SickGear/lib/rtorrent/rpc/__init__.py

# Copyright (c) 2013 Chris Lucas, <chris@chrisjlucas.com>
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
# distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so, subject to
# the following conditions:
#
# The above copyright notice and this permission notice shall be
# included in all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS",  WITHOUT WARRANTY OF ANY KIND,
# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

from ..common import bool_to_int, convert_version_tuple_to_str, safe_repr
from ..compat import xmlrpclib
from ..err import MethodError

import inspect
import re

import rtorrent


def get_varname(rpc_call):
    """Transform rpc method into variable name.

    @newfield example: Example
    @example: if the name of the rpc method is 'p.get_down_rate', the variable
    name will be 'down_rate'
    """
    # extract variable name from xmlrpc func name
    r = re.search(
        r'(^([dtfp]|system)\.|(is|[sg]et)_)+([^=]*?)(?:=|.[sg]et)?$', rpc_call, re.I)
    if r:
        return r.groups()[-1]


def _handle_unavailable_rpc_method(method, rt_obj):
    msg = 'Method isn\'t available.'
    if rt_obj.get_client_version_tuple() < method.min_version:
        msg = 'This method is only available in ' \
              'RTorrent version v{0} or later'.format(convert_version_tuple_to_str(method.min_version))

    raise MethodError(msg)


class DummyClass(object):
    def __init__(self):
        pass


class Method(object):
    """Represents an individual RPC method"""

    def __init__(self, _class, method_name, rpc_call, docstring=None, **kwargs):
        self._class = _class  # : Class this method is associated with
        self.class_name = _class.__name__
        self.method_name = method_name  # : name of public-facing method
        self.rpc_call = rpc_call  # : name of rpc method
        self.docstring = docstring  # : docstring for rpc method (optional)
        self.min_version = kwargs.get('min_version', (0, 0, 0))  # : Minimum version of rTorrent required
        self.boolean = kwargs.get('boolean', False)  # : returns boolean value?
        self.post_process_func = kwargs.get('post_process_func', None)  # : custom post process function
        self.aliases = kwargs.get('aliases', [])  # : aliases for method (optional)
        self.required_args = []  # : Arguments required when calling the method (not utilized)
        self.method_type = self._get_method_type()
        self.varname = None  # : variable for the result of the method call, usually set to self.varname

    def __repr__(self):
        return safe_repr('Method(method_name="{0}", rpc_call="{1}")', self.method_name, self.rpc_call)

    def _get_method_type(self):
        """Determine whether method is a modifier or a retriever"""
        if 'set_' == self.method_name[:4]:
            return 'm'  # modifier
        return 'r'  # retriever

    def is_modifier(self):
        return 'm' == self.method_type

    def is_retriever(self):
        return 'r' == self.method_type

    def is_available(self, rt_obj):

        if rt_obj.get_client_version_tuple() >= self.min_version:
            try:
                self.varname = get_varname(next(filter(lambda f: rt_obj.method_exists(f),
                                                       (self.rpc_call,) + tuple(getattr(self, 'aliases', '')))))
                return True
            except (BaseException, Exception):
                pass

        return False


class Multicall(object):
    # noinspection PyUnusedLocal
    def __init__(self, class_obj, **kwargs):
        self.class_obj = class_obj
        if 'RTorrent' == class_obj.__class__.__name__:
            self.rt_obj = class_obj
        else:
            # noinspection PyProtectedMember
            self.rt_obj = class_obj._rt_obj
        self.calls = []

    def add(self, method, *args):
        """Add call to multicall

        @param method: L{Method} instance or name of raw RPC method
        @type method: Method or str

        @param args: call arguments
        """
        # if a raw rpc method was given instead of a Method instance,
        # try and find the instance for it. And if all else fails, create a
        # dummy Method instance
        if isinstance(method, str):
            result = find_method(method)
            # if result not found
            if -1 == result:
                # noinspection PyTypeChecker
                method = Method(DummyClass, method, method)
            else:
                method = result

        # ensure method is available before adding
        if not method.is_available(self.rt_obj):
            _handle_unavailable_rpc_method(method, self.rt_obj)

        self.calls.append((method, args))

    def list_calls(self):
        for c in self.calls:
            print(c)

    def call(self):
        """Execute added multicall calls

        @return: the results (post-processed), in the order they were added
        @rtype: tuple
        """
        xmc = xmlrpclib.MultiCall(self.rt_obj.get_connection())
        for call in self.calls:
            method, args = call
            rpc_call = method.rpc_call
            if not self.rt_obj.method_exists(rpc_call):
                for alias in getattr(method, 'aliases', None) or []:
                    if self.rt_obj.method_exists(alias):
                        rpc_call = alias
                        break
            getattr(xmc, rpc_call)(*args)

        try:
            results = tuple(next(filter(lambda x: isinstance(x, list), xmc().results)))
        except (BaseException, Exception):
            return [[]]

        results_processed = []

        for r, c in list(zip(results, self.calls)):
            method = c[0]  # Method instance
            result = process_result(method, r)
            results_processed.append(result)
            # assign result to class_obj
            exists = hasattr(self.class_obj, method.varname)
            if not exists or not inspect.ismethod(getattr(self.class_obj, method.varname)):
                setattr(self.class_obj, method.varname, result)

        return tuple(results_processed)


