Move custom libs to libs/custom

libs/custom/synchronousdeluge/__init__.py

@@ -0,0 +1,23 @@
+# coding=utf-8
+"""A synchronous implementation of the Deluge RPC protocol
+   based on gevent-deluge by Christopher Rosell.
+   
+   https://github.com/chrippa/gevent-deluge
+
+Example usage:
+
+    from synchronousdeluge import DelgueClient
+
+    client = DelugeClient()
+    client.connect()
+
+    # Wait for value
+    download_location = client.core.get_config_value("download_location").get()
+"""
+
+from .exceptions import DelugeRPCError
+
+
+__title__ = "synchronous-deluge"
+__version__ = "0.1"
+__author__ = "Christian Dale"

libs/custom/synchronousdeluge/client.py

@@ -0,0 +1,162 @@
+# coding=utf-8
+import os
+import platform
+from collections import defaultdict
+
+from six.moves import map as imap
+
+from .exceptions import DelugeRPCError
+from .protocol import DelugeRPCRequest, DelugeRPCResponse
+from .transfer import DelugeTransfer
+
+__all__ = ["DelugeClient"]
+
+RPC_RESPONSE = 1
+RPC_ERROR = 2
+RPC_EVENT = 3
+
+
+class DelugeClient(object):
+    def __init__(self):
+        """A deluge client session."""
+        self.transfer = DelugeTransfer()
+        self.modules = []
+        self._request_counter = 0
+
+    def _get_local_auth(self):
+        username = password = ""
+        if platform.system() in ('Windows', 'Microsoft'):
+            appDataPath = os.environ.get("APPDATA")
+            if not appDataPath:
+                from six.moves import winreg
+                hkey = winreg.OpenKey(
+                    winreg.HKEY_CURRENT_USER,
+                    "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders",
+                )
+                appDataReg = winreg.QueryValueEx(hkey, "AppData")
+                appDataPath = appDataReg[0]
+                winreg.CloseKey(hkey)
+
+            auth_file = os.path.join(appDataPath, "deluge", "auth")
+        else:
+            from xdg.BaseDirectory import save_config_path
+            try:
+                auth_file = os.path.join(save_config_path("deluge"), "auth")
+            except OSError:
+                return username, password
+
+        if os.path.exists(auth_file):
+            for line in open(auth_file):
+                if line.startswith("#"):
+                    # This is a comment line
+                    continue
+                line = line.strip()
+                try:
+                    lsplit = line.split(":")
+                except Exception:
+                    continue
+
+                if len(lsplit) == 2:
+                    username, password = lsplit
+                elif len(lsplit) == 3:
+                    username, password, level = lsplit
+                else:
+                    continue
+
+                if username == "localclient":
+                    return username, password
+
+        return "", ""
+
+    def _create_module_method(self, module, method):
+        fullname = "{0}.{1}".format(module, method)
+
+        def func(obj, *args, **kwargs):
+            return self.remote_call(fullname, *args, **kwargs)
+
+        func.__name__ = method
+
+        return func
+
+    def _introspect(self):
+        self.modules = []
+
+        methods = self.remote_call("daemon.get_method_list").get()
+        methodmap = defaultdict(dict)
+        splitter = lambda v: v.split(".")
+
+        for module, method in imap(splitter, methods):
+            methodmap[module][method] = self._create_module_method(module, method)
+
+        for module, methods in methodmap.items():
+            clsname = "DelugeModule{0}".format(module.capitalize())
+            cls = type(clsname, (), methods)
+            setattr(self, module, cls())
+            self.modules.append(module)
+
+    def remote_call(self, method, *args, **kwargs):
+        req = DelugeRPCRequest(self._request_counter, method, *args, **kwargs)
+        message = next(self.transfer.send_request(req))
+
+        response = DelugeRPCResponse()
+
+        if not isinstance(message, tuple):
+            return
+
+        if len(message) < 3:
+            return
+
+        message_type = message[0]
+
+        #        if message_type == RPC_EVENT:
+        #            event = message[1]
+        #            values = message[2]
+        #
+        #            if event in self._event_handlers:
+        #                for handler in self._event_handlers[event]:
+        #                    gevent.spawn(handler, *values)
+        #
+        #        elif message_type in (RPC_RESPONSE, RPC_ERROR):
+        if message_type in (RPC_RESPONSE, RPC_ERROR):
+            request_id = message[1]
+            value = message[2]
+
+            if request_id == self._request_counter:
+                if message_type == RPC_RESPONSE:
+                    response.set(value)
+                elif message_type == RPC_ERROR:
+                    err = DelugeRPCError(*value)
+                    response.set_exception(err)
+
+        self._request_counter += 1
+        return response
+
+    def connect(self, host="127.0.0.1", port=58846, username="", password=""):
+        """Connects to a daemon process.
+
+        :param host: str, the hostname of the daemon
+        :param port: int, the port of the daemon
+        :param username: str, the username to login with
+        :param password: str, the password to login with
+        """
+
+        # Connect transport
+        self.transfer.connect((host, port))
+
+        # Attempt to fetch local auth info if needed
+        if not username and host in ("127.0.0.1", "localhost"):
+            username, password = self._get_local_auth()
+
+        # Authenticate
+        self.remote_call("daemon.login", username, password).get()
+
+        # Introspect available methods
+        self._introspect()
+
+    @property
+    def connected(self):
+        return self.transfer.connected
+
+    def disconnect(self):
+        """Disconnects from the daemon."""
+        self.transfer.disconnect()

