Вроде, можно тестировать

lib/pyrrent2http/download.py

@@ -1,65 +0,0 @@
-#import sys
-import os
-import xbmc, xbmcgui, xbmcvfs, xbmcaddon
-from net import HTTP
-
-__libbaseurl__ = "https://github.com/DiMartinoXBMC/script.module.torrent2http/raw/master/bin"
-__settings__ = xbmcaddon.Addon(id='script.module.torrent2http')
-__version__ = __settings__.getAddonInfo('version')
-__plugin__ = __settings__.getAddonInfo('name') + " v." + __version__
-
-def get_libname(platform):
-    return ["torrent2http" + (".exe" if 'windows' in platform else "")]
-
-def log(msg):
-    try:
-        xbmc.log("### [%s]: %s" % (__plugin__,msg,), level=xbmc.LOGNOTICE )
-    except UnicodeEncodeError:
-        xbmc.log("### [%s]: %s" % (__plugin__,msg.encode("utf-8", "ignore"),), level=xbmc.LOGNOTICE )
-    except:
-        xbmc.log("### [%s]: %s" % (__plugin__,'ERROR LOG',), level=xbmc.LOGNOTICE )
-
-def getSettingAsBool(setting):
-    return __settings__.getSetting(setting).lower() == "true"
-
-class LibraryManager():
-    def __init__(self, dest_path, platform):
-        self.dest_path = dest_path
-        self.platform = platform
-
-    def check_update(self):
-        need_update=False
-        if __settings__.getSetting('plugin_name')!=__plugin__:
-            __settings__.setSetting('plugin_name', __plugin__)
-            for libname in get_libname(self.platform):
-                self.libpath = os.path.join(self.dest_path, libname)
-                self.sizepath=os.path.join(self.dest_path, libname+'.size.txt')
-                size=str(os.path.getsize(self.libpath))
-                size_old=open( self.sizepath, "r" ).read()
-                if size_old!=size:
-                    need_update=True
-        return need_update
-
-    def update(self):
-        if self.check_update():
-            for libname in get_libname(self.platform):
-                self.libpath = os.path.join(self.dest_path, libname)
-                xbmcvfs.delete(self.libpath)
-            self.download()
-
-    def download(self):
-        xbmcvfs.mkdirs(self.dest_path)
-        for libname in get_libname(self.platform):
-            dest = os.path.join(self.dest_path, libname)
-            log("try to fetch %s" % libname)
-            url = "%s/%s/%s.zip" % (__libbaseurl__, self.platform, libname)
-            try:
-                self.http = HTTP()
-                self.http.fetch(url, download=dest + ".zip", progress=True)
-                log("%s -> %s" % (url, dest))
-                xbmc.executebuiltin('XBMC.Extract("%s.zip","%s")' % (dest, self.dest_path), True)
-                xbmcvfs.delete(dest + ".zip")
-            except:
-                text = 'Failed download %s!' % libname
-                xbmc.executebuiltin("XBMC.Notification(%s,%s,%s)" % (__plugin__,text,750))
-        return True

lib/pyrrent2http/engine.py

@@ -441,13 +441,13 @@ class Engine:
     def is_alive(self):
         return self.pyrrent2http_loop.is_alive()
 