def call_method(class_obj, method, *args):
    """Handles single RPC calls

    @param class_obj: Peer/File/Torrent/Tracker/RTorrent instance
    @type class_obj: object

    @param method: L{Method} instance or name of raw RPC method
    @type method: Method or str
    """
    if method.is_retriever():
        args = args[:-1]
    else:
        assert args[-1] is not None, 'No argument given.'

    if 'RTorrent' == class_obj.__class__.__name__:
        rt_obj = class_obj
    else:
        # noinspection PyProtectedMember,PyUnresolvedReferences
        rt_obj = class_obj._rt_obj

    # check if rpc method is even available
    if not method.is_available(rt_obj):
        _handle_unavailable_rpc_method(method, rt_obj)

    mc = Multicall(class_obj)
    mc.add(method, *args)
    # only added one method, only getting one result back
    ret_value = mc.call()[0]

    return ret_value


def find_method(rpc_call):
    """Return L{Method} instance associated with given RPC call"""
    try:
        rpc_call = rpc_call.lower()
        return next(filter(lambda m: rpc_call in list(map(
            lambda n: n.lower(), [m.rpc_call] + list(getattr(m, 'aliases', [])))),
                      rtorrent.methods + rtorrent.torrent.methods +
                      rtorrent.file.methods + rtorrent.tracker.methods + rtorrent.peer.methods))
    except (BaseException, Exception):
        return -1


def process_result(method, result):
    """Process given C{B{result}} based on flags set in C{B{method}}

    @param method: L{Method} instance
    @type method: Method

    @param result: result to be processed (the result of given L{Method} instance)

    @note: Supported Processing:
        - bololean - convert ones and zeros returned by rTorrent and
        convert to python boolean values
    """
    # handle custom post processing function
    if method.post_process_func is not None:
        result = method.post_process_func(result)

    # is boolean?
    if method.boolean:
        if result in [1, '1']:
            result = True
        elif result in [0, '0']:
            result = False

    return result


def _build_rpc_methods(class_, method_list):
    """Build glorified aliases to raw RPC methods"""
    instance = None
    if not inspect.isclass(class_):
        instance = class_
        class_ = instance.__class__

    method_store = (instance, class_)[None is instance]
    for m in method_list:
        class_name = m.class_name
        if class_name != class_.__name__:
            continue

        caller = None
        if 'RTorrent' == class_name:
            caller = (lambda self, arg=None, method=m: call_method(self, method, bool_to_int(arg)))
        elif class_name in ['Torrent', 'Tracker', 'File', 'Peer']:
            caller = (lambda self, arg=None, method=m: call_method(self, method, self.rpc_id, bool_to_int(arg)))
        elif 'Group' == class_name:
            caller = (lambda arg=None, method=m: call_method(instance, method, bool_to_int(arg)))

        if None is not caller:
            for method_name in [m.method_name] + list(getattr(m, 'aliases', [])):
                setattr(method_store, method_name, caller)

            m.docstring = m.docstring or ''
            caller.__doc__ = """{0}
    
            @note: Variable where the result for this method is stored: {1}.{2}""".format(
                m.docstring, class_name, m.varname)  # print(m)