libs/custom/synchronousdeluge/exceptions.py

@@ -0,0 +1,11 @@
+# coding=utf-8
+
+
+class DelugeRPCError(Exception):
+    def __init__(self, name, msg, traceback):
+        self.name = name
+        self.msg = msg
+        self.traceback = traceback
+
+    def __str__(self):
+        return "{0}: {1}: {2}".format(self.__class__.__name__, self.name, self.msg)

libs/custom/synchronousdeluge/protocol.py

@@ -0,0 +1,39 @@
+# coding=utf-8
+
+
+class DelugeRPCRequest(object):
+    def __init__(self, request_id, method, *args, **kwargs):
+        self.request_id = request_id
+        self.method = method
+        self.args = args
+        self.kwargs = kwargs
+
+    def format(self):
+        return self.request_id, self.method, self.args, self.kwargs
+
+
+class DelugeRPCResponse(object):
+    def __init__(self):
+        self.value = None
+        self._exception = None
+
+    def successful(self):
+        return self._exception is None
+
+    @property
+    def exception(self):
+        if self._exception is not None:
+            return self._exception
+
+    def set(self, value=None):
+        self.value = value
+        self._exception = None
+
+    def set_exception(self, exception):
+        self._exception = exception
+
+    def get(self):
+        if self._exception is None:
+            return self.value
+        else:
+            raise self._exception

libs/custom/synchronousdeluge/transfer.py

@@ -0,0 +1,56 @@
+# coding=utf-8
+import socket
+import ssl
+import struct
+import zlib
+
+import rencode
+
+__all__ = ["DelugeTransfer"]
+
+
+class DelugeTransfer(object):
+    def __init__(self):
+        self.sock = None
+        self.conn = None
+        self.connected = False
+
+    def connect(self, hostport):
+        if self.connected:
+            self.disconnect()
+
+        self.sock = socket.create_connection(hostport)
+        self.conn = ssl.wrap_socket(self.sock, None, None, False, ssl.CERT_NONE, ssl.PROTOCOL_TLSv1)
+        self.connected = True
+
+    def disconnect(self):
+        if self.conn:
+            self.conn.close()
+            self.connected = False
+
+    def send_request(self, request):
+        data = (request.format(),)
+        payload = zlib.compress(rencode.dumps(data))
+        self.conn.sendall(payload)
+
+        buf = b""
+
+        while True:
+            data = self.conn.recv(1024)
+
+            if not data:
+                self.connected = False
+                break
+
+            buf += data
+            dobj = zlib.decompressobj()
+
+            try:
+                message = rencode.loads(dobj.decompress(buf))
+            except (ValueError, zlib.error, struct.error):
+                # Probably incomplete data, read more
+                continue
+            else:
+                buf = dobj.unused_data
+
+            yield message

libs/custom/utorrent/__init__.py

@@ -0,0 +1 @@
+# coding=utf-8

libs/custom/utorrent/client.py