-    @staticmethod
+    __to_del = '''@staticmethod
     def _decode(response):
         try:
             return json.loads(response)
         except (KeyError, ValueError), e:
             raise Error("Can't decode response from pyrrent2http: %r" % e, Error.REQUEST_ERROR)
-
+'''
     __to_del = '''def _request(self, cmd, timeout=None):
         if not self.started:
             raise Error("pyrrent2http is not started", Error.REQUEST_ERROR)
@@ -483,27 +483,28 @@ class Engine:
         Shuts down pyrrent2http and stops logging. If wait_on_close() was called earlier, it will wait until
         pyrrent2http successfully exits.
         """
-        if self.logpipe and self.wait_on_close_timeout is None:
+#        if self.logpipe and self.wait_on_close_timeout is None:
-            self.logpipe.close()
+#            self.logpipe.close()
         if self.is_alive():
             self._log("Shutting down pyrrent2http...")
-            self._request('shutdown')
+#           self._request('shutdown')
+            self.pyrrent2http.shutdown()
             finished = False
             if self.wait_on_close_timeout is not None:
                 start = time.time()
-                os.close(self.logpipe.write_fd)
+#                os.close(self.logpipe.write_fd)
                 while (time.time() - start) < self.wait_on_close_timeout:
                     time.sleep(0.5)
                     if not self.is_alive():
                         finished = True
                         break
                 if not finished:
-                    self._log("Timeout occurred while shutting down pyrrent2http, killing it")
+                    self._log("PANIC: Timeout occurred while shutting down pyrrent2http thread")
-                    self.process.kill()
+                    #self.process.kill()
                 else:
                     self._log("pyrrent2http successfully shut down.")
                 self.wait_on_close_timeout = None
-            self.process.wait()
+#            self.process.wait()
         self.started = False
         self.logpipe = None
         self.process = None

lib/pyrrent2http/logpipe.py

@@ -1,33 +0,0 @@
-import os
-import threading
-import re
-
-
-class LogPipe(threading.Thread):
-
-    def __init__(self, logger):
-        threading.Thread.__init__(self)
-        self.daemon = False
-        self.logger = logger
-        self.read_fd, self.write_fd = os.pipe()
-        self.stop = threading.Event()
-        self.start()
-
-    def fileno(self):
-        return self.write_fd
-
-    def run(self):
-        self.logger("Logging thread started.")
-        with os.fdopen(self.read_fd) as f:
-            for line in iter(f.readline, ""):
-                line = re.sub(r'^\d+/\d+/\d+ \d+:\d+:\d+ ', '', line)
-                self.logger(line.strip())
-                if self.stop.is_set():
-                    break
-        self.logger("Logging thread finished.")
-
-    def close(self):
-        self.stop.set()
-        f = os.fdopen(self.write_fd, "w")
-        f.write("Stopping logging thread...\n")
-        f.close()

lib/pyrrent2http/net.py

@@ -1,297 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import os
-import time
-import re
-import urllib
-import urllib2
-import cookielib
-import base64
-import mimetools
-import itertools
-
-import xbmc
-import xbmcgui
-import xbmcvfs
-
-RE = {
-    'content-disposition': re.compile('attachment;\sfilename="*([^"\s]+)"|\s')
-}
-
-# ################################
-#
-# HTTP
-#
-# ################################
-
-class HTTP:
-    def __init__(self):
-        self._dirname = xbmc.translatePath('special://temp')
-        for subdir in ('xbmcup', 'script.module.libtorrent'):
-            self._dirname = os.path.join(self._dirname, subdir)
-            if not xbmcvfs.exists(self._dirname):
-                xbmcvfs.mkdir(self._dirname)
-
-    def fetch(self, request, **kwargs):
-        self.con, self.fd, self.progress, self.cookies, self.request = None, None, None, None, request
-
-        if not isinstance(self.request, HTTPRequest):
-            self.request = HTTPRequest(url=self.request, **kwargs)
-
-        self.response = HTTPResponse(self.request)
-
-        xbmc.log('XBMCup: HTTP: request: ' + str(self.request), xbmc.LOGDEBUG)
-
-        try:
-            self._opener()
-            self._fetch()
-        except Exception, e:
-            xbmc.log('XBMCup: HTTP: ' + str(e), xbmc.LOGERROR)
-            if isinstance(e, urllib2.HTTPError):
-                self.response.code = e.code
-            self.response.error = e
-        else:
-            self.response.code = 200
-
-        if self.fd:
-            self.fd.close()
-            self.fd = None
-
-        if self.con:
-            self.con.close()
-            self.con = None
-
-        if self.progress:
-            self.progress.close()
-            self.progress = None
-
-        self.response.time = time.time() - self.response.time
-
-        xbmc.log('XBMCup: HTTP: response: ' + str(self.response), xbmc.LOGDEBUG)
-
-        return self.response
-
-    def _opener(self):
-
-        build = [urllib2.HTTPHandler()]
-
-        if self.request.redirect:
-            build.append(urllib2.HTTPRedirectHandler())
-
-        if self.request.proxy_host and self.request.proxy_port:
-            build.append(urllib2.ProxyHandler(
-                {self.request.proxy_protocol: self.request.proxy_host + ':' + str(self.request.proxy_port)}))
-
-            if self.request.proxy_username:
-                proxy_auth_handler = urllib2.ProxyBasicAuthHandler()
-                proxy_auth_handler.add_password('realm', 'uri', self.request.proxy_username,
-                                                self.request.proxy_password)
-                build.append(proxy_auth_handler)
-
-        if self.request.cookies:
-            self.request.cookies = os.path.join(self._dirname, self.request.cookies)
-            self.cookies = cookielib.MozillaCookieJar()
-            if os.path.isfile(self.request.cookies):
-                self.cookies.load(self.request.cookies)
-            build.append(urllib2.HTTPCookieProcessor(self.cookies))
-
-        urllib2.install_opener(urllib2.build_opener(*build))
-
-    def _fetch(self):
-        params = {} if self.request.params is None else self.request.params
-
-        if self.request.upload:
-            boundary, upload = self._upload(self.request.upload, params)
-            req = urllib2.Request(self.request.url)
-            req.add_data(upload)
-        else:
-
-            if self.request.method == 'POST':
-                if isinstance(params, dict) or isinstance(params, list):
-                    params = urllib.urlencode(params)
-                req = urllib2.Request(self.request.url, params)
-            else:
-                req = urllib2.Request(self.request.url)
-
-        for key, value in self.request.headers.iteritems():
-            req.add_header(key, value)
-
-        if self.request.upload:
-            req.add_header('Content-type', 'multipart/form-data; boundary=%s' % boundary)
-            req.add_header('Content-length', len(upload))
-
-        if self.request.auth_username and self.request.auth_password:
-            req.add_header('Authorization', 'Basic %s' % base64.encodestring(
-                ':'.join([self.request.auth_username, self.request.auth_password])).strip())
-
-        self.con = urllib2.urlopen(req, timeout=self.request.timeout)
-        # self.con = urllib2.urlopen(req)
-        self.response.headers = self._headers(self.con.info())
-
-        if self.request.download:
-            self._download()
-        else:
-            self.response.body = self.con.read()
-
-        if self.request.cookies:
-            self.cookies.save(self.request.cookies)
-
-    def _download(self):
-        fd = open(self.request.download, 'wb')
-        if self.request.progress:
-            self.progress = xbmcgui.DialogProgress()
-            self.progress.create(u'Download')
-
-        bs = 1024 * 8
-        size = -1
-        read = 0
-        name = None
-
-        if self.request.progress:
-            if 'content-length' in self.response.headers:
-                size = int(self.response.headers['content-length'])
-            if 'content-disposition' in self.response.headers:
-                r = RE['content-disposition'].search(self.response.headers['content-disposition'])
-                if r:
-                    name = urllib.unquote(r.group(1))
-
-        while 1:
-            buf = self.con.read(bs)
-            if buf == '':
-                break
-            read += len(buf)
-            fd.write(buf)
-
-            if self.request.progress:
-                self.progress.update(*self._progress(read, size, name))
-
-        self.response.filename = self.request.download
-
-    def _upload(self, upload, params):
-        res = []
-        boundary = mimetools.choose_boundary()
-        part_boundary = '--' + boundary
-
-        if params:
-            for name, value in params.iteritems():
-                res.append([part_boundary, 'Content-Disposition: form-data; name="%s"' % name, '', value])
-
-        if isinstance(upload, dict):
-            upload = [upload]
-
-        for obj in upload:
-            name = obj.get('name')
-            filename = obj.get('filename', 'default')
-            content_type = obj.get('content-type')
-            try:
-                body = obj['body'].read()
-            except AttributeError:
-                body = obj['body']
-
-            if content_type:
-                res.append([part_boundary,
-                            'Content-Disposition: file; name="%s"; filename="%s"' % (name, urllib.quote(filename)),
-                            'Content-Type: %s' % content_type, '', body])
-            else:
-                res.append([part_boundary,
-                            'Content-Disposition: file; name="%s"; filename="%s"' % (name, urllib.quote(filename)), '',
-                            body])
-
-        result = list(itertools.chain(*res))
-        result.append('--' + boundary + '--')
-        result.append('')
-        return boundary, '\r\n'.join(result)
-
-    def _headers(self, raw):
-        headers = {}
-        for line in raw.headers:
-            pair = line.split(':', 1)
-            if len(pair) == 2:
-                tag = pair[0].lower().strip()
-                value = pair[1].strip()
-                if tag and value:
-                    headers[tag] = value
-        return headers
-
-    def _progress(self, read, size, name):
-        res = []
-        if size < 0:
-            res.append(1)
-        else:
-            res.append(int(float(read) / (float(size) / 100.0)))
-        if name:
-            res.append(u'File: ' + name)
-        if size != -1:
-            res.append(u'Size: ' + self._human(size))
-        res.append(u'Load: ' + self._human(read))
-        return res
-
-    def _human(self, size):
-        human = None
-        for h, f in (('KB', 1024), ('MB', 1024 * 1024), ('GB', 1024 * 1024 * 1024), ('TB', 1024 * 1024 * 1024 * 1024)):
-            if size / f > 0:
-                human = h
-                factor = f
-            else:
-                break
-        if human is None:
-            return (u'%10.1f %s' % (size, u'byte')).replace(u'.0', u'')
-        else:
-            return u'%10.2f %s' % (float(size) / float(factor), human)
-
-
-class HTTPRequest:
-    def __init__(self, url, method='GET', headers=None, cookies=None, params=None, upload=None, download=None,
-                 progress=False, auth_username=None, auth_password=None, proxy_protocol='http', proxy_host=None,
-                 proxy_port=None, proxy_username=None, proxy_password='', timeout=20.0, redirect=True, gzip=False):
-        if headers is None:
-            headers = {}
-
-        self.url = url
-        self.method = method
-        self.headers = headers
-
-        self.cookies = cookies
-
-        self.params = params
-
-        self.upload = upload
-        self.download = download
-        self.progress = progress
-
-        self.auth_username = auth_username
-        self.auth_password = auth_password
-
-        self.proxy_protocol = proxy_protocol
-        self.proxy_host = proxy_host
-        self.proxy_port = proxy_port
-        self.proxy_username = proxy_username
-        self.proxy_password = proxy_password
-
-        self.timeout = timeout
-
-        self.redirect = redirect
-
-        self.gzip = gzip
-
-    def __repr__(self):
-        return '%s(%s)' % (self.__class__.__name__, ','.join('%s=%r' % i for i in self.__dict__.iteritems()))
-
-
-class HTTPResponse:
-    def __init__(self, request):
-        self.request = request
-        self.code = None
-        self.headers = {}
-        self.error = None
-        self.body = None
-        self.filename = None
-        self.time = time.time()
-
-    def __repr__(self):
-        args = ','.join('%s=%r' % i for i in self.__dict__.iteritems() if i[0] != 'body')
-        if self.body:
-            args += ',body=<data>'
-        else:
-            args += ',body=None'
-        return '%s(%s)' % (self.__class__.__name__, args)

lib/pyrrent2http/pyrrent2http.py

@@ -3,15 +3,19 @@
 import argparse
 import sys, os
 import json
+
 try:
-    import libtorrent as lt
+    import xbmcgui
-except:
+    from python_libtorrent import get_libtorrent
+    lt=get_libtorrent()
+    print('Imported libtorrent v%s from python_libtorrent' %(lt.version, ))
+except Exception, e:
+    print('Error importing python_libtorrent.Exception: %s' %(str(e),))
     try:
-        sys.path.append(os.path.dirname(os.path.realpath(__file__)))
         import libtorrent as lt
     except Exception as e:
         strerror = e.args
-        logging.error(strerror)
+        print(strerror)
         sys.exit(1)
 from random import SystemRandom
 import time