script.module.iptvlib/lib/iptvlib/api.py

# coding=utf-8
#
#      Copyright (C) 2018 Dmitry Vinogradov
#      https://github.com/kodi-iptv-addons
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Library General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Library General Public License for more details.
#
# You should have received a copy of the GNU Library General Public
# License along with this library; if not, write to the
# Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
# Boston, MA  02110-1301, USA.
#
import abc
import json
import os
import ssl
import threading
import traceback
import urllib.error
import urllib.parse
import urllib.request
from collections import OrderedDict
from queue import Queue
from threading import Event
from urllib.parse import urlencode
from urllib.request import Request

import xbmc

from . import build_user_agent, log, DAY, time_now, format_date, normalize
from .models import Group, Program, Channel


class ApiException(Exception):
    def __init__(self, message, code, origin_error=None):
        self.message = message
        self.code = code
        self.origin_error = origin_error

    def __repr__(self):
        return "ApiException: (%s) %s" % (self.code, self.message)


class HttpRequest(urllib.request.Request):
    ident = None  # type: str
    method = None  # type: str

    def __init__(self, ident=None, method=None, **kwargs):
        self.ident = ident
        self.method = method
        urllib.request.Request.__init__(self, **kwargs)

    def get_method(self):
        return self.method or urllib.request.Request.get_method(self)

    def __repr__(self):
        return "%s(%r)" % (self.__class__, self.__dict__)


