mirror of
https://github.com/SickGear/SickGear.git
synced 2024-11-15 09:25:04 +00:00
8ddffb7882
Remove py2 part from _23.py Remove more mapped stuff. Replace filter_iter with native filter. Replace map_iter with native map. Remove unidecode from _23 (empty wrapper on py3). Remove map_list and replace with native list(map( for performance reasons. Replace filter_list with list(filter. Replace list_keys with list(. Replace list_values with list(...values()). Replace list_items with list(....items()). Replace ordered_dict with dict. Fix tvinfo base type docs. Remove py2 parts from sg_futures. Remove scandir lib ... it's a sub module of os in py3. Remove PY2 stuff. Ignore unknown ids for characters/persons. Fix tvdb image parsing. Ignore unknown id sources on person page.
280 lines
10 KiB
Python
280 lines
10 KiB
Python
# 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)
|