@@ -0,0 +1,150 @@
+# coding=utf8
+import re
+
+from six import StringIO, iteritems
+from six.moves.http_cookiejar import CookieJar
+from six.moves.urllib.request import (
+    HTTPBasicAuthHandler,
+    HTTPCookieProcessor,
+    Request,
+    build_opener,
+    install_opener,
+)
+from six.moves.urllib_parse import urlencode, urljoin
+
+from .upload import MultiPartForm
+
+try:
+    import json
+except ImportError:
+    import simplejson as json
+
+class UTorrentClient(object):
+
+    def __init__(self, base_url, username, password):
+        self.base_url = base_url
+        self.username = username
+        self.password = password
+        self.opener = self._make_opener('uTorrent', base_url, username, password)
+        self.token = self._get_token()
+        #TODO refresh token, when necessary
+
+    def _make_opener(self, realm, base_url, username, password):
+        '''uTorrent API need HTTP Basic Auth and cookie support for token verify.'''
+
+        auth_handler = HTTPBasicAuthHandler()
+        auth_handler.add_password(realm=realm,
+                                  uri=base_url,
+                                  user=username,
+                                  passwd=password)
+        opener = build_opener(auth_handler)
+        install_opener(opener)
+
+        cookie_jar = CookieJar()
+        cookie_handler = HTTPCookieProcessor(cookie_jar)
+
+        handlers = [auth_handler, cookie_handler]
+        opener = build_opener(*handlers)
+        return opener
+
+    def _get_token(self):
+        url = urljoin(self.base_url, 'token.html')
+        response = self.opener.open(url)
+        token_re = "<div id='token' style='display:none;'>([^<>]+)</div>"
+        match = re.search(token_re, response.read())
+        return match.group(1)
+
+    def list(self, **kwargs):
+        params = [('list', '1')]
+        params += kwargs.items()
+        return self._action(params)
+
+    def start(self, *hashes):
+        params = [('action', 'start'),]
+        for hash in hashes:
+            params.append(('hash', hash))
+        return self._action(params)
+
+    def stop(self, *hashes):
+        params = [('action', 'stop'),]
+        for hash in hashes:
+            params.append(('hash', hash))
+        return self._action(params)
+
+    def pause(self, *hashes):
+        params = [('action', 'pause'),]
+        for hash in hashes:
+            params.append(('hash', hash))
+        return self._action(params)
+
+    def forcestart(self, *hashes):
+        params = [('action', 'forcestart'),]
+        for hash in hashes:
+            params.append(('hash', hash))
+        return self._action(params)
+
+    def getfiles(self, hash):
+        params = [('action', 'getfiles'), ('hash', hash)]
+        return self._action(params)
+
+    def getprops(self, hash):
+        params = [('action', 'getprops'), ('hash', hash)]
+        return self._action(params)
+
+    def setprops(self, hash, **kvpairs):
+        params = [('action', 'setprops'), ('hash', hash)]
+        for k, v in iteritems(kvpairs):
+            params.append( ("s", k) )
+            params.append( ("v", v) )
+
+        return self._action(params)
+
+    def setprio(self, hash, priority, *files):
+        params = [('action', 'setprio'), ('hash', hash), ('p', str(priority))]
+        for file_index in files:
+            params.append(('f', str(file_index)))
+
+        return self._action(params)
+
+    def addfile(self, filename, filepath=None, bytes=None):
+        params = [('action', 'add-file')]
+
+        form = MultiPartForm()
+        if filepath is not None:
+            file_handler = open(filepath,'rb')
+        else:
+            file_handler = StringIO(bytes)
+
+        form.add_file('torrent_file', filename.encode('utf-8'), file_handler)
+
+        return self._action(params, str(form), form.get_content_type())
+
+    def addurl(self, url):
+        params = [('action', 'add-url'), ('s', url)]
+        self._action(params)
+
+    def remove(self, *hashes):
+        params = [('action', 'remove'),]
+        for hash in hashes:
+            params.append(('hash', hash))
+        return self._action(params)
+
+    def removedata(self, *hashes):
+        params = [('action', 'removedata'),]
+        for hash in hashes:
+            params.append(('hash', hash))
+        return self._action(params)
+
+    def _action(self, params, body=None, content_type=None):
+        #about token, see https://github.com/bittorrent/webui/wiki/TokenSystem
+        url = self.base_url + '?token=' + self.token + '&' + urlencode(params)
+        request = Request(url)
+
+        if body:
+            request.data = body
+            request.add_header('Content-length', len(body))
+        if content_type:
+            request.add_header('Content-type', content_type)
+
+        response = self.opener.open(request)
+        return response.code, json.loads(response.read())

libs/custom/utorrent/upload.py

@@ -0,0 +1,70 @@
+# coding=utf-8
+# code copied from http://www.doughellmann.com/PyMOTW/urllib2/
+
+import itertools
+import mimetypes
+from email.generator import _make_boundary as choose_boundary
+
+
+class MultiPartForm(object):
+    """Accumulate the data to be used when posting a form."""
+
+    def __init__(self):
+        self.form_fields = []
+        self.files = []
+        self.boundary = choose_boundary()
+        return
+
+    def get_content_type(self):
+        return 'multipart/form-data; boundary=%s' % self.boundary
+
+    def add_field(self, name, value):
+        """Add a simple field to the form data."""
+        self.form_fields.append((name, value))
+        return
+
+    def add_file(self, fieldname, filename, fileHandle, mimetype=None):
+        """Add a file to be uploaded."""
+        body = fileHandle.read()
+        if mimetype is None:
+            mimetype = mimetypes.guess_type(filename)[0] or 'application/octet-stream'
+        self.files.append((fieldname, filename, mimetype, body))
+        return
+
+    def __str__(self):
+        """Return a string representing the form data, including attached files."""
+        # Build a list of lists, each containing "lines" of the
+        # request.  Each part is separated by a boundary string.
+        # Once the list is built, return a string where each
+        # line is separated by '\r\n'.  
+        parts = []
+        part_boundary = '--' + self.boundary
+
+        # Add the form fields
+        parts.extend(
+            [ part_boundary,
+              'Content-Disposition: form-data; name="%s"' % name,
+              '',
+              value,
+            ]
+            for name, value in self.form_fields
+            )
+
+        # Add the files to upload
+        parts.extend(
+            [ part_boundary,
+              'Content-Disposition: file; name="%s"; filename="%s"' % \
+                 (field_name, filename),
+              'Content-Type: %s' % content_type,
+              '',
+              body,
+            ]
+            for field_name, filename, content_type, body in self.files
+            )
+
+        # Flatten the list and add closing boundary marker,
+        # then return CR+LF separated data
+        flattened = list(itertools.chain(*parts))
+        flattened.append('--' + self.boundary + '--')
+        flattened.append('')
+        return '\r\n'.join(flattened)