class Api(metaclass=abc.ABCMeta):
    AUTH_STATUS_NONE = 0
    AUTH_STATUS_OK = 1
    AUTH_MAX_ATTEMPTS = 3

    E_UNKNOW_ERROR = 1000
    E_HTTP_REQUEST_FAILED = 1001
    E_JSON_DECODE = 1002
    E_AUTH_ERROR = 1003
    E_API_ERROR = 1004

    auth_status = AUTH_STATUS_NONE  # type: int
    username = None  # type: str
    password = None  # type: str
    sort_channels = None  # type: bool
    working_path = None  # type: str
    cookie_file = None  # type: str
    settings_file = None  # type: str
    _attempt = 0  # type: int
    _groups = None  # type: OrderedDict[str, Group]
    _channels = None  # type: OrderedDict[str, Channel]
    _ident = None  # type: str
    _epg_map = None  # type: dict

    def __init__(self, username=None, password=None, working_path="./", sort_channels=False):
        self.auth_status = self.AUTH_STATUS_NONE
        self.username = self._ident = username
        self.password = password
        self.working_path = working_path
        self.sort_channels = sort_channels
        if not os.path.exists(self.working_path):
            os.makedirs(self.working_path)
        self.cookie_file = os.path.join(self.working_path, "%s.cookie.txt" % self.__class__.__name__)
        self.settings_file = os.path.join(self.working_path, "%s.settings.txt" % self.__class__.__name__)
        self._groups = OrderedDict()
        self._channels = OrderedDict()

    @property
    def client_id(self):
        return "%s:%s" % (self.__class__.__name__, self._ident)

    @property
    def user_agent(self):
        # type: () -> str
        """
        User agent of HTTP client.
        :rtype: str
        """
        return build_user_agent()

    @property
    def groups(self):
        if len(self._groups) == 0:
            self._groups = OrderedDict(sorted(iter(self.get_groups().items()), key=lambda item: item[1].name)) \
                if self.sort_channels else self.get_groups()
            self._channels = OrderedDict()
            for group in list(self._groups.values()):
                channels = OrderedDict(sorted(iter(group.channels.items()), key=lambda item: item[1].name)) \
                    if self.sort_channels else group.channels
                self._channels.update(channels)
        return self._groups

    @property
    def channels(self):
        if len(self._channels) == 0:
            len(self.groups)
        return self._channels

    @property
    def base_api_url(self):
        # type: () -> str
        """
        Base URL of API.
        :rtype: str
        """
        return ""

    @property
    def base_icon_url(self):
        # type: () -> str
        """
        Base URL of channel icons.
        :rtype: str
        """
        return ""

    @property
    def host(self):
        # type: () -> str
        """
        Api hostname.
        :rtype: str
        """
        return ""

    @property
    def diff_live_archive(self):
        # type: () -> int
        """
        Difference between live stream and archive stream in seconds.
        :rtype: int
        """
        return -1

    @property
    def archive_ttl(self):
        # type: () -> int
        """
        Time to live (ttl) of archive streams in seconds.
        :rtype: int
        """
        return -1

    @abc.abstractmethod
    def login(self):
        # type: () -> dict
        """Login to the IPTV service"""
        pass

    @abc.abstractmethod
    def is_login_request(self, uri, payload=None, method=None, headers=None):
        # type: (str, dict, str, dict) -> bool
        """
        Checks whether given URI is used for login
        :rtype: str
        """
        pass

    @abc.abstractmethod
    def get_groups(self):
        # type: () ->  OrderedDict[str, Group]
        """
        Returns the groups from the service
        :rtype: dict[str, Group]
        """
        pass

    @abc.abstractmethod
    def get_stream_url(self, cid, ut_start=None):
        # type: (str, int) -> str
        """
        Returns the stream URL for given channel id and timestamp
        :rtype: str
        """
        pass

    def resolve_url(self, url):
        # type: (str) -> str
        request = self.prepare_request(url)
        try:
            response = urllib.request.urlopen(request, context=ssl.create_default_context())
            return response.url
        except urllib.error.HTTPError:
            return url

    @abc.abstractmethod
    def get_epg(self, cid):
        # type: (str) -> dict[int, Program]
        """
        Returns the EPG for given channel id
        :rtype: dict[int, Program]
        """
        pass

    @abc.abstractmethod
    def get_cookie(self):
        # type: () -> str
        """
        Returns cookie
        :rtype: str
        """
        pass

    def read_cookie_file(self):
        # type: () -> str
        """
        Returns cookie stored in the cookie file
        :rtype: str
        """
        cookie = ""
        if os.path.isfile(self.cookie_file):
            with open(self.cookie_file, 'r') as fh:
                cookie = fh.read()
                fh.close()
        return cookie

    def write_cookie_file(self, data):
        # type: (str) -> None
        """
        Stores cookie to the cookie file
        :rtype: None
        """
        with open(self.cookie_file, 'w') as fh:
            fh.write(data)
            fh.close()

    def read_settings_file(self):
        # type: () -> dict
        """
        Returns settings stored in the settings file
        :rtype: dict
        """
        settings = None
        if os.path.isfile(self.settings_file):
            with open(self.settings_file, 'r') as fh:
                json_string = fh.read()
                fh.close()
                settings = json.loads(json_string)
        return settings

    def write_settings_file(self, data):
        # type: (dict) -> None
        """
        Stores settings to the settings file
        :rtype: None
        """
        with open(self.settings_file, 'w') as fh:
            fh.write(json.dumps(data))
            fh.close()

    def prepare_request(self, uri, payload=None, method="GET", headers=None, ident=None):
        # type: (str, dict, str, dict, str) -> HttpRequest
        url = self.base_api_url % uri if uri.startswith('http') is False else uri
        headers = headers or {}
        headers["User-Agent"] = self.user_agent
        headers["Connection"] = "Close"

        cookie = self.get_cookie()
        if cookie != "" and not self.is_login_request(uri, payload):
            headers["Cookie"] = cookie

        data = None
        if payload:
            if method == "POST":
                if "Content-Type" in headers and headers["Content-Type"] == "application/json":
                    data = json.dumps(payload)
                else:
                    data = urlencode(payload)
            elif method == "GET":
                url += "%s%s" % ("&" if "?" in url else "?", urlencode(payload))
        ident = ident or url
        return HttpRequest(ident=ident, method=method, url=url, headers=headers, data=data)

    def send_request(self, request):
        # type: (Request) -> dict|str
        json_data = ""
        try:
            log("request: %s" % request, xbmc.LOGDEBUG)
            response = urllib.request.urlopen(request)  # type: addinfourl
            content_type = response.headers.get("content-type")  # type: str
            content = response.read()
            if not content_type.startswith("application/json"):
                return content
            response = json.loads(content)
        except urllib.error.URLError as ex:
            log("Exception %s: message=%s" % (type(ex), ex))
            log(traceback.format_exc(), xbmc.LOGDEBUG)
            response = {
                "__error": {
                    "message": str(ex),
                    "code": self.E_HTTP_REQUEST_FAILED,
                    "details": {
                        "url": request.get_full_url(),
                        "data": request.data,
                        "headers": request.headers
                    },
                }
            }
            pass
        except ValueError as ex:
            log("Exception %s: message=%s" % (type(ex), ex))
            log(traceback.format_exc(), xbmc.LOGDEBUG)
            response = {
                "__error": {
                    "message": "Unable decode server response: %s" % str(ex),
                    "code": self.E_JSON_DECODE,
                    "details": {
                        "response": json_data
                    }
                }
            }
            pass
        except Exception as ex:
            log("Exception %s: message=%s" % (type(ex), ex))
            log(traceback.format_exc(), xbmc.LOGDEBUG)
            response = {
                "__error": {
                    "message": "%s: %s" % (type(ex), str(ex)),
                    "code": self.E_UNKNOW_ERROR
                }
            }
            pass
        return response

    def make_request(self, uri, payload=None, method="GET", headers=None):
        # type: (str, dict, str, dict) -> dict
        """
        Makes HTTP request to the IPTV API
        :param uri: URL of the IPTV API
        :param payload: Payload data
        :param method: HTTP method
        :param headers: Additional HTTP headers
        :return:
        """
        if self.auth_status != self.AUTH_STATUS_OK and not self.is_login_request(uri, payload, method, headers):
            self.login()
            return self.make_request(uri, payload, method, headers)

        request = self.prepare_request(uri, payload, method, headers)
        response = self.send_request(request)

        if "__error" in response:
            if self.is_login_request(uri, payload):
                self.auth_status = self.AUTH_STATUS_NONE
                try:
                    os.remove(self.cookie_file)
                except OSError:
                    pass

        return response

    def do_send_request(self, queue, results, stop_event, wait=None):
        # type: (Queue, dict[str, dict], Event, float) -> None
        while not stop_event.is_set():
            request = queue.get()  # type: HttpRequest
            results[request.ident] = self.send_request(request)
            queue.task_done()
            stop_event.wait(wait)

    def send_parallel_requests(self, requests, wait=None, num_threads=None):
        # type: (list[HttpRequest], float, int) -> dict[str, dict]
        num_threads = len(requests) if num_threads is None else num_threads
        queue = Queue(num_threads * 2)
        results = dict()

        stop_event = threading.Event()
        for i in range(num_threads):
            thread = threading.Thread(target=self.do_send_request, args=(queue, results, stop_event, wait,))
            thread.setDaemon(True)
            thread.start()

        for req in requests:
            queue.put(req)
        queue.join()

        while queue.unfinished_tasks > 0:
            continue

        stop_event.set()

        return results

    def get_epg_gh(self, channel):
        # type: (Channel) -> OrderedDict[int, Program]

        programs = OrderedDict()

        if self._epg_map is None:
            self._epg_map = self.make_request("https://kodi-iptv-addons.github.io/EPG/map.json?%s" % time_now())

        norm = normalize(channel.name)
        if (norm in self._epg_map) is False:
            return programs

        cid = self._epg_map.get(norm)

        requests = []
        days = (self.archive_ttl // DAY) + 5
        start = int(time_now() - self.archive_ttl)
        for i in range(days):
            day = format_date(start + (i * DAY), custom_format="%Y-%m-%d")
            request = self.prepare_request(
                "https://kodi-iptv-addons.github.io/EPG/%s/%s.json" % (cid, day)
            )
            requests.append(request)

        results = self.send_parallel_requests(requests)

        epg = dict()
        for key in sorted(results.keys()):
            response = results[key]
            is_error, error = Api.is_error_response(response)
            if is_error:
                log("error: %s" % error if is_error else response, xbmc.LOGDEBUG)
                return programs
            for k, v in response.items():
                epg[int(k)] = v

        prev = None  # type: Program
        for key in sorted(epg.keys()):
            val = epg[key]
            program = Program(
                channel.cid,
                channel.gid,
                val["start"],
                val["stop"],
                val["title"],
                val["descr"],
                channel.archive,
                val["image"]
            )
            if prev is not None:
                program.prev_program = prev
                prev.next_program = program
            programs[program.ut_start] = prev = program
        return programs

    @staticmethod
    def is_error_response(response):
        # type: (dict) -> (bool, dict or None)
        if "__error" in response:
            return True, response["__error"]
        return False, None