diff --git a/CHANGES.md b/CHANGES.md
index 3cd1f8b..14a4d88 100644
--- a/CHANGES.md
+++ b/CHANGES.md
@@ -33,6 +33,12 @@
 
 
 
+### 0.19.6 (2019-06-24 00:15:00 UTC)
+
+* Change add rTorrent 0.9.7 compatibility
+* Change improve Cloudflare connectivity
+
+
 ### 0.19.5 (2019-06-13 18:25:00 UTC)
 
 * Update Js2Py 0.43 (da310bb) to 0.64 (efbfcca)
diff --git a/HACKS.txt b/HACKS.txt
index 0dd835e..94db0ec 100644
--- a/HACKS.txt
+++ b/HACKS.txt
@@ -10,6 +10,7 @@ Libs with customisations...
 /lib/hachoir_parser/guess.py
 /lib/hachoir_parser/misc/torrent.py
 /lib/lockfile/mkdirlockfile.py
+/lib/rtorrent
 /lib/scandir/scandir.py
 /lib/tmdb_api/tmdb_api.py
 /lib/tornado
diff --git a/gui/slick/interfaces/default/config_search.tmpl b/gui/slick/interfaces/default/config_search.tmpl
index 80fce93..58403ad 100755
--- a/gui/slick/interfaces/default/config_search.tmpl
+++ b/gui/slick/interfaces/default/config_search.tmpl
@@ -516,7 +516,7 @@
 								</label>
 							</div>
 
-							<div class="field-pair">
+							<div class="field-pair" id="torrent-password-option">
 								<label>
 									<span class="component-title" id="password-title">Client password</span>
 									<span class="component-desc">
diff --git a/gui/slick/js/configSearch.js b/gui/slick/js/configSearch.js
index 6109d89..ba43f16 100644
--- a/gui/slick/js/configSearch.js
+++ b/gui/slick/js/configSearch.js
@@ -1,7 +1,13 @@
+/** @namespace $.SickGear.Root */
 /** @namespace config.defaultHost */
 $(document).ready(function(){
 
-	var loading = '<img src="' + sbRoot + '/images/loading16' + themeSpinner + '.gif" height="16" width="16" />';
+	var loading = '<img src="' + $.SickGear.Root + '/images/loading16' + themeSpinner + '.gif" height="16" width="16" />',
+		handleSCGI = function() {
+			var opts$ = $('#torrent-username-option,#torrent-password-option');
+			$('#torrent_username,#torrent_password').each(function() {$(this).val(
+				/^\s*scgi:\/\//.test($('#torrent_host').val()) ? opts$.hide() && $('#torrent_label').select() && ''
+					: opts$.show() && $('#torrent_username').select() && $(this).prop('defaultValue'));});};
 
 	function toggleTorrentTitle() {
 		var noTorrent$ = $('#no_torrents');
@@ -65,7 +71,8 @@ $(document).ready(function(){
 				pathBlank = '#path-blank',
 				seedTimeOption = '#torrent-seed-time-option',
 				pausedOption = '#torrent-paused-option',
-				highBandwidthOption = '#torrent-high-bandwidth-option';
+				highBandwidthOption = '#torrent-high-bandwidth-option',
+				torrentHost$ = $('#torrent_host');
 
 			$([labelWarningDeluge, hostDescDeluge, hostDescRtorrent, verifyCertOption, seedTimeOption,
 				highBandwidthOption, qBitTorrent, synology, transmission].join(',')).hide();
@@ -73,6 +80,8 @@ $(document).ready(function(){
 			$([hostDesc, usernameOption, pathOption, labelOption, pathBlank, pausedOption].join(',')).show();
 			$(pathOption).find('.fileBrowser').show();
 
+			torrentHost$.off('blur');
+
 			switch (selectedProvider) {
 				case 'utorrent':
 					client = 'uTorrent';
@@ -99,8 +108,9 @@ $(document).ready(function(){
 					$(synology).show();
 					break;
 				case 'rtorrent':
-					client = 'rTorrent'; hideHostDesc = !0; hidePausedOption = !0;
+					client = 'rTorrent'; hideHostDesc = !0;
 					$(hostDescRtorrent).show();
+					torrentHost$.on('blur', handleSCGI);
 					break;
 			}
 			hideHostDesc && $(hostDesc).hide();
@@ -129,8 +139,10 @@ $(document).ready(function(){
 
 	$('#test_torrent').click(function() {
 		$('#test-torrent-result').html(loading);
+		var method = $('#torrent_method').find(':selected').val();
+		(('rtorrent' === method) && handleSCGI());
 		$.get(sbRoot + '/home/test_torrent',
-			{'torrent_method': $('#torrent_method').find(':selected').val(), 'host': $('#torrent_host').val(),
+			{'torrent_method': method, 'host': $('#torrent_host').val(),
 				'username': $('#torrent_username').val(), 'password': $('#torrent_password').val()},
 				function(data) { $(this).testResult(data, '#test-torrent-result'); });
 	});
diff --git a/lib/cfscrape/__init__.py b/lib/cfscrape/__init__.py
index c5bc46b..9e7642a 100644
--- a/lib/cfscrape/__init__.py
+++ b/lib/cfscrape/__init__.py
@@ -199,7 +199,7 @@ class CloudflareScraper(Session):
                     ([], ['GREASE_3A', 'GREASE_6A', 'AES128-GCM-SHA256', 'AES256-GCM-SHA256', 'AES256-GCM-SHA384',
                           'CHACHA20-POLY1305-SHA256'])[hasattr(ssl, 'PROTOCOL_TLSv1_3')] +
                     ['ECDHE-ECDSA-AES128-GCM-SHA256', 'ECDHE-RSA-AES128-GCM-SHA256',
-                     'ECDHE-ECDSA-AES256-GCM-SHA384', 'ECDHE-RSA-AES256-GCM-SHA384',
+                     'ECDHE-ECDSA-AES256-GCM-SHA384',
                      'ECDHE-ECDSA-CHACHA20-POLY1305-SHA256', 'ECDHE-RSA-CHACHA20-POLY1305-SHA256',
                      'ECDHE-RSA-AES128-CBC-SHA', 'ECDHE-RSA-AES256-CBC-SHA', 'RSA-AES128-GCM-SHA256',
                      'RSA-AES256-GCM-SHA384', 'ECDHE-RSA-AES128-GCM-SHA256', 'RSA-AES256-SHA', '3DES-EDE-CBC']):
diff --git a/lib/rtorrent/__init__.py b/lib/rtorrent/__init__.py
index 26957bc..7915fdd 100644
--- a/lib/rtorrent/__init__.py
+++ b/lib/rtorrent/__init__.py
@@ -10,62 +10,56 @@
 # 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,
+# 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.
-try:
-    import urllib.parse as urlparser
-except ImportError:
-    import urllib as urlparser
 import os.path
 import time
-try:
-    import xmlrpc.client as xmlrpclib
-except ImportError:
-    import xmlrpclib
-
-from rtorrent.common import find_torrent, \
-    is_valid_port, convert_version_tuple_to_str
-from rtorrent.lib.torrentparser import TorrentParser
-from rtorrent.lib.xmlrpc.http import HTTPServerProxy
-from rtorrent.lib.xmlrpc.scgi import SCGIServerProxy
-from rtorrent.rpc import Method
-from rtorrent.lib.xmlrpc.basic_auth import BasicAuthTransport
-from rtorrent.torrent import Torrent
-from rtorrent.group import Group
-import rtorrent.rpc  # @UnresolvedImport
-
-__version__ = "0.2.9"
-__author__ = "Chris Lucas"
-__contact__ = "chris@chrisjlucas.com"
-__license__ = "MIT"
+
+from .common import convert_version_tuple_to_str, find_torrent, is_valid_port, join_uri, update_uri
+from .compat import urlparse, xmlrpclib
+from .lib.torrentparser import TorrentParser
+from .lib.xmlrpc.basic_auth import BasicAuthTransport
+from .lib.xmlrpc.http import HTTPServerProxy
+from .lib.xmlrpc.scgi import SCGIServerProxy
+from .rpc import Method
+import rpc  # @UnresolvedImport
+
+from .file import File, methods as file_methods
+from .group import Group
+from .peer import Peer, methods as peer_methods
+from .torrent import Torrent, methods as torrent_methods
+from .tracker import Tracker, methods as tracker_methods
+
+__version__ = '0.2.10'
+__author__ = 'Chris Lucas'
+__maintainer__ = 'SickGear'
+__contact__ = 'chris@chrisjlucas.com'
+__license__ = 'MIT'
 
 MIN_RTORRENT_VERSION = (0, 8, 1)
 MIN_RTORRENT_VERSION_STR = convert_version_tuple_to_str(MIN_RTORRENT_VERSION)
 
 
-class RTorrent:
+class RTorrent(object):
     """ Create a new rTorrent connection """
     rpc_prefix = None
 
-    def __init__(self, uri, username=None, password=None,
-                 verify=False, sp=None, sp_kwargs=None):
-        self.uri = uri  # : From X{__init__(self, url)}
+    def __init__(self, uri, username=None, password=None, check_connection=True, sp=None, sp_kwargs=None):
 
         self.username = username
         self.password = password
 
-        self.schema = urlparser.splittype(uri)[0]
-
+        self.scheme, self.uri = self._transform_uri(uri)
         if sp:
             self.sp = sp
-        elif self.schema in ['http', 'https']:
+        elif self.scheme in ['http', 'https']:
             self.sp = HTTPServerProxy
-        elif self.schema == 'scgi':
+        elif 'scgi' == self.scheme:
             self.sp = SCGIServerProxy
         else:
             raise NotImplementedError()
@@ -76,66 +70,107 @@ class RTorrent:
         self._rpc_methods = []  # : List of rTorrent RPC methods
         self._torrent_cache = []
         self._client_version_tuple = ()
+        self.use_target = False
+        self.dht_port = None
+        self.request_interval = 3
 
-        if verify is True:
-            self._verify_conn()
+        if check_connection:
+            self._check_connection()
 
-    def _get_conn(self):
-        """Get ServerProxy instance"""
-        if self.username is not None and self.password is not None:
-            if self.schema == 'scgi':
-                raise NotImplementedError()
+    @staticmethod
+    def _transform_uri(uri):
+        scheme = urlparse(uri).scheme
 
-            return self.sp(
-                self.uri,
-                transport=BasicAuthTransport(self.username, self.password),
-                **self.sp_kwargs
-            )
+        if 'httprpc' == scheme or scheme.startswith('httprpc+'):
+            # Transform URI with new path and scheme
+            uri = join_uri(uri, 'plugins/httprpc/action.php', construct=False)
 
-        return self.sp(self.uri, **self.sp_kwargs)
+            # Try find HTTPRPC transport (token after '+' in 'httprpc+https'), otherwise assume HTTP
+            transport = 'http' if '+' not in scheme else scheme[scheme.index('+') + 1:]
 
-    def _verify_conn(self):
-        # check for rpc methods that should be available
-        assert "system.client_version" in self._get_rpc_methods(), "Required RPC method not available."
-        assert "system.library_version" in self._get_rpc_methods(), "Required RPC method not available."
+            uri = update_uri(uri, scheme=transport)
 
-        # minimum rTorrent version check
-        assert self._meets_version_requirement() is True,\
-            "Error: Minimum rTorrent version required is {0}".format(
-            MIN_RTORRENT_VERSION_STR)
+        return urlparse(uri).scheme, uri
 
-    def _meets_version_requirement(self):
-        return self._get_client_version_tuple() >= MIN_RTORRENT_VERSION
+    def get_connection(self):
+        """Get ServerProxy instance"""
 
-    def _get_client_version_tuple(self):
-        conn = self._get_conn()
+        if not (self.username and self.password):
+            return self.sp(self.uri, **self.sp_kwargs)
 
-        if not self._client_version_tuple:
-            if not hasattr(self, "client_version"):
-                setattr(self, "client_version",
-                        conn.system.client_version())
+        if 'scgi' == self.scheme:
+            raise NotImplementedError()
 
-            rtver = getattr(self, "client_version")
-            self._client_version_tuple = tuple([int(i) for i in
-                                                rtver.split(".")])
+        return self.sp(self.uri,
+                       transport=BasicAuthTransport('https' == self.scheme, self.username, self.password),
+                       **self.sp_kwargs)
 
-        return self._client_version_tuple
+    def test_connection(self):
+        """
+        Test connection to rT
+        :return: True of connection successful, otherwise False
+        :rtype: Boolean
+        """
+        try:
+            self._check_connection()
+            return True
+        except(Exception, BaseException):
+            return False
 
-    def _update_rpc_methods(self):
-        self._rpc_methods = self._get_conn().system.listMethods()
+    def _check_connection(self):
+        # check for rpc methods that should be available
+        assert self.method_exists('system.client_version'), \
+            'Required RPC method (client_version) not available. Check connection settings in client.'
+        assert self.method_exists('system.library_version'), \
+            'Required RPC method (system.library_version) not available. Check connection settings in client.'
 
-        return self._rpc_methods
+        # minimum rTorrent version check
+        assert self._meets_version_requirement() is True, \
+            'Error: Minimum rTorrent version required is %s' % MIN_RTORRENT_VERSION_STR
+
+    def method_exists(self, name):
+        """
+        Check if rpc method exists
+        :param name: Name of method
+        :type name: str
+        :return: True if method is found
+        :rtype: Boolean
+        """
+        return name in self.get_rpc_methods()
 
-    def _get_rpc_methods(self):
+    def get_rpc_methods(self):
         """ Get list of raw RPC commands
 
         @return: raw RPC commands
         @rtype: list
         """
 
-        return(self._rpc_methods or self._update_rpc_methods())
+        return self._rpc_methods or self._fetch_rpc_methods()
+
+    def _fetch_rpc_methods(self):
+
+        self._rpc_methods = self.get_connection().system.listMethods()
+
+        return self._rpc_methods
+
+    def _meets_version_requirement(self):
+        return self.get_client_version_tuple() >= MIN_RTORRENT_VERSION
 
-    def get_torrents(self, view="main"):
+    def get_client_version_tuple(self):
+        conn = self.get_connection()
+
+        if not self._client_version_tuple:
+            if not hasattr(self, 'client_version'):
+                setattr(self, 'client_version',
+                        conn.system.client_version())
+
+            rtver = getattr(self, 'client_version')
+            self._client_version_tuple = tuple([int(i) for i in
+                                                rtver.split('.')])
+
+        return self._client_version_tuple
+
+    def get_torrents(self, view='main'):
         """Get list of all torrents in specified view
 
         @return: list of L{Torrent} instances
@@ -145,113 +180,107 @@ class RTorrent:
         @todo: add validity check for specified view
         """
         self.torrents = []
-        methods = rtorrent.torrent.methods
-        retriever_methods = [m for m in methods
-                             if m.is_retriever() and m.is_available(self)]
+        retriever_methods = filter(lambda m: m.is_retriever() and m.is_available(self), torrent_methods)
+        mc = rpc.Multicall(self)
 
-        m = rtorrent.rpc.Multicall(self)
-        m.add("d.multicall", view, "d.get_hash=",
-              *[method.rpc_call + "=" for method in retriever_methods])
+        if self.method_exists('d.multicall2'):
+            mc.add('d.multicall2', '', view, 'd.hash=',
+                   *map(lambda m2: ((getattr(m2, 'aliases') or [''])[-1] or m2.rpc_call) + '=', retriever_methods))
+        else:
+            mc.add('d.multicall', view, 'd.get_hash=',
+                   *map(lambda m1: m1.rpc_call + '=', retriever_methods))
 
-        results = m.call()[0]  # only sent one call, only need first result
+        results = mc.call()[0]  # only sent one call, only need first result
 
         for result in results:
-            results_dict = {}
-            # build results_dict
-            for m, r in zip(retriever_methods, result[1:]):  # result[0] is the info_hash
-                results_dict[m.varname] = rtorrent.rpc.process_result(m, r)
-
             self.torrents.append(
-                Torrent(self, info_hash=result[0], **results_dict)
-            )
+                Torrent(self, info_hash=result[0],
+                        **dict((mc.varname, rpc.process_result(mc, r))
+                               for (mc, r) in list(zip(retriever_methods, result[1:])))))  # result[0]=info_hash
 
         self._manage_torrent_cache()
-        return(self.torrents)
+        return self.torrents
 
     def _manage_torrent_cache(self):
         """Carry tracker/peer/file lists over to new torrent list"""
-        for torrent in self._torrent_cache:
-            new_torrent = rtorrent.common.find_torrent(torrent.info_hash,
-                                                       self.torrents)
+        for t in self._torrent_cache:
+            new_torrent = common.find_torrent(t.info_hash, self.torrents)
             if new_torrent is not None:
-                new_torrent.files = torrent.files
-                new_torrent.peers = torrent.peers
-                new_torrent.trackers = torrent.trackers
+                new_torrent.files = t.files
+                new_torrent.peers = t.peers
+                new_torrent.trackers = t.trackers
 
         self._torrent_cache = self.torrents
 
     def _get_load_function(self, file_type, start, verbose):
         """Determine correct "load torrent" RPC method"""
-        func_name = None
-        if file_type == "url":
-            # url strings can be input directly
-            if start and verbose:
-                func_name = "load_start_verbose"
-            elif start:
-                func_name = "load_start"
-            elif verbose:
-                func_name = "load_verbose"
-            else:
-                func_name = "load"
-        elif file_type in ["file", "raw"]:
-            if start and verbose:
-                func_name = "load_raw_start_verbose"
-            elif start:
-                func_name = "load_raw_start"
-            elif verbose:
-                func_name = "load_raw_verbose"
-            else:
-                func_name = "load_raw"
-
-        return(func_name)
-
-    def load_magnet(self, magneturl, info_hash, start=False, verbose=False, verify_load=True):
-
-        p = self._get_conn()
-
-        info_hash = info_hash.upper()
-
-        func_name = self._get_load_function("url", start, verbose)
-
+        func_name = file_type in ('url', 'file', 'raw') and (
+            dict(sv='load_raw_start_verbose', s='load_raw_start', v='load_raw_verbose', ld='load_raw'),
+            dict(sv='load_start_verbose', s='load_start', v='load_verbose', ld='load')
+        )['url' == file_type][
+            ((('ld', 'v')[verbose], 's')[start], 'sv')[start and verbose]] or None
+
+        if not self.method_exists(func_name):
+            if 'load' == func_name:
+                func_name = 'load.normal'
+            func_name = func_name.replace('load_', 'load.')
+            if not self.method_exists(func_name):
+                func_name = None
+
+        return func_name
+
+    def execute_func(self, func_name, param=None, extra=None):
+        
+        param = ([param], param)[isinstance(param, list)]
+        for x in (extra or []):
+            try:
+                call, arg = x.split('=')
+                method = rpc.find_method(call)
+                method_name = filter(lambda m: self.method_exists(m), (method.rpc_call,) + method.aliases)[0]
+                param += ['%s=%s' % (method_name, arg)]
+            except(Exception, BaseException):
+                pass
+
+        method = getattr(self.get_connection(), func_name)
+
+        if not self.use_target:
+            try:
+                method(*param)
+            except(Exception, BaseException):
+                self.use_target = True
+        if self.use_target:
+            method('', *param)
+
+    def load_magnet(self, magneturl, info_hash, extra=None, start=False, verbose=False, verify_load=True):
+
+        func_name = self._get_load_function('url', start, verbose)
         # load magnet
-        getattr(p, func_name)(magneturl)
+        self.execute_func(func_name, magneturl, extra)
 
         t = None
         if verify_load:
-            max_retries = 3
-            i = 0
-            while i < max_retries:
-                for t in self.get_torrents():
-                    if t.info_hash != info_hash:
-                        continue
-                    time.sleep(1)
-                    i += 1
-
-            if t:
-                # Resolve magnet to torrent
-                t.start()
-
-                assert info_hash in [t.info_hash for t in self.torrents],\
-                    "Adding torrent was unsuccessful."
-
-                max_retries = 3
-                i = 0
-                while i < max_retries:
-                    for t in self.get_torrents():
-                        if t.info_hash == info_hash:
-                            if str(info_hash) not in str(t.name) :
-                                time.sleep(1)
-                                i += 1
+            info_hash = info_hash.upper()
+            max_retries = 10
+            while max_retries:
+                try:
+                    t = filter(lambda td: td.info_hash.upper() == info_hash, self.get_torrents())[0]
+                    break
+                except(Exception, BaseException):
+                    time.sleep(self.request_interval)
+                    max_retries -= 1
 
         return t
 
-    def load_torrent(self, torrent, start=False, verbose=False, verify_load=True, verify_retries=3):
+    def load_torrent(self, data, extra=None, start=False, verbose=False, verify_load=True, verify_retries=3):
         """
         Loads torrent into rTorrent (with various enhancements)
 
-        @param torrent: can be a url, a path to a local file, or the raw data
+        @param data: can be a url, a path to a local file, or the raw data
         of a torrent file
-        @type torrent: str
+        @type data: str
+
+        @param extra: extra commands to send
+        @type extra: array
 
         @param start: start torrent when loaded
         @type start: bool
@@ -262,6 +291,9 @@ class RTorrent:
         @param verify_load: verify that torrent was added to rTorrent successfully
         @type verify_load: bool
 
+        @param verify_retries: number of times to attempt verification
+        @type verify_load: int
+
         @return: Depends on verify_load:
                  - if verify_load is True, (and the torrent was
                  loaded successfully), it'll return a L{Torrent} instance
@@ -279,43 +311,40 @@ class RTorrent:
         this function doesn't execute instantaneously. If that's what you're
         looking for, use load_torrent_simple() instead.
         """
-        p = self._get_conn()
-        tp = TorrentParser(torrent)
-        torrent = xmlrpclib.Binary(tp._raw_torrent)
+        tp = TorrentParser(data)
         info_hash = tp.info_hash
 
-        func_name = self._get_load_function("raw", start, verbose)
-
         # load torrent
-        getattr(p, func_name)(torrent)
+        self.execute_func(self._get_load_function('url', False, False), '')
+        self.execute_func(self._get_load_function('raw', start, verbose), xmlrpclib.Binary(tp.raw_torrent), extra)
 
+        t = None
         if verify_load:
-            i = 0
-            while i < verify_retries:
-                self.get_torrents()
-                if info_hash in [t.info_hash for t in self.torrents]:
+            while verify_retries:
+                try:
+                    t = filter(lambda td: td.info_hash == info_hash, self.get_torrents())[0]
                     break
+                except(Exception, BaseException):
+                    time.sleep(self.request_interval)
+                    verify_retries -= 1
 
-                # was still getting AssertionErrors, delay should help
-                time.sleep(1)
-                i += 1
+            assert None is not t, 'Adding torrent was unsuccessful.'
 
-            assert info_hash in [t.info_hash for t in self.torrents],\
-                "Adding torrent was unsuccessful."
-
-        return(find_torrent(info_hash, self.torrents))
+        return t
 
-    def load_torrent_simple(self, torrent, file_type,
-                            start=False, verbose=False):
+    def load_torrent_simple(self, data, file_type, extra=None, start=False, verbose=False):
         """Loads torrent into rTorrent
 
-        @param torrent: can be a url, a path to a local file, or the raw data
+        @param data: can be a url, a path to a local file, or the raw data
         of a torrent file
-        @type torrent: str
+        @type data: str
 
         @param file_type: valid options: "url", "file", or "raw"
         @type file_type: str
 
+        @param extra: extra commands to send
+        @type extra: array
+
         @param start: start torrent when loaded
         @type start: bool
 
@@ -331,47 +360,48 @@ class RTorrent:
         verification that the torrent was successfully added to rTorrent.
         Use load_torrent() if you would like these features.
         """
-        p = self._get_conn()
-
-        assert file_type in ["raw", "file", "url"], \
-            "Invalid file_type, options are: 'url', 'file', 'raw'."
+        assert file_type in ['raw', 'file', 'url'], \
+            'Invalid file_type, options are: \'url\', \'file\', \'raw\'.'
         func_name = self._get_load_function(file_type, start, verbose)
 
-        if file_type == "file":
+        if 'file' == file_type:
             # since we have to assume we're connected to a remote rTorrent
             # client, we have to read the file and send it to rT as raw
-            assert os.path.isfile(torrent), \
-                "Invalid path: \"{0}\"".format(torrent)
-            torrent = open(torrent, "rb").read()
+            assert os.path.isfile(data), \
+                'Invalid path: "{0}"'.format(data)
+            data = open(data, 'rb').read()
+        elif 'raw' == file_type:
+            self.execute_func(self._get_load_function('url', False, False), '')
 
-        if file_type in ["raw", "file"]:
-            finput = xmlrpclib.Binary(torrent)
-        elif file_type == "url":
-            finput = torrent
+        finput = None
+        if file_type in ['raw', 'file']:
+            finput = xmlrpclib.Binary(data)
+        elif 'url' == file_type:
+            finput = data
 
-        getattr(p, func_name)(finput)
+        self.execute_func(func_name, finput, extra)
 
     def get_views(self):
-        p = self._get_conn()
+        p = self.get_connection()
         return p.view_list()
 
     def create_group(self, name, persistent=True, view=None):
-        p = self._get_conn()
+        p = self.get_connection()
 
         if persistent is True:
             p.group.insert_persistent_view('', name)
         else:
-            assert view is not None, "view parameter required on non-persistent groups"
+            assert view is not None, 'view parameter required on non-persistent groups'
             p.group.insert('', name, view)
 
-        self._update_rpc_methods()
+        self._fetch_rpc_methods()
 
     def get_group(self, name):
-        assert name is not None, "group name required"
+        assert name is not None, 'group name required'
 
-        group = Group(self, name)
-        group.update()
-        return group
+        grp = Group(self, name)
+        grp.update()
+        return grp
 
     def set_dht_port(self, port):
         """Set DHT port
@@ -381,7 +411,7 @@ class RTorrent:
 
         @raise AssertionError: if invalid port is given
         """
-        assert is_valid_port(port), "Valid port range is 0-65535"
+        assert is_valid_port(port), 'Valid port range is 0-65535'
         self.dht_port = self._p.set_dht_port(port)
 
     def enable_check_hash(self):
@@ -393,8 +423,18 @@ class RTorrent:
         self.set_check_hash(False)
 
     def find_torrent(self, info_hash):
-        """Frontend for rtorrent.common.find_torrent"""
-        return(rtorrent.common.find_torrent(info_hash, self.get_torrents()))
+        """Frontend for common.find_torrent"""
+        return common.find_torrent(info_hash, self.get_torrents())
+
+    def has_local_id(self, info_hash):
+        method = rpc.find_method('d.get_local_id')
+        result = True
+        try:
+            func = filter(lambda m: self.method_exists(m), (method.rpc_call,) + method.aliases)[0]
+            getattr(self.get_connection(), func)(info_hash)
+        except(xmlrpclib.Fault, BaseException):
+            result = False
+        return result
 
     def poll(self):
         """ poll rTorrent to get latest torrent/peer/tracker/file information
@@ -417,19 +457,17 @@ class RTorrent:
 
         @return: None
         """
-        multicall = rtorrent.rpc.Multicall(self)
-        retriever_methods = [m for m in methods
-                             if m.is_retriever() and m.is_available(self)]
-        for method in retriever_methods:
-            multicall.add(method)
+        mc = rpc.Multicall(self)
+
+        for method in filter(lambda m: m.is_retriever() and m.is_available(self), methods):
+            mc.add(method)
 
-        multicall.call()
+        mc.call()
 
 
 def _build_class_methods(class_obj):
     # multicall add class
-    caller = lambda self, multicall, method, *args:\
-        multicall.add(method, self.rpc_id, *args)
+    caller = (lambda self, mc, method, *args: mc.add(method, self.rpc_id, *args))
 
     caller.__doc__ = """Same as Multicall.add(), but with automatic inclusion
                         of the rpc_id
@@ -442,105 +480,159 @@ def _build_class_methods(class_obj):
 
                         @param args: optional arguments to pass
                         """
-    setattr(class_obj, "multicall_add", caller)
+    setattr(class_obj, 'multicall_add', caller)
 
 
 def __compare_rpc_methods(rt_new, rt_old):
     from pprint import pprint
-    rt_new_methods = set(rt_new._get_rpc_methods())
-    rt_old_methods = set(rt_old._get_rpc_methods())
-    print("New Methods:")
+    rt_new_methods = set(rt_new.get_rpc_methods())
+    rt_old_methods = set(rt_old.get_rpc_methods())
+    print('New Methods:')
     pprint(rt_new_methods - rt_old_methods)
-    print("Methods not in new rTorrent:")
+    print('Methods not in new rTorrent:')
     pprint(rt_old_methods - rt_new_methods)
 
 
 def __check_supported_methods(rt):
     from pprint import pprint
-    supported_methods = set([m.rpc_call for m in
-                             methods +
-                             rtorrent.file.methods +
-                             rtorrent.torrent.methods +
-                             rtorrent.tracker.methods +
-                             rtorrent.peer.methods])
-    all_methods = set(rt._get_rpc_methods())
-
-    print("Methods NOT in supported methods")
+    supported_methods = set(
+        [m.rpc_call for m in methods + file_methods + torrent_methods + tracker_methods + peer_methods])
+    all_methods = set(rt.get_rpc_methods())
+
+    print('Methods NOT in supported methods')
     pprint(all_methods - supported_methods)
-    print("Supported methods NOT in all methods")
+    print('Supported methods NOT in all methods')
     pprint(supported_methods - all_methods)
 
+
 methods = [
     # RETRIEVERS
-    Method(RTorrent, 'get_xmlrpc_size_limit', 'get_xmlrpc_size_limit'),
-    Method(RTorrent, 'get_proxy_address', 'get_proxy_address'),
-    Method(RTorrent, 'get_split_suffix', 'get_split_suffix'),
-    Method(RTorrent, 'get_up_limit', 'get_upload_rate'),
-    Method(RTorrent, 'get_max_memory_usage', 'get_max_memory_usage'),
-    Method(RTorrent, 'get_max_open_files', 'get_max_open_files'),
-    Method(RTorrent, 'get_min_peers_seed', 'get_min_peers_seed'),
-    Method(RTorrent, 'get_use_udp_trackers', 'get_use_udp_trackers'),
-    Method(RTorrent, 'get_preload_min_size', 'get_preload_min_size'),
-    Method(RTorrent, 'get_max_uploads', 'get_max_uploads'),
-    Method(RTorrent, 'get_max_peers', 'get_max_peers'),
-    Method(RTorrent, 'get_timeout_sync', 'get_timeout_sync'),
-    Method(RTorrent, 'get_receive_buffer_size', 'get_receive_buffer_size'),
-    Method(RTorrent, 'get_split_file_size', 'get_split_file_size'),
-    Method(RTorrent, 'get_dht_throttle', 'get_dht_throttle'),
-    Method(RTorrent, 'get_max_peers_seed', 'get_max_peers_seed'),
-    Method(RTorrent, 'get_min_peers', 'get_min_peers'),
-    Method(RTorrent, 'get_tracker_numwant', 'get_tracker_numwant'),
-    Method(RTorrent, 'get_max_open_sockets', 'get_max_open_sockets'),
-    Method(RTorrent, 'get_session', 'get_session'),
-    Method(RTorrent, 'get_ip', 'get_ip'),
-    Method(RTorrent, 'get_scgi_dont_route', 'get_scgi_dont_route'),
+    Method(RTorrent, 'get_xmlrpc_size_limit', 'get_xmlrpc_size_limit',
+           aliases=('network.xmlrpc.size_limit',)),
+    Method(RTorrent, 'get_proxy_address', 'get_proxy_address',
+           aliases=('network.proxy_address',)),
+    Method(RTorrent, 'get_split_suffix', 'get_split_suffix',
+           aliases=('system.file.split_suffix',)),
+    Method(RTorrent, 'get_up_limit', 'get_upload_rate',
+           aliases=('throttle.global_up.max_rate',)),
+    Method(RTorrent, 'get_max_memory_usage', 'get_max_memory_usage',
+           aliases=('pieces.memory.max',)),
+    Method(RTorrent, 'get_max_open_files', 'get_max_open_files',
+           aliases=('network.max_open_files',)),
+    Method(RTorrent, 'get_min_peers_seed', 'get_min_peers_seed',
+           aliases=('throttle.min_peers.seed',)),
+    Method(RTorrent, 'get_use_udp_trackers', 'get_use_udp_trackers',
+           aliases=('trackers.use_udp',)),
+    Method(RTorrent, 'get_preload_min_size', 'get_preload_min_size',
+           aliases=('pieces.preload.min_size',)),
+    Method(RTorrent, 'get_max_uploads', 'get_max_uploads',
+           aliases=('throttle.max_uploads',)),
+    Method(RTorrent, 'get_max_peers', 'get_max_peers',
+           aliases=('throttle.max_peers.normal',)),
+    Method(RTorrent, 'get_timeout_sync', 'get_timeout_sync',
+           aliases=('pieces.sync.timeout',)),
+    Method(RTorrent, 'get_receive_buffer_size', 'get_receive_buffer_size',
+           aliases=('network.receive_buffer.size',)),
+    Method(RTorrent, 'get_split_file_size', 'get_split_file_size',
+           aliases=('system.file.split_size',)),
+    Method(RTorrent, 'get_dht_throttle', 'get_dht_throttle',
+           aliases=('dht.throttle.name',)),
+    Method(RTorrent, 'get_max_peers_seed', 'get_max_peers_seed',
+           aliases=('throttle.max_peers.seed',)),
+    Method(RTorrent, 'get_min_peers', 'get_min_peers',
+           aliases=('throttle.min_peers.normal',)),
+    Method(RTorrent, 'get_tracker_numwant', 'get_tracker_numwant',
+           aliases=('trackers.numwant',)),
+    Method(RTorrent, 'get_max_open_sockets', 'get_max_open_sockets',
+           aliases=('network.max_open_sockets',)),
+    Method(RTorrent, 'get_session', 'get_session',
+           aliases=('session.path',)),
+    Method(RTorrent, 'get_ip', 'get_ip',
+           aliases=('network.local_address',)),
+    Method(RTorrent, 'get_scgi_dont_route', 'get_scgi_dont_route',
+           aliases=('network.scgi.dont_route',)),
     Method(RTorrent, 'get_hash_read_ahead', 'get_hash_read_ahead'),
-    Method(RTorrent, 'get_http_cacert', 'get_http_cacert'),
-    Method(RTorrent, 'get_dht_port', 'get_dht_port'),
+    Method(RTorrent, 'get_http_cacert', 'get_http_cacert',
+           aliases=('network.http.cacert',)),
+    Method(RTorrent, 'get_dht_port', 'get_dht_port',
+           aliases=('dht.port',)),
     Method(RTorrent, 'get_handshake_log', 'get_handshake_log'),
-    Method(RTorrent, 'get_preload_type', 'get_preload_type'),
-    Method(RTorrent, 'get_max_open_http', 'get_max_open_http'),
-    Method(RTorrent, 'get_http_capath', 'get_http_capath'),
-    Method(RTorrent, 'get_max_downloads_global', 'get_max_downloads_global'),
-    Method(RTorrent, 'get_name', 'get_name'),
-    Method(RTorrent, 'get_session_on_completion', 'get_session_on_completion'),
-    Method(RTorrent, 'get_down_limit', 'get_download_rate'),
-    Method(RTorrent, 'get_down_total', 'get_down_total'),
-    Method(RTorrent, 'get_up_rate', 'get_up_rate'),
+    Method(RTorrent, 'get_preload_type', 'get_preload_type',
+           aliases=('pieces.preload.type',)),
+    Method(RTorrent, 'get_max_open_http', 'get_max_open_http',
+           aliases=('network.http.max_open',)),
+    Method(RTorrent, 'get_http_capath', 'get_http_capath',
+           aliases=('network.http.capath',)),
+    Method(RTorrent, 'get_max_downloads_global', 'get_max_downloads_global',
+           aliases=('throttle.max_downloads.global',)),
+    Method(RTorrent, 'get_name', 'get_name',
+           aliases=('session.name',)),
+    Method(RTorrent, 'get_session_on_completion', 'get_session_on_completion',
+           aliases=('session.on_completion',)),
+    Method(RTorrent, 'get_down_limit', 'get_download_rate',
+           aliases=('throttle.global_down.max_rate',)),
+    Method(RTorrent, 'get_down_total', 'get_down_total',
+           aliases=('throttle.global_down.total',)),
+    Method(RTorrent, 'get_up_rate', 'get_up_rate',
+           aliases=('throttle.global_up.rate',)),
     Method(RTorrent, 'get_hash_max_tries', 'get_hash_max_tries'),
-    Method(RTorrent, 'get_peer_exchange', 'get_peer_exchange'),
-    Method(RTorrent, 'get_down_rate', 'get_down_rate'),
-    Method(RTorrent, 'get_connection_seed', 'get_connection_seed'),
-    Method(RTorrent, 'get_http_proxy', 'get_http_proxy'),
-    Method(RTorrent, 'get_stats_preloaded', 'get_stats_preloaded'),
-    Method(RTorrent, 'get_timeout_safe_sync', 'get_timeout_safe_sync'),
+    Method(RTorrent, 'get_peer_exchange', 'get_peer_exchange',
+           aliases=('protocol.pex',)),
+    Method(RTorrent, 'get_down_rate', 'get_down_rate',
+           aliases=('throttle.global_down.rate',)),
+    Method(RTorrent, 'get_connection_seed', 'get_connection_seed',
+           aliases=('protocol.connection.seed',)),
+    Method(RTorrent, 'get_http_proxy', 'get_http_proxy',
+           aliases=('network.http.proxy_address',)),
+    Method(RTorrent, 'get_stats_preloaded', 'get_stats_preloaded',
+           aliases=('pieces.stats_preloaded',)),
+    Method(RTorrent, 'get_timeout_safe_sync', 'get_timeout_safe_sync',
+           aliases=('pieces.sync.timeout_safe',)),
     Method(RTorrent, 'get_hash_interval', 'get_hash_interval'),
-    Method(RTorrent, 'get_port_random', 'get_port_random'),
-    Method(RTorrent, 'get_directory', 'get_directory'),
-    Method(RTorrent, 'get_port_open', 'get_port_open'),
-    Method(RTorrent, 'get_max_file_size', 'get_max_file_size'),
-    Method(RTorrent, 'get_stats_not_preloaded', 'get_stats_not_preloaded'),
-    Method(RTorrent, 'get_memory_usage', 'get_memory_usage'),
-    Method(RTorrent, 'get_connection_leech', 'get_connection_leech'),
+    Method(RTorrent, 'get_port_random', 'get_port_random',
+           aliases=('network.port_random',)),
+    Method(RTorrent, 'get_directory', 'get_directory',
+           aliases=('directory.default',)),
+    Method(RTorrent, 'get_port_open', 'get_port_open',
+           aliases=('network.port_open',)),
+    Method(RTorrent, 'get_max_file_size', 'get_max_file_size',
+           aliases=('system.file.max_size',)),
+    Method(RTorrent, 'get_stats_not_preloaded', 'get_stats_not_preloaded',
+           aliases=('pieces.stats_not_preloaded',)),
+    Method(RTorrent, 'get_memory_usage', 'get_memory_usage',
+           aliases=('pieces.memory.current',)),
+    Method(RTorrent, 'get_connection_leech', 'get_connection_leech',
+           aliases=('protocol.connection.leech',)),
     Method(RTorrent, 'get_check_hash', 'get_check_hash',
            boolean=True,
+           aliases=('pieces.hash.on_completion',)
            ),
-    Method(RTorrent, 'get_session_lock', 'get_session_lock'),
-    Method(RTorrent, 'get_preload_required_rate', 'get_preload_required_rate'),
-    Method(RTorrent, 'get_max_uploads_global', 'get_max_uploads_global'),
-    Method(RTorrent, 'get_send_buffer_size', 'get_send_buffer_size'),
-    Method(RTorrent, 'get_port_range', 'get_port_range'),
-    Method(RTorrent, 'get_max_downloads_div', 'get_max_downloads_div'),
-    Method(RTorrent, 'get_max_uploads_div', 'get_max_uploads_div'),
-    Method(RTorrent, 'get_safe_sync', 'get_safe_sync'),
-    Method(RTorrent, 'get_bind', 'get_bind'),
-    Method(RTorrent, 'get_up_total', 'get_up_total'),
+    Method(RTorrent, 'get_session_lock', 'get_session_lock',
+           aliases=('session.use_lock',)),
+    Method(RTorrent, 'get_preload_required_rate', 'get_preload_required_rate',
+           aliases=('pieces.preload.min_rate',)),
+    Method(RTorrent, 'get_max_uploads_global', 'get_max_uploads_global',
+           aliases=('throttle.max_uploads.global',)),
+    Method(RTorrent, 'get_send_buffer_size', 'get_send_buffer_size',
+           aliases=('network.send_buffer.size',)),
+    Method(RTorrent, 'get_port_range', 'get_port_range',
+           aliases=('network.port_range',)),
+    Method(RTorrent, 'get_max_downloads_div', 'get_max_downloads_div',
+           aliases=('throttle.max_downloads.div',)),
+    Method(RTorrent, 'get_max_uploads_div', 'get_max_uploads_div',
+           aliases=('throttle.max_uploads.div',)),
+    Method(RTorrent, 'get_safe_sync', 'get_safe_sync',
+           aliases=('pieces.sync.always_safe',)),
+    Method(RTorrent, 'get_bind', 'get_bind',
+           aliases=('network.bind_address',)),
+    Method(RTorrent, 'get_up_total', 'get_up_total',
+           aliases=('throttle.global_up.total',)),
     Method(RTorrent, 'get_client_version', 'system.client_version'),
     Method(RTorrent, 'get_library_version', 'system.library_version'),
     Method(RTorrent, 'get_api_version', 'system.api_version',
            min_version=(0, 9, 1)
            ),
-    Method(RTorrent, "get_system_time", "system.time",
+    Method(RTorrent, 'get_system_time', 'system.time',
            docstring="""Get the current time of the system rTorrent is running on
 
            @return: time (posix)
@@ -548,15 +640,19 @@ methods = [
            ),
 
     # MODIFIERS
-    Method(RTorrent, 'set_http_proxy', 'set_http_proxy'),
-    Method(RTorrent, 'set_max_memory_usage', 'set_max_memory_usage'),
-    Method(RTorrent, 'set_max_file_size', 'set_max_file_size'),
+    Method(RTorrent, 'set_http_proxy', 'set_http_proxy',
+           aliases=('network.http.proxy_address.set',)),
+    Method(RTorrent, 'set_max_memory_usage', 'set_max_memory_usage',
+           aliases=('pieces.memory.max.set',)),
+    Method(RTorrent, 'set_max_file_size', 'set_max_file_size',
+           aliases=('system.file.max_size.set',)),
     Method(RTorrent, 'set_bind', 'set_bind',
            docstring="""Set address bind
 
            @param arg: ip address
            @type arg: str
            """,
+           aliases=('network.bind_address.set',)
            ),
     Method(RTorrent, 'set_up_limit', 'set_upload_rate',
            docstring="""Set global upload limit (in bytes)
@@ -564,67 +660,111 @@ methods = [
            @param arg: speed limit
            @type arg: int
            """,
+           aliases=('throttle.global_up.max_rate.set',)
            ),
-    Method(RTorrent, 'set_port_random', 'set_port_random'),
-    Method(RTorrent, 'set_connection_leech', 'set_connection_leech'),
-    Method(RTorrent, 'set_tracker_numwant', 'set_tracker_numwant'),
-    Method(RTorrent, 'set_max_peers', 'set_max_peers'),
-    Method(RTorrent, 'set_min_peers', 'set_min_peers'),
-    Method(RTorrent, 'set_max_uploads_div', 'set_max_uploads_div'),
-    Method(RTorrent, 'set_max_open_files', 'set_max_open_files'),
-    Method(RTorrent, 'set_max_downloads_global', 'set_max_downloads_global'),
-    Method(RTorrent, 'set_session_lock', 'set_session_lock'),
-    Method(RTorrent, 'set_session', 'set_session'),
-    Method(RTorrent, 'set_split_suffix', 'set_split_suffix'),
+    Method(RTorrent, 'set_port_random', 'set_port_random',
+           aliases=('network.port_random.set',)),
+    Method(RTorrent, 'set_connection_leech', 'set_connection_leech',
+           aliases=('protocol.connection.leech.set',)),
+    Method(RTorrent, 'set_tracker_numwant', 'set_tracker_numwant',
+           aliases=('trackers.numwant.set',)),
+    Method(RTorrent, 'set_max_peers', 'set_max_peers',
+           aliases=('throttle.max_peers.normal.set',)),
+    Method(RTorrent, 'set_min_peers', 'set_min_peers',
+           aliases=('throttle.min_peers.normal.set',)),
+    Method(RTorrent, 'set_max_uploads_div', 'set_max_uploads_div',
+           aliases=('throttle.max_uploads.div.set',)),
+    Method(RTorrent, 'set_max_open_files', 'set_max_open_files',
+           aliases=('network.max_open_files.set',)),
+    Method(RTorrent, 'set_max_downloads_global', 'set_max_downloads_global',
+           aliases=('throttle.max_downloads.global.set',)),
+    Method(RTorrent, 'set_session_lock', 'set_session_lock',
+           aliases=('session.use_lock.set',)),
+    Method(RTorrent, 'set_session', 'set_session',
+           aliases=('session.path.set',)),
+    Method(RTorrent, 'set_split_suffix', 'set_split_suffix',
+           aliases=('system.file.split_suffix.set',)),
     Method(RTorrent, 'set_hash_interval', 'set_hash_interval'),
     Method(RTorrent, 'set_handshake_log', 'set_handshake_log'),
-    Method(RTorrent, 'set_port_range', 'set_port_range'),
-    Method(RTorrent, 'set_min_peers_seed', 'set_min_peers_seed'),
-    Method(RTorrent, 'set_scgi_dont_route', 'set_scgi_dont_route'),
-    Method(RTorrent, 'set_preload_min_size', 'set_preload_min_size'),
+    Method(RTorrent, 'set_port_range', 'set_port_range',
+           aliases=('network.port_range.set',)),
+    Method(RTorrent, 'set_min_peers_seed', 'set_min_peers_seed',
+           aliases=('throttle.min_peers.seed.set',)),
+    Method(RTorrent, 'set_scgi_dont_route', 'set_scgi_dont_route',
+           aliases=('network.scgi.dont_route.set',)),
+    Method(RTorrent, 'set_preload_min_size', 'set_preload_min_size',
+           aliases=('pieces.preload.min_size.set',)),
     Method(RTorrent, 'set_log.tracker', 'set_log.tracker'),
-    Method(RTorrent, 'set_max_uploads_global', 'set_max_uploads_global'),
+    Method(RTorrent, 'set_max_uploads_global', 'set_max_uploads_global',
+           aliases=('throttle.max_uploads.global.set',)),
     Method(RTorrent, 'set_down_limit', 'set_download_rate',
            docstring="""Set global download limit (in bytes)
 
            @param arg: speed limit
            @type arg: int
            """,
+           aliases=('throttle.global_down.max_rate.set',)
            ),
-    Method(RTorrent, 'set_preload_required_rate', 'set_preload_required_rate'),
+    Method(RTorrent, 'set_preload_required_rate', 'set_preload_required_rate',
+           aliases=('pieces.preload.min_rate.set',)),
     Method(RTorrent, 'set_hash_read_ahead', 'set_hash_read_ahead'),
-    Method(RTorrent, 'set_max_peers_seed', 'set_max_peers_seed'),
-    Method(RTorrent, 'set_max_uploads', 'set_max_uploads'),
-    Method(RTorrent, 'set_session_on_completion', 'set_session_on_completion'),
-    Method(RTorrent, 'set_max_open_http', 'set_max_open_http'),
-    Method(RTorrent, 'set_directory', 'set_directory'),
-    Method(RTorrent, 'set_http_cacert', 'set_http_cacert'),
-    Method(RTorrent, 'set_dht_throttle', 'set_dht_throttle'),
+    Method(RTorrent, 'set_max_peers_seed', 'set_max_peers_seed',
+           aliases=('throttle.max_peers.seed.set',)),
+    Method(RTorrent, 'set_max_uploads', 'set_max_uploads',
+           aliases=('throttle.max_uploads.set',)),
+    Method(RTorrent, 'set_session_on_completion', 'set_session_on_completion',
+           aliases=('session.on_completion.set',)),
+    Method(RTorrent, 'set_max_open_http', 'set_max_open_http',
+           aliases=('network.http.max_open.set',)),
+    Method(RTorrent, 'set_directory', 'set_directory',
+           aliases=('directory.default.set',)),
+    Method(RTorrent, 'set_http_cacert', 'set_http_cacert',
+           aliases=('network.http.cacert.set',)),
+    Method(RTorrent, 'set_dht_throttle', 'set_dht_throttle',
+           aliases=('dht.throttle.name.set',)),
     Method(RTorrent, 'set_hash_max_tries', 'set_hash_max_tries'),
-    Method(RTorrent, 'set_proxy_address', 'set_proxy_address'),
-    Method(RTorrent, 'set_split_file_size', 'set_split_file_size'),
-    Method(RTorrent, 'set_receive_buffer_size', 'set_receive_buffer_size'),
-    Method(RTorrent, 'set_use_udp_trackers', 'set_use_udp_trackers'),
-    Method(RTorrent, 'set_connection_seed', 'set_connection_seed'),
-    Method(RTorrent, 'set_xmlrpc_size_limit', 'set_xmlrpc_size_limit'),
-    Method(RTorrent, 'set_xmlrpc_dialect', 'set_xmlrpc_dialect'),
-    Method(RTorrent, 'set_safe_sync', 'set_safe_sync'),
-    Method(RTorrent, 'set_http_capath', 'set_http_capath'),
-    Method(RTorrent, 'set_send_buffer_size', 'set_send_buffer_size'),
-    Method(RTorrent, 'set_max_downloads_div', 'set_max_downloads_div'),
-    Method(RTorrent, 'set_name', 'set_name'),
-    Method(RTorrent, 'set_port_open', 'set_port_open'),
-    Method(RTorrent, 'set_timeout_sync', 'set_timeout_sync'),
-    Method(RTorrent, 'set_peer_exchange', 'set_peer_exchange'),
+    Method(RTorrent, 'set_proxy_address', 'set_proxy_address',
+           aliases=('network.proxy_address.set',)),
+    Method(RTorrent, 'set_split_file_size', 'set_split_file_size',
+           aliases=('system.file.split_size.set',)),
+    Method(RTorrent, 'set_receive_buffer_size', 'set_receive_buffer_size',
+           aliases=('network.receive_buffer.size.set',)),
+    Method(RTorrent, 'set_use_udp_trackers', 'set_use_udp_trackers',
+           aliases=('trackers.use_udp.set',)),
+    Method(RTorrent, 'set_connection_seed', 'set_connection_seed',
+           aliases=('protocol.connection.seed.set',)),
+    Method(RTorrent, 'set_xmlrpc_size_limit', 'set_xmlrpc_size_limit',
+           aliases=('network.xmlrpc.size_limit.set',)),
+    Method(RTorrent, 'set_xmlrpc_dialect', 'set_xmlrpc_dialect',
+           aliases=('network.xmlrpc.dialect.set',)),
+    Method(RTorrent, 'set_safe_sync', 'set_safe_sync',
+           aliases=('pieces.sync.always_safe.set',)),
+    Method(RTorrent, 'set_http_capath', 'set_http_capath',
+           aliases=('network.http.capath.set',)),
+    Method(RTorrent, 'set_send_buffer_size', 'set_send_buffer_size',
+           aliases=('network.send_buffer.size.set',)),
+    Method(RTorrent, 'set_max_downloads_div', 'set_max_downloads_div',
+           aliases=('throttle.max_downloads.div.set',)),
+    Method(RTorrent, 'set_name', 'set_name',
+           aliases=('session.name.set',)),
+    Method(RTorrent, 'set_port_open', 'set_port_open',
+           aliases=('network.port_open.set',)),
+    Method(RTorrent, 'set_timeout_sync', 'set_timeout_sync',
+           aliases=('pieces.sync.timeout.set',)),
+    Method(RTorrent, 'set_peer_exchange', 'set_peer_exchange',
+           aliases=('protocol.pex.set',)),
     Method(RTorrent, 'set_ip', 'set_ip',
            docstring="""Set IP
 
            @param arg: ip address
            @type arg: str
            """,
+           aliases=('network.local_address.set',)
            ),
-    Method(RTorrent, 'set_timeout_safe_sync', 'set_timeout_safe_sync'),
-    Method(RTorrent, 'set_preload_type', 'set_preload_type'),
+    Method(RTorrent, 'set_timeout_safe_sync', 'set_timeout_safe_sync',
+           aliases=('pieces.sync.timeout_safe.set',)),
+    Method(RTorrent, 'set_preload_type', 'set_preload_type',
+           aliases=('pieces.preload.type.set',)),
     Method(RTorrent, 'set_check_hash', 'set_check_hash',
            docstring="""Enable/Disable hash checking on finished torrents
 
@@ -632,23 +772,18 @@ methods = [
             @type arg: bool
             """,
            boolean=True,
-           ),
+           aliases=('pieces.hash.on_completion.set',)
+           )
 ]
 
-_all_methods_list = [methods,
-                     rtorrent.file.methods,
-                     rtorrent.torrent.methods,
-                     rtorrent.tracker.methods,
-                     rtorrent.peer.methods,
-                     ]
-
-class_methods_pair = {
-    RTorrent: methods,
-    rtorrent.file.File: rtorrent.file.methods,
-    rtorrent.torrent.Torrent: rtorrent.torrent.methods,
-    rtorrent.tracker.Tracker: rtorrent.tracker.methods,
-    rtorrent.peer.Peer: rtorrent.peer.methods,
-}
-for c in class_methods_pair.keys():
-    rtorrent.rpc._build_rpc_methods(c, class_methods_pair[c])
+class_methods = [
+    (RTorrent, methods),
+    (File, file_methods),
+    (Torrent, torrent_methods),
+    (Tracker, tracker_methods),
+    (Peer, peer_methods)]
+
+for c, methods in class_methods:
+    # noinspection PyProtectedMember
+    rpc._build_rpc_methods(c, methods)
     _build_class_methods(c)
diff --git a/lib/rtorrent/common.py b/lib/rtorrent/common.py
index 371c71c..859ba66 100644
--- a/lib/rtorrent/common.py
+++ b/lib/rtorrent/common.py
@@ -10,26 +10,25 @@
 # 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,
+# 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 compat import is_py3, urlparse, urlunparse, ParseResult
 
-
-from rtorrent.compat import is_py3
+import os
 
 
 def bool_to_int(value):
     """Translates python booleans to RPC-safe integers"""
     if value is True:
-        return("1")
+        return '1'
     elif value is False:
-        return("0")
-    else:
-        return(value)
+        return '0'
+    return value
 
 
 def cmd_exists(cmds_list, cmd):
@@ -44,7 +43,7 @@ def cmd_exists(cmds_list, cmd):
     @return: bool
     """
 
-    return(cmd in cmds_list)
+    return cmd in cmds_list
 
 
 def find_torrent(info_hash, torrent_list):
@@ -67,11 +66,11 @@ def find_torrent(info_hash, torrent_list):
 
 def is_valid_port(port):
     """Check if given port is valid"""
-    return(0 <= int(port) <= 65535)
+    return 0 <= int(port) <= 65535
 
 
 def convert_version_tuple_to_str(t):
-    return(".".join([str(n) for n in t]))
+    return '.'.join([str(n) for n in t])
 
 
 def safe_repr(fmt, *args, **kwargs):
@@ -79,8 +78,73 @@ def safe_repr(fmt, *args, **kwargs):
 
     if not is_py3():
         # unicode fmt can take str args, str fmt cannot take unicode args
-        fmt = fmt.decode("utf-8")
+        fmt = fmt.decode('utf-8')
         out = fmt.format(*args, **kwargs)
-        return out.encode("utf-8")
-    else:
-        return fmt.format(*args, **kwargs)
+        return out.encode('utf-8')
+
+    return fmt.format(*args, **kwargs)
+
+
+def split_path(path):
+    fragments = path.split('/')
+
+    if 1 == len(fragments):
+        return fragments
+
+    if not fragments[-1]:
+        return fragments[:-1]
+
+    return fragments
+
+
+def join_path(base, path):
+    # Return if we have a new absolute path
+    if os.path.isabs(path):
+        return path
+
+    # non-absolute base encountered
+    if base and not os.path.isabs(base):
+        raise NotImplementedError()
+
+    return '/'.join(split_path(base) + split_path(path))
+
+
+def join_uri(base, uri, construct=True):
+    p_uri = urlparse(uri)
+
+    # Return if there is nothing to join
+    if not p_uri.path:
+        return base
+
+    scheme, netloc, path, params, query, fragment = urlparse(base)
+
+    # Switch to 'uri' parts
+    _, _, _, params, query, fragment = p_uri
+
+    path = join_path(path, p_uri.path)
+
+    result = ParseResult(scheme, netloc, path, params, query, fragment)
+
+    if not construct:
+        return result
+
+    # Construct from parts
+    return urlunparse(result)
+
+
+def update_uri(uri, construct=True, **kwargs):
+    if isinstance(uri, ParseResult):
+        # noinspection PyProtectedMember
+        uri = dict(uri._asdict())
+
+    if type(uri) is not dict:
+        raise ValueError('Unknown URI type')
+
+    uri.update(kwargs)
+
+    result = ParseResult(**uri)
+
+    if not construct:
+        return result
+
+    return urlunparse(result)
diff --git a/lib/rtorrent/compat.py b/lib/rtorrent/compat.py
index 1778818..576a4ed 100644
--- a/lib/rtorrent/compat.py
+++ b/lib/rtorrent/compat.py
@@ -24,7 +24,17 @@ import sys
 def is_py3():
     return sys.version_info[0] == 3
 
+
 if is_py3():
+    # noinspection PyCompatibility
+    from urllib.parse import parse_qs, ParseResult, urlparse, urlunparse
+    # noinspection PyCompatibility
+    from urllib.request import urlopen
+
     import xmlrpc.client as xmlrpclib
 else:
+    from urllib2 import urlopen
+    # noinspection PyProtectedMember
+    from urlparse import parse_qs, ParseResult, urlparse, urlunparse
+
     import xmlrpclib
diff --git a/lib/rtorrent/err.py b/lib/rtorrent/err.py
index 920b838..03441da 100644
--- a/lib/rtorrent/err.py
+++ b/lib/rtorrent/err.py
@@ -18,18 +18,18 @@
 # 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 rtorrent.common import convert_version_tuple_to_str
+from common import convert_version_tuple_to_str
 
 
 class RTorrentVersionError(Exception):
     def __init__(self, min_version, cur_version):
         self.min_version = min_version
         self.cur_version = cur_version
-        self.msg = "Minimum version required: {0}".format(
+        self.msg = 'Minimum version required: {0}'.format(
             convert_version_tuple_to_str(min_version))
 
     def __str__(self):
-        return(self.msg)
+        return self.msg
 
 
 class MethodError(Exception):
@@ -37,4 +37,4 @@ class MethodError(Exception):
         self.msg = msg
 
     def __str__(self):
-        return(self.msg)
+        return self.msg
diff --git a/lib/rtorrent/file.py b/lib/rtorrent/file.py
index a3db35c..06e52a3 100644
--- a/lib/rtorrent/file.py
+++ b/lib/rtorrent/file.py
@@ -18,25 +18,22 @@
 # 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 rtorrent.rpc import Method
-import rtorrent.rpc
+from .common import safe_repr
+from .rpc import Method
+import rpc
 
-from rtorrent.common import safe_repr
 
-Method = rtorrent.rpc.Method
-
-
-class File:
+class File(object):
     """Represents an individual file within a L{Torrent} instance."""
 
     def __init__(self, _rt_obj, info_hash, index, **kwargs):
         self._rt_obj = _rt_obj
         self.info_hash = info_hash  # : info hash for the torrent the file is associated with
         self.index = index  # : The position of the file within the file list
-        for k in kwargs.keys():
+        for k in kwargs:
             setattr(self, k, kwargs.get(k, None))
 
-        self.rpc_id = "{0}:f{1}".format(
+        self.rpc_id = '{0}:f{1}'.format(
             self.info_hash, self.index)  # : unique id to pass to rTorrent
 
     def update(self):
@@ -46,44 +43,58 @@ class File:
 
         @return: None
         """
-        multicall = rtorrent.rpc.Multicall(self)
-        retriever_methods = [m for m in methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
-        for method in retriever_methods:
-            multicall.add(method, self.rpc_id)
+        mc = rpc.Multicall(self)
 
-        multicall.call()
+        for method in filter(lambda m: m.is_retriever() and m.is_available(self._rt_obj), methods):
+            mc.add(method, self.rpc_id)
+
+        mc.call()
 
     def __repr__(self):
-        return safe_repr("File(index={0} path=\"{1}\")", self.index, self.path)
+        return safe_repr('File(index={0} path="{1}")', self.index, self.path)
+
 
 methods = [
     # RETRIEVERS
-    Method(File, 'get_last_touched', 'f.get_last_touched'),
-    Method(File, 'get_range_second', 'f.get_range_second'),
-    Method(File, 'get_size_bytes', 'f.get_size_bytes'),
-    Method(File, 'get_priority', 'f.get_priority'),
-    Method(File, 'get_match_depth_next', 'f.get_match_depth_next'),
+    Method(File, 'get_last_touched', 'f.get_last_touched',
+           aliases=('f.last_touched',)),
+    Method(File, 'get_range_second', 'f.get_range_second',
+           aliases=('f.range_second',)),
+    Method(File, 'get_size_bytes', 'f.get_size_bytes',
+           aliases=('f.size_bytes',)),
+    Method(File, 'get_priority', 'f.get_priority',
+           aliases=('f.priority',)),
+    Method(File, 'get_match_depth_next', 'f.get_match_depth_next',
+           aliases=('f.match_depth_next',)),
     Method(File, 'is_resize_queued', 'f.is_resize_queued',
-           boolean=True,
+           boolean=True
            ),
-    Method(File, 'get_range_first', 'f.get_range_first'),
-    Method(File, 'get_match_depth_prev', 'f.get_match_depth_prev'),
-    Method(File, 'get_path', 'f.get_path'),
-    Method(File, 'get_completed_chunks', 'f.get_completed_chunks'),
-    Method(File, 'get_path_components', 'f.get_path_components'),
+    Method(File, 'get_range_first', 'f.get_range_first',
+           aliases=('f.range_first',)),
+    Method(File, 'get_match_depth_prev', 'f.get_match_depth_prev',
+           aliases=('f.match_depth_prev',)),
+    Method(File, 'get_path', 'f.get_path',
+           aliases=('f.path',)),
+    Method(File, 'get_completed_chunks', 'f.get_completed_chunks',
+           aliases=('f.completed_chunks',)),
+    Method(File, 'get_path_components', 'f.get_path_components',
+           aliases=('f.path_components',)),
     Method(File, 'is_created', 'f.is_created',
-           boolean=True,
+           boolean=True
            ),
     Method(File, 'is_open', 'f.is_open',
-           boolean=True,
+           boolean=True
            ),
-    Method(File, 'get_size_chunks', 'f.get_size_chunks'),
-    Method(File, 'get_offset', 'f.get_offset'),
-    Method(File, 'get_frozen_path', 'f.get_frozen_path'),
-    Method(File, 'get_path_depth', 'f.get_path_depth'),
+    Method(File, 'get_size_chunks', 'f.get_size_chunks',
+           aliases=('f.size_chunks',)),
+    Method(File, 'get_offset', 'f.get_offset',
+           aliases=('f.offset',)),
+    Method(File, 'get_frozen_path', 'f.get_frozen_path',
+           aliases=('f.frozen_path',)),
+    Method(File, 'get_path_depth', 'f.get_path_depth',
+           aliases=('f.path_depth',)),
     Method(File, 'is_create_queued', 'f.is_create_queued',
-           boolean=True,
+           boolean=True
            ),
 
 
diff --git a/lib/rtorrent/group.py b/lib/rtorrent/group.py
index e8246aa..3f8e1d0 100644
--- a/lib/rtorrent/group.py
+++ b/lib/rtorrent/group.py
@@ -18,12 +18,11 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-import rtorrent.rpc
+from .rpc import Method
+import rpc
 
-Method = rtorrent.rpc.Method
 
-
-class Group:
+class Group(object):
     __name__ = 'Group'
 
     def __init__(self, _rt_obj, name):
@@ -42,43 +41,49 @@ class Group:
             Method(Group, 'set_upload', 'group.' + self.name + '.ratio.upload.set', varname='upload')
         ]
 
-        rtorrent.rpc._build_rpc_methods(self, self.methods)
+        # noinspection PyProtectedMember
+        rpc._build_rpc_methods(self, self.methods)
 
         # Setup multicall_add method
-        caller = lambda multicall, method, *args: \
-            multicall.add(method, *args)
-        setattr(self, "multicall_add", caller)
+        caller = (lambda mc, method, *args: mc.add(method, *args))
+        setattr(self, 'multicall_add', caller)
 
     def _get_prefix(self):
         return 'group.' + self.name + '.ratio.'
 
     def update(self):
-        multicall = rtorrent.rpc.Multicall(self)
-
-        retriever_methods = [m for m in self.methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
+        mc = rpc.Multicall(self)
 
-        for method in retriever_methods:
-            multicall.add(method)
+        for method in filter(lambda m: m.is_retriever() and m.is_available(self._rt_obj), self.methods):
+            mc.add(method)
 
-        multicall.call()
+        mc.call()
 
     def enable(self):
-        p = self._rt_obj._get_conn()
+        p = self._rt_obj.get_connection()
         return getattr(p, self._get_prefix() + 'enable')()
 
     def disable(self):
-        p = self._rt_obj._get_conn()
+        p = self._rt_obj.get_connection()
         return getattr(p, self._get_prefix() + 'disable')()
 
+    def _get_method(self, *choices):
+        try:
+            return filter(lambda method: self._rt_obj.method_exists(method), choices)[0]
+        except(Exception, BaseException):
+            pass
+
     def set_command(self, *methods):
-        methods = [m + '=' for m in methods]
+        method = self._get_method(*('system.method.set', 'method.set'))
+        if method:
+            methods = [m + '=' for m in methods]
+
+            mc = rpc.Multicall(self)
 
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(
-            m, 'system.method.set',
-            self._get_prefix() + 'command',
-            *methods
-        )
+            self.multicall_add(
+                mc, method,
+                self._get_prefix() + 'command',
+                *methods
+            )
 
-        return(m.call()[-1])
+            return mc.call()[-1]
diff --git a/lib/rtorrent/lib/torrentparser.py b/lib/rtorrent/lib/torrentparser.py
index b59ae22..6d554e9 100644
--- a/lib/rtorrent/lib/torrentparser.py
+++ b/lib/rtorrent/lib/torrentparser.py
@@ -18,19 +18,15 @@
 # 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 rtorrent.compat import is_py3
+from ..compat import parse_qs, urlopen, urlparse
+import bencode
+
+import hashlib
 import os.path
 import re
-import rtorrent.lib.bencode as bencode
-import hashlib
 
-if is_py3():
-    from urllib.request import urlopen  # @UnresolvedImport @UnusedImport
-else:
-    from urllib2 import urlopen  # @UnresolvedImport @Reimport
 
-
-class TorrentParser():
+class TorrentParser(object):
     def __init__(self, torrent):
         """Decode and parse given torrent
 
@@ -48,12 +44,16 @@ class TorrentParser():
         self.file_type = None
 
         self._get_raw_torrent()
-        assert self._raw_torrent is not None, "Couldn't get raw_torrent."
+        assert self._raw_torrent is not None, 'Couldn\'t get raw_torrent.'
         if self._torrent_decoded is None:
             self._decode_torrent()
-        assert isinstance(self._torrent_decoded, dict), "Invalid torrent file."
+        assert isinstance(self._torrent_decoded, dict), 'Invalid torrent file.'
         self._parse_torrent()
 
+    @property
+    def raw_torrent(self):
+        return self._raw_torrent
+
     def _is_raw(self):
         raw = False
         if isinstance(self.torrent, (str, bytes)):
@@ -63,43 +63,57 @@ class TorrentParser():
                 # reset self._torrent_decoded (currently equals False)
                 self._torrent_decoded = None
 
-        return(raw)
+        return raw
 
     def _get_raw_torrent(self):
         """Get raw torrent data by determining what self.torrent is"""
         # already raw?
         if self._is_raw():
-            self.file_type = "raw"
+            self.file_type = 'raw'
             self._raw_torrent = self.torrent
             return
         # local file?
         if os.path.isfile(self.torrent):
-            self.file_type = "file"
-            self._raw_torrent = open(self.torrent, "rb").read()
+            self.file_type = 'file'
+            self._raw_torrent = open(self.torrent, 'rb').read()
         # url?
-        elif re.search("^(http|ftp)s?:\/\/", self.torrent, re.I):
-            self.file_type = "url"
+        elif re.search(r'^(http|ftp)s?://', self.torrent, re.I):
+            self.file_type = 'url'
             self._raw_torrent = urlopen(self.torrent).read()
+        # magnet link?
+        elif re.match(r'magnet:', self.torrent, re.I):
+            self.file_type = 'url'
+            query = {}
+            try:
+                parsed = urlparse(self.torrent)
+                query = parse_qs(parsed.query)
+            except(Exception, BaseException):
+                pass
+            self.title = query.get('dn', [''])[0]
+            self.info_hash = query.get('xt', [''])[0].split(':')[-1]
+            self.trackers = query.get('tr', [])
+            self._torrent_decoded = query
+            self._raw_torrent = self.torrent
 
     def _decode_torrent(self, raw_torrent=None):
         if raw_torrent is None:
             raw_torrent = self._raw_torrent
         self._torrent_decoded = bencode.decode(raw_torrent)
-        return(self._torrent_decoded)
+        return self._torrent_decoded
 
     def _calc_info_hash(self):
         self.info_hash = None
-        if "info" in self._torrent_decoded.keys():
-            info_encoded = bencode.encode(self._torrent_decoded["info"])
+        if 'info' in self._torrent_decoded:
+            info_encoded = bencode.encode(self._torrent_decoded['info'])
 
             if info_encoded:
                 self.info_hash = hashlib.sha1(info_encoded).hexdigest().upper()
 
-        return(self.info_hash)
+        return self.info_hash
 
     def _parse_torrent(self):
         for k in self._torrent_decoded:
-            key = k.replace(" ", "_").lower()
+            key = k.replace(' ', '_').lower()
             setattr(self, key, self._torrent_decoded[k])
 
         self._calc_info_hash()
@@ -119,8 +133,8 @@ class NewTorrentParser(object):
     def _decode_torrent(data):
         return bencode.decode(data)
 
-    def __init__(self, input):
-        self.input = input
+    def __init__(self, infile):
+        self.input = infile
         self._raw_torrent = None
         self._decoded_torrent = None
         self._hash_outdated = False
@@ -128,33 +142,33 @@ class NewTorrentParser(object):
         if isinstance(self.input, (str, bytes)):
             # path to file?
             if os.path.isfile(self.input):
-                self._raw_torrent = self._read_file(open(self.input, "rb"))
+                self._raw_torrent = self._read_file(open(self.input, 'rb'))
             else:
                 # assume input was the raw torrent data (do we really want
                 # this?)
                 self._raw_torrent = self.input
 
         # file-like object?
-        elif self.input.hasattr("read"):
+        elif self.input.hasattr('read'):
             self._raw_torrent = self._read_file(self.input)
 
-        assert self._raw_torrent is not None, "Invalid input: input must be a path or a file-like object"
+        assert self._raw_torrent is not None, 'Invalid input: input must be a path or a file-like object'
 
         self._decoded_torrent = self._decode_torrent(self._raw_torrent)
 
         assert isinstance(
-            self._decoded_torrent, dict), "File could not be decoded"
+            self._decoded_torrent, dict), 'File could not be decoded'
 
     def _calc_info_hash(self):
         self.info_hash = None
-        info_dict = self._torrent_decoded["info"]
+        info_dict = self._torrent_decoded['info']
         self.info_hash = hashlib.sha1(bencode.encode(
             info_dict)).hexdigest().upper()
 
-        return(self.info_hash)
+        return self.info_hash
 
     def set_tracker(self, tracker):
-        self._decoded_torrent["announce"] = tracker
+        self._decoded_torrent['announce'] = tracker
 
     def get_tracker(self):
-        return self._decoded_torrent.get("announce")
+        return self._decoded_torrent.get('announce')
diff --git a/lib/rtorrent/lib/xmlrpc/basic_auth.py b/lib/rtorrent/lib/xmlrpc/basic_auth.py
index 76344c5..a4b1f26 100644
--- a/lib/rtorrent/lib/xmlrpc/basic_auth.py
+++ b/lib/rtorrent/lib/xmlrpc/basic_auth.py
@@ -20,27 +20,44 @@
 # 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 base64 import encodestring
-import string
-try:
-    import xmlrpc.client as xmlrpclib
-except:
-    import xmlrpclib
+from ...compat import xmlrpclib
+
+from base64 import b64encode
+import httplib
 
 
 class BasicAuthTransport(xmlrpclib.Transport):
-    def __init__(self, username=None, password=None):
+    def __init__(self, secure=False, username=None, password=None):
         xmlrpclib.Transport.__init__(self)
 
+        self.secure = secure
+
         self.username = username
         self.password = password
 
+        self.verbose = None
+
     def send_auth(self, h):
-        if self.username is not None and self.password is not None:
-            h.putheader('AUTHORIZATION', "Basic %s" % string.replace(
-                encodestring("%s:%s" % (self.username, self.password)),
-                "\012", ""
-            ))
+        if self.username and self.password:
+            h.putheader('Authorization', 'Basic %s' % b64encode('%s:%s' % (self.username, self.password)))
+
+    def make_connection(self, host):
+        if self._connection and host == self._connection[0]:
+            return self._connection[1]
+
+        chost, self._extra_headers, x509 = self.get_host_info(host)
+
+        if self.secure:
+            try:
+                self._connection = host, httplib.HTTPSConnection(chost, None, **(x509 or {}))
+            except AttributeError:
+                raise NotImplementedError(
+                    'In use version of httplib doesn\'t support HTTPS'
+                )
+        else:
+            self._connection = host, httplib.HTTPConnection(chost)
+
+        return self._connection[1]
 
     def single_request(self, host, handler, request_body, verbose=0):
         # issue XML-RPC request
@@ -57,7 +74,7 @@ class BasicAuthTransport(xmlrpclib.Transport):
             self.send_content(h, request_body)
 
             response = h.getresponse(buffering=True)
-            if response.status == 200:
+            if 200 == response.status:
                 self.verbose = verbose
                 return self.parse_response(response)
         except xmlrpclib.Fault:
@@ -66,8 +83,8 @@ class BasicAuthTransport(xmlrpclib.Transport):
             self.close()
             raise
 
-        #discard any response data and raise exception
-        if response.getheader("content-length", 0):
+        # discard any response data and raise exception
+        if response.getheader('content-length', 0):
             response.read()
         raise xmlrpclib.ProtocolError(
             host + handler,
diff --git a/lib/rtorrent/lib/xmlrpc/http.py b/lib/rtorrent/lib/xmlrpc/http.py
index 3eb8521..bf41c8c 100644
--- a/lib/rtorrent/lib/xmlrpc/http.py
+++ b/lib/rtorrent/lib/xmlrpc/http.py
@@ -18,6 +18,6 @@
 # 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 rtorrent.compat import xmlrpclib
+from ...compat import xmlrpclib
 
 HTTPServerProxy = xmlrpclib.ServerProxy
diff --git a/lib/rtorrent/lib/xmlrpc/scgi.py b/lib/rtorrent/lib/xmlrpc/scgi.py
index 5c647fb..ef11373 100644
--- a/lib/rtorrent/lib/xmlrpc/scgi.py
+++ b/lib/rtorrent/lib/xmlrpc/scgi.py
@@ -82,39 +82,14 @@
 # OF THIS SOFTWARE.
 from __future__ import print_function
 
-try:
-    import http.client as httplib
-except ImportError:
-    import httplib
 import re
 import socket
 import sys
-try:
-    import urllib.parse as urlparser
-except ImportError:
-    import urllib as urlparser
 
-try:
-    import xmlrpc.client as xmlrpclib
-except:
-    import xmlrpclib
-
-import errno
+from ...compat import urlparse, xmlrpclib
 
 
 class SCGITransport(xmlrpclib.Transport):
-    # Added request() from Python 2.7 xmlrpclib here to backport to Python 2.6
-    def request(self, host, handler, request_body, verbose=0):
-        #retry request once if cached connection has gone cold
-        for i in (0, 1):
-            try:
-                return self.single_request(host, handler, request_body, verbose)
-            except socket.error as e:
-                if i or e.errno not in (errno.ECONNRESET, errno.ECONNABORTED, errno.EPIPE):
-                    raise
-            except httplib.BadStatusLine: #close after we sent request
-                if i:
-                    raise
 
     def single_request(self, host, handler, request_body, verbose=0):
         # Add SCGI headers to the request.
@@ -127,7 +102,9 @@ class SCGITransport(xmlrpclib.Transport):
 
         try:
             if host:
-                host, port = urlparser.splitport(host)
+                parsed = urlparse('//' + host)
+                host, port = parsed.hostname, parsed.port
+
                 addrinfo = socket.getaddrinfo(host, int(port), socket.AF_INET,
                                               socket.SOCK_STREAM)
                 sock = socket.socket(*addrinfo[0][:3])
@@ -136,10 +113,12 @@ class SCGITransport(xmlrpclib.Transport):
                 sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
                 sock.connect(handler)
 
+            # noinspection PyAttributeOutsideInit
             self.verbose = verbose
 
             if sys.version_info[0] > 2:
-                sock.send(bytes(request_body, "utf-8"))
+                # noinspection PyArgumentList
+                sock.send(bytes(request_body, 'utf-8'))  # py3
             else:
                 sock.send(request_body)
             return self.parse_response(sock.makefile())
@@ -163,10 +142,9 @@ class SCGITransport(xmlrpclib.Transport):
             print('body:', repr(response_body))
 
         try:
-            response_header, response_body = re.split(r'\n\s*?\n', response_body,
-                                                  maxsplit=1)
+            response_header, response_body = re.split(r'\n\s*?\n', response_body, maxsplit=1)
         except ValueError:
-            print("error in response: %s", response_body)
+            print('error in response: %s', response_body)
             p.close()
             u.close()
 
@@ -177,12 +155,14 @@ class SCGITransport(xmlrpclib.Transport):
 
 
 class SCGIServerProxy(xmlrpclib.ServerProxy):
-    def __init__(self, uri, transport=None, encoding=None, verbose=False,
-                 allow_none=False, use_datetime=False):
-        type, uri = urlparser.splittype(uri)
-        if type not in ('scgi'):
+
+    # noinspection PyMissingConstructor
+    def __init__(self, uri, transport=None, encoding=None, verbose=False, allow_none=False, use_datetime=False):
+
+        parsed = urlparse(uri)
+        if 'scgi' != parsed.scheme:
             raise IOError('unsupported XML-RPC protocol')
-        self.__host, self.__handler = urlparser.splithost(uri)
+        self.__host, self.__handler = parsed.netloc, parsed.path
         if not self.__handler:
             self.__handler = '/'
 
@@ -194,14 +174,10 @@ class SCGIServerProxy(xmlrpclib.ServerProxy):
         self.__verbose = verbose
         self.__allow_none = allow_none
 
-    def __close(self):
-        self.__transport.close()
-
     def __request(self, methodname, params):
         # call a method on the remote server
 
-        request = xmlrpclib.dumps(params, methodname, encoding=self.__encoding,
-                                  allow_none=self.__allow_none)
+        request = xmlrpclib.dumps(params, methodname, encoding=self.__encoding, allow_none=self.__allow_none)
 
         response = self.__transport.request(
             self.__host,
@@ -210,22 +186,22 @@ class SCGIServerProxy(xmlrpclib.ServerProxy):
             verbose=self.__verbose
         )
 
-        if len(response) == 1:
+        if 1 == len(response):
             response = response[0]
 
         return response
 
     def __repr__(self):
-        return (
-            "<SCGIServerProxy for %s%s>" %
-            (self.__host, self.__handler)
-        )
+        return ('<SCGIServerProxy for %s%s>' %
+                (self.__host, self.__handler))
 
     __str__ = __repr__
 
     def __getattr__(self, name):
         # magic method dispatcher
+        # noinspection PyProtectedMember
         return xmlrpclib._Method(self.__request, name)
+        # return _Method(self.__request, name)
 
     # note: to call a remote object with an non-standard name, use
     # result getattr(server, "strange-python-name")(args)
@@ -234,8 +210,8 @@ class SCGIServerProxy(xmlrpclib.ServerProxy):
         """A workaround to get special attributes on the ServerProxy
            without interfering with the magic __getattr__
         """
-        if attr == "close":
+        if 'close' == attr:
             return self.__close
-        elif attr == "transport":
+        elif 'transport' == attr:
             return self.__transport
-        raise AttributeError("Attribute %r not found" % (attr,))
+        raise AttributeError('Attribute %r not found' % (attr,))
diff --git a/lib/rtorrent/peer.py b/lib/rtorrent/peer.py
index 61ca094..b617577 100644
--- a/lib/rtorrent/peer.py
+++ b/lib/rtorrent/peer.py
@@ -18,27 +18,24 @@
 # 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 rtorrent.rpc import Method
-import rtorrent.rpc
+from .common import safe_repr
+from .rpc import Method
+import rpc
 
-from rtorrent.common import safe_repr
 
-Method = rtorrent.rpc.Method
-
-
-class Peer:
+class Peer(object):
     """Represents an individual peer within a L{Torrent} instance."""
     def __init__(self, _rt_obj, info_hash, **kwargs):
         self._rt_obj = _rt_obj
         self.info_hash = info_hash  # : info hash for the torrent the peer is associated with
-        for k in kwargs.keys():
+        for k in kwargs:
             setattr(self, k, kwargs.get(k, None))
 
-        self.rpc_id = "{0}:p{1}".format(
+        self.rpc_id = '{0}:p{1}'.format(
             self.info_hash, self.id)  # : unique id to pass to rTorrent
 
     def __repr__(self):
-        return safe_repr("Peer(id={0})", self.id)
+        return safe_repr('Peer(id={0})', self.id)
 
     def update(self):
         """Refresh peer data
@@ -47,52 +44,65 @@ class Peer:
 
         @return: None
         """
-        multicall = rtorrent.rpc.Multicall(self)
-        retriever_methods = [m for m in methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
-        for method in retriever_methods:
-            multicall.add(method, self.rpc_id)
+        mc = rpc.Multicall(self)
+
+        for method in filter(lambda fx: fx.is_retriever() and fx.is_available(self._rt_obj), methods):
+            mc.add(method, self.rpc_id)
+
+        mc.call()
 
-        multicall.call()
 
 methods = [
     # RETRIEVERS
     Method(Peer, 'is_preferred', 'p.is_preferred',
            boolean=True,
            ),
-    Method(Peer, 'get_down_rate', 'p.get_down_rate'),
+    Method(Peer, 'get_down_rate', 'p.get_down_rate',
+           aliases=('p.down_rate',)),
     Method(Peer, 'is_unwanted', 'p.is_unwanted',
            boolean=True,
            ),
-    Method(Peer, 'get_peer_total', 'p.get_peer_total'),
-    Method(Peer, 'get_peer_rate', 'p.get_peer_rate'),
-    Method(Peer, 'get_port', 'p.get_port'),
+    Method(Peer, 'get_peer_total', 'p.get_peer_total',
+           aliases=('p.peer_total',)),
+    Method(Peer, 'get_peer_rate', 'p.get_peer_rate',
+           aliases=('p.peer_rate',)),
+    Method(Peer, 'get_port', 'p.get_port',
+           aliases=('p.port',)),
     Method(Peer, 'is_snubbed', 'p.is_snubbed',
            boolean=True,
            ),
-    Method(Peer, 'get_id_html', 'p.get_id_html'),
-    Method(Peer, 'get_up_rate', 'p.get_up_rate'),
+    Method(Peer, 'get_id_html', 'p.get_id_html',
+           aliases=('p.id_html',)),
+    Method(Peer, 'get_up_rate', 'p.get_up_rate',
+           aliases=('p.up_rate',)),
     Method(Peer, 'is_banned', 'p.banned',
            boolean=True,
            ),
-    Method(Peer, 'get_completed_percent', 'p.get_completed_percent'),
+    Method(Peer, 'get_completed_percent', 'p.get_completed_percent',
+           aliases=('p.completed_percent',)),
     Method(Peer, 'completed_percent', 'p.completed_percent'),
-    Method(Peer, 'get_id', 'p.get_id'),
+    Method(Peer, 'get_id', 'p.get_id',
+           aliases=('p.id',)),
     Method(Peer, 'is_obfuscated', 'p.is_obfuscated',
            boolean=True,
            ),
-    Method(Peer, 'get_down_total', 'p.get_down_total'),
-    Method(Peer, 'get_client_version', 'p.get_client_version'),
-    Method(Peer, 'get_address', 'p.get_address'),
+    Method(Peer, 'get_down_total', 'p.get_down_total',
+           aliases=('p.down_total',)),
+    Method(Peer, 'get_client_version', 'p.get_client_version',
+           aliases=('p.client_version',)),
+    Method(Peer, 'get_address', 'p.get_address',
+           aliases=('p.address',)),
     Method(Peer, 'is_incoming', 'p.is_incoming',
            boolean=True,
            ),
     Method(Peer, 'is_encrypted', 'p.is_encrypted',
            boolean=True,
            ),
-    Method(Peer, 'get_options_str', 'p.get_options_str'),
+    Method(Peer, 'get_options_str', 'p.get_options_str',
+           aliases=('p.options_str',)),
     Method(Peer, 'get_client_version', 'p.client_version'),
-    Method(Peer, 'get_up_total', 'p.get_up_total'),
+    Method(Peer, 'get_up_total', 'p.get_up_total',
+           aliases=('p.up_total',)),
 
     # MODIFIERS
 ]
diff --git a/lib/rtorrent/rpc/__init__.py b/lib/rtorrent/rpc/__init__.py
index 116ca1c..c1dba01 100644
--- a/lib/rtorrent/rpc/__init__.py
+++ b/lib/rtorrent/rpc/__init__.py
@@ -10,7 +10,7 @@
 # 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,
+# 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
@@ -18,13 +18,14 @@
 # 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 rtorrent
 import re
-from rtorrent.common import bool_to_int, convert_version_tuple_to_str,\
-    safe_repr
-from rtorrent.err import MethodError
-from rtorrent.compat import xmlrpclib
+
+import rtorrent
 
 
 def get_varname(rpc_call):
@@ -36,91 +37,78 @@ def get_varname(rpc_call):
     """
     # extract variable name from xmlrpc func name
     r = re.search(
-        "([ptdf]\.|system\.|get\_|is\_|set\_)+([^=]*)", rpc_call, re.I)
+        r'(^([dtfp]|system)\.|(is|[sg]et)_)+([^=]*?)(?:=|.[sg]et)?$', rpc_call, re.I)
     if r:
-        return(r.groups()[-1])
-    else:
-        return(None)
+        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))
+    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:
+class DummyClass(object):
     def __init__(self):
         pass
 
 
-class Method:
+class Method(object):
     """Represents an individual RPC method"""
 
-    def __init__(self, _class, method_name,
-                 rpc_call, docstring=None, varname=None, **kwargs):
+    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.varname = varname  # : variable for the result of the method call, usually set to self.varname
-        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.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()
-
-        if self.varname is None:
-            self.varname = get_varname(self.rpc_call)
-        assert self.varname is not None, "Couldn't get variable name."
+        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)
+        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 self.method_name[:4] == "set_": return('m')  # modifier
-        else:
-            return('r')  # retriever
+        if 'set_' == self.method_name[:4]:
+            return 'm'  # modifier
+        return 'r'  # retriever
 
     def is_modifier(self):
-        if self.method_type == 'm':
-            return(True)
-        else:
-            return(False)
+        return 'm' == self.method_type
 
     def is_retriever(self):
-        if self.method_type == 'r':
-            return(True)
-        else:
-            return(False)
+        return 'r' == self.method_type
 
     def is_available(self, rt_obj):
-        if rt_obj._get_client_version_tuple() < self.min_version or \
-                self.rpc_call not in rt_obj._get_rpc_methods():
-            return(False)
-        else:
-            return(True)
+
+        if rt_obj.get_client_version_tuple() >= self.min_version:
+            try:
+                self.varname = get_varname(filter(lambda f: rt_obj.method_exists(f),
+                                                  (self.rpc_call,) + tuple(getattr(self, 'aliases', '')))[0])
+                return True
+            except IndexError:
+                pass
+
+        return False
 
 
-class Multicall:
+class Multicall(object):
+    # noinspection PyUnusedLocal
     def __init__(self, class_obj, **kwargs):
         self.class_obj = class_obj
-        if class_obj.__class__.__name__ == "RTorrent":
+        if 'RTorrent' == class_obj.__class__.__name__:
             self.rt_obj = class_obj
         else:
+            # noinspection PyProtectedMember
             self.rt_obj = class_obj._rt_obj
         self.calls = []
 
@@ -138,7 +126,8 @@ class Multicall:
         if isinstance(method, str):
             result = find_method(method)
             # if result not found
-            if result == -1:
+            if -1 == result:
+                # noinspection PyTypeChecker
                 method = Method(DummyClass, method, method)
             else:
                 method = result
@@ -159,17 +148,25 @@ class Multicall:
         @return: the results (post-processed), in the order they were added
         @rtype: tuple
         """
-        m = xmlrpclib.MultiCall(self.rt_obj._get_conn())
+        xmc = xmlrpclib.MultiCall(self.rt_obj.get_connection())
         for call in self.calls:
             method, args = call
-            rpc_call = getattr(method, "rpc_call")
-            getattr(m, rpc_call)(*args)
+            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(filter(lambda x: isinstance(x, list), xmc().results)[0])
+        except IndexError:
+            return [[]]
 
-        results = m()
-        results = tuple(results)
         results_processed = []
 
-        for r, c in zip(results, self.calls):
+        for r, c in list(zip(results, self.calls)):
             method = c[0]  # Method instance
             result = process_result(method, r)
             results_processed.append(result)
@@ -178,7 +175,7 @@ class Multicall:
             if not exists or not inspect.ismethod(getattr(self.class_obj, method.varname)):
                 setattr(self.class_obj, method.varname, result)
 
-        return(tuple(results_processed))
+        return tuple(results_processed)
 
 
 def call_method(class_obj, method, *args):
@@ -193,51 +190,35 @@ def call_method(class_obj, method, *args):
     if method.is_retriever():
         args = args[:-1]
     else:
-        assert args[-1] is not None, "No argument given."
+        assert args[-1] is not None, 'No argument given.'
 
-    if class_obj.__class__.__name__ == "RTorrent":
+    if 'RTorrent' == class_obj.__class__.__name__:
         rt_obj = class_obj
     else:
+        # noinspection PyProtectedMember
         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)
 
-    m = Multicall(class_obj)
-    m.add(method, *args)
+    mc = Multicall(class_obj)
+    mc.add(method, *args)
     # only added one method, only getting one result back
-    ret_value = m.call()[0]
+    ret_value = mc.call()[0]
 
-    ####### OBSOLETE ##########################################################
-    # if method.is_retriever():
-    #    #value = process_result(method, ret_value)
-    #    value = ret_value #MultiCall already processed the result
-    # else:
-    #    # we're setting the user's input to method.varname
-    #    # but we'll return the value that xmlrpc gives us
-    #    value = process_result(method, args[-1])
-    ##########################################################################
-
-    return(ret_value)
+    return ret_value
 
 
 def find_method(rpc_call):
     """Return L{Method} instance associated with given RPC call"""
-    method_lists = [
-        rtorrent.methods,
-        rtorrent.file.methods,
-        rtorrent.tracker.methods,
-        rtorrent.peer.methods,
-        rtorrent.torrent.methods,
-    ]
-
-    for l in method_lists:
-        for m in l:
-            if m.rpc_call.lower() == rpc_call.lower():
-                return(m)
-
-    return(-1)
+    try:
+        rpc_call = rpc_call.lower()
+        return filter(lambda m: rpc_call in 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)[0]
+    except IndexError:
+        return -1
 
 
 def process_result(method, result):
@@ -249,7 +230,7 @@ def process_result(method, result):
     @param result: result to be processed (the result of given L{Method} instance)
 
     @note: Supported Processing:
-        - boolean - convert ones and zeros returned by rTorrent and
+        - bololean - convert ones and zeros returned by rTorrent and
         convert to python boolean values
     """
     # handle custom post processing function
@@ -263,7 +244,7 @@ def process_result(method, result):
         elif result in [0, '0']:
             result = False
 
-    return(result)
+    return result
 
 
 def _build_rpc_methods(class_, method_list):
@@ -273,47 +254,26 @@ def _build_rpc_methods(class_, method_list):
         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
 
-        if class_name == "RTorrent":
-            caller = lambda self, arg = None, method = m:\
-                call_method(self, method, bool_to_int(arg))
-        elif class_name == "Torrent":
-            caller = lambda self, arg = None, method = m:\
-                call_method(self, method, self.rpc_id,
-                            bool_to_int(arg))
-        elif class_name in ["Tracker", "File"]:
-            caller = lambda self, arg = None, method = m:\
-                call_method(self, method, self.rpc_id,
-                            bool_to_int(arg))
-
-        elif class_name == "Peer":
-            caller = lambda self, arg = None, method = m:\
-                call_method(self, method, self.rpc_id,
-                            bool_to_int(arg))
-
-        elif class_name == "Group":
-            caller = lambda arg = None, method = m: \
-                call_method(instance, method, bool_to_int(arg))
-
-        if m.docstring is None:
-            m.docstring = ""
-
-        # print(m)
-        docstring = """{0}
-
-        @note: Variable where the result for this method is stored: {1}.{2}""".format(
-            m.docstring,
-            class_name,
-            m.varname)
-
-        caller.__doc__ = docstring
-
-        for method_name in [m.method_name] + list(m.aliases):
-            if instance is None:
-                setattr(class_, method_name, caller)
-            else:
-                setattr(instance, method_name, caller)
+        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)
diff --git a/lib/rtorrent/torrent.py b/lib/rtorrent/torrent.py
index a158651..05734f4 100644
--- a/lib/rtorrent/torrent.py
+++ b/lib/rtorrent/torrent.py
@@ -18,40 +18,38 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-import rtorrent.rpc
-# from rtorrent.rpc import Method
-import rtorrent.peer
-import rtorrent.tracker
-import rtorrent.file
-import rtorrent.compat
+from .common import safe_repr
 
-from rtorrent.common import safe_repr
+from .file import File, methods as file_methods
+from .peer import Peer, methods as peer_methods
+from .tracker import Tracker, methods as tracker_methods
+from .rpc import Method
+import rpc
 
-Peer = rtorrent.peer.Peer
-Tracker = rtorrent.tracker.Tracker
-File = rtorrent.file.File
-Method = rtorrent.rpc.Method
 
-
-class Torrent:
+class Torrent(object):
     """Represents an individual torrent within a L{RTorrent} instance."""
 
     def __init__(self, _rt_obj, info_hash, **kwargs):
         self._rt_obj = _rt_obj
         self.info_hash = info_hash  # : info hash for the torrent
         self.rpc_id = self.info_hash  # : unique id to pass to rTorrent
-        for k in kwargs.keys():
+        for k in kwargs:
             setattr(self, k, kwargs.get(k, None))
 
         self.peers = []
         self.trackers = []
         self.files = []
+        self.hashing = None
+        self.state = None
+        self.directory = None
+        self.active = None
 
         self._call_custom_methods()
 
     def __repr__(self):
-        return safe_repr("Torrent(info_hash=\"{0}\" name=\"{1}\")",
-                        self.info_hash, self.name)
+        return safe_repr('Torrent(info_hash="{0}" name="{1}")',
+                         self.info_hash, self.name)
 
     def _call_custom_methods(self):
         """only calls methods that check instance variables."""
@@ -68,25 +66,23 @@ class Torrent:
         @note: also assigns return value to self.peers
         """
         self.peers = []
-        retriever_methods = [m for m in rtorrent.peer.methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
+        retriever_methods = filter(lambda m: m.is_retriever() and m.is_available(self._rt_obj), peer_methods)
+        mc = rpc.Multicall(self)
+
         # need to leave 2nd arg empty (dunno why)
-        m = rtorrent.rpc.Multicall(self)
-        m.add("p.multicall", self.info_hash, "",
-              *[method.rpc_call + "=" for method in retriever_methods])
+        mc.add('p.multicall', self.info_hash, '', *[method.rpc_call + '=' for method in retriever_methods])
 
-        results = m.call()[0]  # only sent one call, only need first result
+        results = mc.call()[0]  # only sent one call, only need first result
 
         for result in results:
             results_dict = {}
             # build results_dict
-            for m, r in zip(retriever_methods, result):
-                results_dict[m.varname] = rtorrent.rpc.process_result(m, r)
+            for mc, r in zip(retriever_methods, result):
+                results_dict[mc.varname] = rpc.process_result(mc, r)
 
-            self.peers.append(Peer(
-                self._rt_obj, self.info_hash, **results_dict))
+            self.peers.append(Peer(self._rt_obj, self.info_hash, **results_dict))
 
-        return(self.peers)
+        return self.peers
 
     def get_trackers(self):
         """Get list of Tracker instances for given torrent.
@@ -97,26 +93,23 @@ class Torrent:
         @note: also assigns return value to self.trackers
         """
         self.trackers = []
-        retriever_methods = [m for m in rtorrent.tracker.methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
+        retriever_methods = filter(lambda m: m.is_retriever() and m.is_available(self._rt_obj), tracker_methods)
+        mc = rpc.Multicall(self)
 
         # need to leave 2nd arg empty (dunno why)
-        m = rtorrent.rpc.Multicall(self)
-        m.add("t.multicall", self.info_hash, "",
-              *[method.rpc_call + "=" for method in retriever_methods])
+        mc.add('t.multicall', self.info_hash, '', *[method.rpc_call + '=' for method in retriever_methods])
 
-        results = m.call()[0]  # only sent one call, only need first result
+        results = mc.call()[0]  # only sent one call, only need first result
 
         for result in results:
             results_dict = {}
             # build results_dict
-            for m, r in zip(retriever_methods, result):
-                results_dict[m.varname] = rtorrent.rpc.process_result(m, r)
+            for mc, r in zip(retriever_methods, result):
+                results_dict[mc.varname] = rpc.process_result(mc, r)
 
-            self.trackers.append(Tracker(
-                self._rt_obj, self.info_hash, **results_dict))
+            self.trackers.append(Tracker(self._rt_obj, self.info_hash, **results_dict))
 
-        return(self.trackers)
+        return self.trackers
 
     def get_files(self):
         """Get list of File instances for given torrent.
@@ -128,18 +121,15 @@ class Torrent:
         """
 
         self.files = []
-        retriever_methods = [m for m in rtorrent.file.methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
+        retriever_methods = filter(lambda m: m.is_retriever() and m.is_available(self._rt_obj), file_methods)
+        mc = rpc.Multicall(self)
+
         # 2nd arg can be anything, but it'll return all files in torrent
-        # regardless
-        m = rtorrent.rpc.Multicall(self)
-        m.add("f.multicall", self.info_hash, "",
-              *[method.rpc_call + "=" for method in retriever_methods])
+        mc.add('f.multicall', self.info_hash, '', *[method.rpc_call + '=' for method in retriever_methods])
 
-        results = m.call()[0]  # only sent one call, only need first result
+        results = mc.call()[0]  # only sent one call, only need first result
 
-        offset_method_index = retriever_methods.index(
-            rtorrent.rpc.find_method("f.get_offset"))
+        offset_method_index = retriever_methods.index(rpc.find_method('f.get_offset'))
 
         # make a list of the offsets of all the files, sort appropriately
         offset_list = sorted([r[offset_method_index] for r in results])
@@ -147,17 +137,33 @@ class Torrent:
         for result in results:
             results_dict = {}
             # build results_dict
-            for m, r in zip(retriever_methods, result):
-                results_dict[m.varname] = rtorrent.rpc.process_result(m, r)
+            for mc, r in zip(retriever_methods, result):
+                results_dict[mc.varname] = rpc.process_result(mc, r)
 
             # get proper index positions for each file (based on the file
             # offset)
-            f_index = offset_list.index(results_dict["offset"])
+            f_index = offset_list.index(results_dict['offset'])
+
+            self.files.append(File(self._rt_obj, self.info_hash, f_index, **results_dict))
+
+        return self.files
+
+    def _get_method(self, *choices):
+
+        try:
+            return filter(lambda method: self._rt_obj.method_exists(method), choices)[0]
+        except(Exception, BaseException):
+            pass
 
-            self.files.append(File(self._rt_obj, self.info_hash,
-                                   f_index, **results_dict))
+    def get_state(self):
 
-        return(self.files)
+        method = self._get_method(*('d.get_state', 'd.state'))
+        if method:
+            mc = rpc.Multicall(self)
+
+            self.multicall_add(mc, method)
+
+            return mc.call()[-1]
 
     def set_directory(self, d):
         """Modify download directory
@@ -166,11 +172,14 @@ class Torrent:
         Also doesn't restart after directory is set, that must be called
         separately.
         """
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.try_stop")
-        self.multicall_add(m, "d.set_directory", d)
+        method = self._get_method(*('d.set_directory', 'd.directory.set'))
+        if method:
+            mc = rpc.Multicall(self)
+
+            self.multicall_add(mc, 'd.try_stop')
+            self.multicall_add(mc, method, d)
 
-        self.directory = m.call()[-1]
+            self.directory = mc.call()[-1]
 
     def set_directory_base(self, d):
         """Modify base download directory
@@ -179,64 +188,74 @@ class Torrent:
         Also doesn't restart after directory is set, that must be called
         separately.
         """
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.try_stop")
-        self.multicall_add(m, "d.set_directory_base", d)
+        method = self._get_method(*('d.set_directory_base', 'd.directory_base.set'))
+        if method:
+            mc = rpc.Multicall(self)
+
+            self.multicall_add(mc, 'd.try_stop')
+            self.multicall_add(mc, method, d)
 
     def start(self):
         """Start the torrent"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.try_start")
-        self.multicall_add(m, "d.is_active")
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.try_start')
+        self.multicall_add(mc, 'd.is_active')
 
-        self.active = m.call()[-1]
-        return(self.active)
+        self.active = mc.call()[-1]
+        return self.active
 
     def stop(self):
         """"Stop the torrent"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.try_stop")
-        self.multicall_add(m, "d.is_active")
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.try_stop')
+        self.multicall_add(mc, 'd.is_active')
 
-        self.active = m.call()[-1]
-        return(self.active)
+        self.active = mc.call()[-1]
+        return self.active
 
     def pause(self):
         """Pause the torrent"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.pause")
+        mc = rpc.Multicall(self)
 
-        return(m.call()[-1])
+        self.multicall_add(mc, 'd.pause')
+
+        return mc.call()[-1]
 
     def resume(self):
         """Resume the torrent"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.resume")
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.resume')
 
-        return(m.call()[-1])
+        return mc.call()[-1]
 
     def close(self):
         """Close the torrent and it's files"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.close")
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.close')
 
-        return(m.call()[-1])
+        return mc.call()[-1]
 
     def erase(self):
         """Delete the torrent
 
         @note: doesn't delete the downloaded files"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.erase")
+        mc = rpc.Multicall(self)
 
-        return(m.call()[-1])
+        self.multicall_add(mc, 'd.erase')
+
+        return mc.call()[-1]
 
     def check_hash(self):
         """(Re)hash check the torrent"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.check_hash")
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.check_hash')
 
-        return(m.call()[-1])
+        return mc.call()[-1]
 
     def poll(self):
         """poll rTorrent to get latest peer/tracker/file information"""
@@ -251,13 +270,12 @@ class Torrent:
 
         @return: None
         """
-        multicall = rtorrent.rpc.Multicall(self)
-        retriever_methods = [m for m in methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
-        for method in retriever_methods:
-            multicall.add(method, self.rpc_id)
+        mc = rpc.Multicall(self)
+
+        for method in filter(lambda m: m.is_retriever() and m.is_available(self._rt_obj), methods):
+            mc.add(method, self.rpc_id)
 
-        multicall.call()
+        mc.call()
 
         # custom functions (only call private methods, since they only check
         # local variables and are therefore faster)
@@ -268,27 +286,23 @@ class Torrent:
 
         @param accept_seeds: enable/disable accepting seeders
         @type accept_seeds: bool"""
-        if accept_seeds:
-            call = "d.accepting_seeders.enable"
-        else:
-            call = "d.accepting_seeders.disable"
+        mc = rpc.Multicall(self)
 
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, call)
+        self.multicall_add(mc, ('d.accepting_seeders.disable', 'd.accepting_seeders.enable')[accept_seeds])
 
-        return(m.call()[-1])
+        return mc.call()[-1]
 
     def announce(self):
         """Announce torrent info to tracker(s)"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.tracker_announce")
+        mc = rpc.Multicall(self)
 
-        return(m.call()[-1])
+        self.multicall_add(mc, 'd.tracker_announce')
+
+        return mc.call()[-1]
 
     @staticmethod
     def _assert_custom_key_valid(key):
-        assert type(key) == int and key > 0 and key < 6, \
-            "key must be an integer between 1-5"
+        assert type(key) == int and 0 < key < 6, 'key must be an integer between 1-5'
 
     def get_custom(self, key):
         """
@@ -301,13 +315,16 @@ class Torrent:
         """
 
         self._assert_custom_key_valid(key)
-        m = rtorrent.rpc.Multicall(self)
 
-        field = "custom{0}".format(key)
-        self.multicall_add(m, "d.get_{0}".format(field))
-        setattr(self, field, m.call()[-1])
+        field = 'custom%s' % key
+        method = self._get_method(*('d.get_%s' % field, 'd.%s' % field))
+        if method:
+            mc = rpc.Multicall(self)
+
+            self.multicall_add(mc, method)
 
-        return (getattr(self, field))
+            setattr(self, field, mc.call()[-1])
+            return getattr(self, field)
 
     def set_custom(self, key, value):
         """
@@ -324,19 +341,23 @@ class Torrent:
         """
 
         self._assert_custom_key_valid(key)
-        m = rtorrent.rpc.Multicall(self)
 
-        self.multicall_add(m, "d.set_custom{0}".format(key), value)
+        field = 'custom%s' % key
+        method = self._get_method(*('d.set_%s' % field, 'd.%s.set' % field))
+        if method:
+            mc = rpc.Multicall(self)
+
+            self.multicall_add(mc, method, value)
 
-        return(m.call()[-1])
+            return mc.call()[-1]
 
     def set_visible(self, view, visible=True):
-        p = self._rt_obj._get_conn()
+        p = self._rt_obj.get_connection()
 
         if visible:
             return p.view.set_visible(self.info_hash, view)
-        else:
-            return p.view.set_not_visible(self.info_hash, view)
+
+        return p.view.set_not_visible(self.info_hash, view)
 
     def add_tracker(self, group, tracker):
         """
@@ -351,10 +372,11 @@ class Torrent:
         @return: if successful, 0
         @rtype: int
         """
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.tracker.insert", group, tracker)
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.tracker.insert', group, tracker)
 
-        return (m.call()[-1])
+        return mc.call()[-1]
 
     ############################################################################
     # CUSTOM METHODS (Not part of the official rTorrent API)
@@ -366,45 +388,48 @@ class Torrent:
         self.hash_checking_queued = (self.hashing == 3 and
                                      self.hash_checking is False)
 
-        return(self.hash_checking_queued)
+        return self.hash_checking_queued
 
     def is_hash_checking_queued(self):
         """Check if torrent is waiting to be hash checked
 
         @note: Variable where the result for this method is stored Torrent.hash_checking_queued"""
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.get_hashing")
-        self.multicall_add(m, "d.is_hash_checking")
-        results = m.call()
 
-        setattr(self, "hashing", results[0])
-        setattr(self, "hash_checking", results[1])
+        method = self._get_method(*('d.get_hashing', 'd.hashing'))
+        if method:
+            mc = rpc.Multicall(self)
+
+            self.multicall_add(mc, method)
+            self.multicall_add(mc, 'd.is_hash_checking')
+            results = mc.call()
 
-        return(self._is_hash_checking_queued())
+            setattr(self, 'hashing', results[0])
+            setattr(self, 'hash_checking', results[1])
+            return self._is_hash_checking_queued()
 
     def _is_paused(self):
         """Only checks instance variables, shouldn't be called directly"""
         self.paused = (self.state == 0)
-        return(self.paused)
+        return self.paused
 
     def is_paused(self):
         """Check if torrent is paused
 
         @note: Variable where the result for this method is stored: Torrent.paused"""
         self.get_state()
-        return(self._is_paused())
+        return self._is_paused()
 
     def _is_started(self):
         """Only checks instance variables, shouldn't be called directly"""
         self.started = (self.state == 1)
-        return(self.started)
+        return self.started
 
     def is_started(self):
         """Check if torrent is started
 
         @note: Variable where the result for this method is stored: Torrent.started"""
         self.get_state()
-        return(self._is_started())
+        return self._is_started()
 
 
 methods = [
@@ -415,121 +440,197 @@ methods = [
     Method(Torrent, 'is_hash_checking', 'd.is_hash_checking',
            boolean=True,
            ),
-    Method(Torrent, 'get_peers_max', 'd.get_peers_max'),
-    Method(Torrent, 'get_tracker_focus', 'd.get_tracker_focus'),
-    Method(Torrent, 'get_skip_total', 'd.get_skip_total'),
-    Method(Torrent, 'get_state', 'd.get_state'),
-    Method(Torrent, 'get_peer_exchange', 'd.get_peer_exchange'),
-    Method(Torrent, 'get_down_rate', 'd.get_down_rate'),
-    Method(Torrent, 'get_connection_seed', 'd.get_connection_seed'),
-    Method(Torrent, 'get_uploads_max', 'd.get_uploads_max'),
-    Method(Torrent, 'get_priority_str', 'd.get_priority_str'),
+    Method(Torrent, 'get_peers_max', 'd.get_peers_max',
+           aliases=('d.peers_max',)),
+    Method(Torrent, 'get_tracker_focus', 'd.get_tracker_focus',
+           aliases=('d.tracker_focus',)),
+    Method(Torrent, 'get_skip_total', 'd.get_skip_total',
+           aliases=('d.skip.total',)),
+    Method(Torrent, 'get_state', 'd.get_state',
+           aliases=('d.state',)),
+    Method(Torrent, 'get_peer_exchange', 'd.get_peer_exchange',
+           aliases=('d.peer_exchange',)),
+    Method(Torrent, 'get_down_rate', 'd.get_down_rate',
+           aliases=('d.down.rate',)),
+    Method(Torrent, 'get_connection_seed', 'd.get_connection_seed',
+           aliases=('d.connection_seed',)),
+    Method(Torrent, 'get_uploads_max', 'd.get_uploads_max',
+           aliases=('d.uploads_max',)),
+    Method(Torrent, 'get_priority_str', 'd.get_priority_str',
+           aliases=('d.priority_str',)),
     Method(Torrent, 'is_open', 'd.is_open',
            boolean=True,
            ),
-    Method(Torrent, 'get_peers_min', 'd.get_peers_min'),
-    Method(Torrent, 'get_peers_complete', 'd.get_peers_complete'),
-    Method(Torrent, 'get_tracker_numwant', 'd.get_tracker_numwant'),
-    Method(Torrent, 'get_connection_current', 'd.get_connection_current'),
+    Method(Torrent, 'get_peers_min', 'd.get_peers_min',
+           aliases=('d.peers_min',)),
+    Method(Torrent, 'get_peers_complete', 'd.get_peers_complete',
+           aliases=('d.peers_complete',)),
+    Method(Torrent, 'get_tracker_numwant', 'd.get_tracker_numwant',
+           aliases=('d.tracker_numwant',)),
+    Method(Torrent, 'get_connection_current', 'd.get_connection_current',
+           aliases=('d.connection_current',)),
     Method(Torrent, 'is_complete', 'd.get_complete',
            boolean=True,
+           aliases=('d.complete',)
            ),
-    Method(Torrent, 'get_peers_connected', 'd.get_peers_connected'),
-    Method(Torrent, 'get_chunk_size', 'd.get_chunk_size'),
-    Method(Torrent, 'get_state_counter', 'd.get_state_counter'),
-    Method(Torrent, 'get_base_filename', 'd.get_base_filename'),
-    Method(Torrent, 'get_state_changed', 'd.get_state_changed'),
-    Method(Torrent, 'get_peers_not_connected', 'd.get_peers_not_connected'),
-    Method(Torrent, 'get_directory', 'd.get_directory'),
+    Method(Torrent, 'get_peers_connected', 'd.get_peers_connected',
+           aliases=('d.peers_connected',)),
+    Method(Torrent, 'get_chunk_size', 'd.get_chunk_size',
+           aliases=('d.chunk_size',)),
+    Method(Torrent, 'get_state_counter', 'd.get_state_counter',
+           aliases=('d.state_counter',)),
+    Method(Torrent, 'get_base_filename', 'd.get_base_filename',
+           aliases=('d.base_filename',)),
+    Method(Torrent, 'get_state_changed', 'd.get_state_changed',
+           aliases=('d.state_changed',)),
+    Method(Torrent, 'get_peers_not_connected', 'd.get_peers_not_connected',
+           aliases=('d.peers_not_connected',)),
+    Method(Torrent, 'get_directory', 'd.get_directory',
+           aliases=('d.directory',)),
     Method(Torrent, 'is_incomplete', 'd.incomplete',
            boolean=True,
            ),
-    Method(Torrent, 'get_tracker_size', 'd.get_tracker_size'),
+    Method(Torrent, 'get_tracker_size', 'd.get_tracker_size',
+           aliases=('d.tracker_size',)),
     Method(Torrent, 'is_multi_file', 'd.is_multi_file',
            boolean=True,
            ),
-    Method(Torrent, 'get_local_id', 'd.get_local_id'),
+    Method(Torrent, 'get_local_id', 'd.get_local_id',
+           aliases=('d.local_id',)),
     Method(Torrent, 'get_ratio', 'd.get_ratio',
            post_process_func=lambda x: x / 1000.0,
+           aliases=('d.ratio',)
            ),
-    Method(Torrent, 'get_loaded_file', 'd.get_loaded_file'),
-    Method(Torrent, 'get_max_file_size', 'd.get_max_file_size'),
-    Method(Torrent, 'get_size_chunks', 'd.get_size_chunks'),
+    Method(Torrent, 'get_loaded_file', 'd.get_loaded_file',
+           aliases=('d.loaded_file',)),
+    Method(Torrent, 'get_max_file_size', 'd.get_max_file_size',
+           aliases=('d.max_file_size',)),
+    Method(Torrent, 'get_size_chunks', 'd.get_size_chunks',
+           aliases=('d.size_chunks',)),
     Method(Torrent, 'is_pex_active', 'd.is_pex_active',
            boolean=True,
            ),
-    Method(Torrent, 'get_hashing', 'd.get_hashing'),
-    Method(Torrent, 'get_bitfield', 'd.get_bitfield'),
-    Method(Torrent, 'get_local_id_html', 'd.get_local_id_html'),
-    Method(Torrent, 'get_connection_leech', 'd.get_connection_leech'),
-    Method(Torrent, 'get_peers_accounted', 'd.get_peers_accounted'),
-    Method(Torrent, 'get_message', 'd.get_message'),
+    Method(Torrent, 'get_hashing', 'd.get_hashing',
+           aliases=('d.hashing',)),
+    Method(Torrent, 'get_bitfield', 'd.get_bitfield',
+           aliases=('d.bitfield',)),
+    Method(Torrent, 'get_local_id_html', 'd.get_local_id_html',
+           aliases=('d.bitfield',)),
+    Method(Torrent, 'get_connection_leech', 'd.get_connection_leech',
+           aliases=('d.connection_leech',)),
+    Method(Torrent, 'get_peers_accounted', 'd.get_peers_accounted',
+           aliases=('d.peers_accounted',)),
+    Method(Torrent, 'get_message', 'd.get_message',
+           aliases=('d.message',)),
     Method(Torrent, 'is_active', 'd.is_active',
            boolean=True,
            ),
-    Method(Torrent, 'get_size_bytes', 'd.get_size_bytes'),
-    Method(Torrent, 'get_ignore_commands', 'd.get_ignore_commands'),
-    Method(Torrent, 'get_creation_date', 'd.get_creation_date'),
-    Method(Torrent, 'get_base_path', 'd.get_base_path'),
-    Method(Torrent, 'get_left_bytes', 'd.get_left_bytes'),
-    Method(Torrent, 'get_size_files', 'd.get_size_files'),
-    Method(Torrent, 'get_size_pex', 'd.get_size_pex'),
+    Method(Torrent, 'get_size_bytes', 'd.get_size_bytes',
+           aliases=('d.size_bytes',)),
+    Method(Torrent, 'get_ignore_commands', 'd.get_ignore_commands',
+           aliases=('d.ignore_commands',)),
+    Method(Torrent, 'get_creation_date', 'd.get_creation_date',
+           aliases=('d.creation_date',)),
+    Method(Torrent, 'get_base_path', 'd.get_base_path',
+           aliases=('d.base_path',)),
+    Method(Torrent, 'get_left_bytes', 'd.get_left_bytes',
+           aliases=('d.left_bytes',)),
+    Method(Torrent, 'get_size_files', 'd.get_size_files',
+           aliases=('d.size_files',)),
+    Method(Torrent, 'get_size_pex', 'd.get_size_pex',
+           aliases=('d.size_pex',)),
     Method(Torrent, 'is_private', 'd.is_private',
            boolean=True,
            ),
     Method(Torrent, 'get_max_size_pex', 'd.get_max_size_pex'),
     Method(Torrent, 'get_num_chunks_hashed', 'd.get_chunks_hashed',
-           aliases=("get_chunks_hashed",)),
+           aliases=('get_chunks_hashed', 'd.chunks_hashed')),
     Method(Torrent, 'get_num_chunks_wanted', 'd.wanted_chunks'),
-    Method(Torrent, 'get_priority', 'd.get_priority'),
-    Method(Torrent, 'get_skip_rate', 'd.get_skip_rate'),
-    Method(Torrent, 'get_completed_bytes', 'd.get_completed_bytes'),
-    Method(Torrent, 'get_name', 'd.get_name'),
-    Method(Torrent, 'get_completed_chunks', 'd.get_completed_chunks'),
-    Method(Torrent, 'get_throttle_name', 'd.get_throttle_name'),
-    Method(Torrent, 'get_free_diskspace', 'd.get_free_diskspace'),
-    Method(Torrent, 'get_directory_base', 'd.get_directory_base'),
-    Method(Torrent, 'get_hashing_failed', 'd.get_hashing_failed'),
-    Method(Torrent, 'get_tied_to_file', 'd.get_tied_to_file'),
-    Method(Torrent, 'get_down_total', 'd.get_down_total'),
-    Method(Torrent, 'get_bytes_done', 'd.get_bytes_done'),
-    Method(Torrent, 'get_up_rate', 'd.get_up_rate'),
-    Method(Torrent, 'get_up_total', 'd.get_up_total'),
+    Method(Torrent, 'get_priority', 'd.get_priority',
+           aliases=('d.priority',)),
+    Method(Torrent, 'get_skip_rate', 'd.get_skip_rate',
+           aliases=('d.skip.rate',)),
+    Method(Torrent, 'get_completed_bytes', 'd.get_completed_bytes',
+           aliases=('d.completed_bytes',)),
+    Method(Torrent, 'get_name', 'd.get_name',
+           aliases=('d.name',)),
+    Method(Torrent, 'get_completed_chunks', 'd.get_completed_chunks',
+           aliases=('d.completed_chunks',)),
+    Method(Torrent, 'get_throttle_name', 'd.get_throttle_name',
+           aliases=('d.throttle_name',)),
+    Method(Torrent, 'get_free_diskspace', 'd.get_free_diskspace',
+           aliases=('d.free_diskspace',)),
+    Method(Torrent, 'get_directory_base', 'd.get_directory_base',
+           aliases=('d.directory_base',)),
+    Method(Torrent, 'get_hashing_failed', 'd.get_hashing_failed',
+           aliases=('d.hashing_failed',)),
+    Method(Torrent, 'get_tied_to_file', 'd.get_tied_to_file',
+           aliases=('d.tied_to_file',)),
+    Method(Torrent, 'get_down_total', 'd.get_down_total',
+           aliases=('d.down.total',)),
+    Method(Torrent, 'get_bytes_done', 'd.get_bytes_done',
+           aliases=('d.bytes_done',)),
+    Method(Torrent, 'get_up_rate', 'd.get_up_rate',
+           aliases=('d.up.rate',)),
+    Method(Torrent, 'get_up_total', 'd.get_up_total',
+           aliases=('d.up.total',)),
     Method(Torrent, 'is_accepting_seeders', 'd.accepting_seeders',
            boolean=True,
            ),
-    Method(Torrent, "get_chunks_seen", "d.chunks_seen",
+    Method(Torrent, 'get_chunks_seen', 'd.chunks_seen',
            min_version=(0, 9, 1),
            ),
-    Method(Torrent, "is_partially_done", "d.is_partially_done",
+    Method(Torrent, 'is_partially_done', 'd.is_partially_done',
            boolean=True,
            ),
-    Method(Torrent, "is_not_partially_done", "d.is_not_partially_done",
+    Method(Torrent, 'is_not_partially_done', 'd.is_not_partially_done',
            boolean=True,
            ),
-    Method(Torrent, "get_time_started", "d.timestamp.started"),
-    Method(Torrent, "get_custom1", "d.get_custom1"),
-    Method(Torrent, "get_custom2", "d.get_custom2"),
-    Method(Torrent, "get_custom3", "d.get_custom3"),
-    Method(Torrent, "get_custom4", "d.get_custom4"),
-    Method(Torrent, "get_custom5", "d.get_custom5"),
+    Method(Torrent, 'get_time_started', 'd.timestamp.started'),
+    Method(Torrent, 'get_custom1', 'd.get_custom1',
+           aliases=('d.custom1',)),
+    Method(Torrent, 'get_custom2', 'd.get_custom2',
+           aliases=('d.custom2',)),
+    Method(Torrent, 'get_custom3', 'd.get_custom3',
+           aliases=('d.custom3',)),
+    Method(Torrent, 'get_custom4', 'd.get_custom4',
+           aliases=('d.custom4',)),
+    Method(Torrent, 'get_custom5', 'd.get_custom5',
+           aliases=('d.custom5',)),
 
     # MODIFIERS
-    Method(Torrent, 'set_uploads_max', 'd.set_uploads_max'),
-    Method(Torrent, 'set_tied_to_file', 'd.set_tied_to_file'),
-    Method(Torrent, 'set_tracker_numwant', 'd.set_tracker_numwant'),
-    Method(Torrent, 'set_priority', 'd.set_priority'),
-    Method(Torrent, 'set_peers_max', 'd.set_peers_max'),
-    Method(Torrent, 'set_hashing_failed', 'd.set_hashing_failed'),
-    Method(Torrent, 'set_message', 'd.set_message'),
-    Method(Torrent, 'set_throttle_name', 'd.set_throttle_name'),
-    Method(Torrent, 'set_peers_min', 'd.set_peers_min'),
-    Method(Torrent, 'set_ignore_commands', 'd.set_ignore_commands'),
-    Method(Torrent, 'set_max_file_size', 'd.set_max_file_size'),
-    Method(Torrent, 'set_custom5', 'd.set_custom5'),
-    Method(Torrent, 'set_custom4', 'd.set_custom4'),
-    Method(Torrent, 'set_custom2', 'd.set_custom2'),
-    Method(Torrent, 'set_custom1', 'd.set_custom1'),
-    Method(Torrent, 'set_custom3', 'd.set_custom3'),
-    Method(Torrent, 'set_connection_current', 'd.set_connection_current'),
+    Method(Torrent, 'set_uploads_max', 'd.set_uploads_max',
+           aliases=('d.uploads_max.set',)),
+    Method(Torrent, 'set_tied_to_file', 'd.set_tied_to_file',
+           aliases=('d.tied_to_file.set',)),
+    Method(Torrent, 'set_tracker_numwant', 'd.set_tracker_numwant',
+           aliases=('d.tracker_numwant.set',)),
+    Method(Torrent, 'set_priority', 'd.set_priority',
+           aliases=('d.priority.set',)),
+    Method(Torrent, 'set_peers_max', 'd.set_peers_max',
+           aliases=('d.peers_max.set',)),
+    Method(Torrent, 'set_hashing_failed', 'd.set_hashing_failed',
+           aliases=('d.hashing_failed.set',)),
+    Method(Torrent, 'set_message', 'd.set_message',
+           aliases=('d.message.set',)),
+    Method(Torrent, 'set_throttle_name', 'd.set_throttle_name',
+           aliases=('d.throttle_name.set',)),
+    Method(Torrent, 'set_peers_min', 'd.set_peers_min',
+           aliases=('d.peers_min.set',)),
+    Method(Torrent, 'set_ignore_commands', 'd.set_ignore_commands',
+           aliases=('d.ignore_commands.set',)),
+    Method(Torrent, 'set_max_file_size', 'd.set_max_file_size',
+           aliases=('d.max_file_size.set',)),
+    Method(Torrent, 'set_custom5', 'd.set_custom5',
+           aliases=('d.custom5.set',)),
+    Method(Torrent, 'set_custom4', 'd.set_custom4',
+           aliases=('d.custom4.set',)),
+    Method(Torrent, 'set_custom2', 'd.set_custom2',
+           aliases=('d.custom2.set',)),
+    Method(Torrent, 'set_custom1', 'd.set_custom1',
+           aliases=('d.custom1.set',)),
+    Method(Torrent, 'set_custom3', 'd.set_custom3',
+           aliases=('d.custom3.set',)),
+    Method(Torrent, 'set_connection_current', 'd.set_connection_current',
+           aliases=('d.connection_current.set',)),
 ]
diff --git a/lib/rtorrent/tracker.py b/lib/rtorrent/tracker.py
index b3b7bf9..ee5df0b 100644
--- a/lib/rtorrent/tracker.py
+++ b/lib/rtorrent/tracker.py
@@ -18,39 +18,36 @@
 # 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 rtorrent.rpc import Method
-import rtorrent.rpc
+from .common import safe_repr
+from .rpc import Method
+import rpc
 
-from rtorrent.common import safe_repr
 
-Method = rtorrent.rpc.Method
-
-
-class Tracker:
+class Tracker(object):
     """Represents an individual tracker within a L{Torrent} instance."""
 
     def __init__(self, _rt_obj, info_hash, **kwargs):
         self._rt_obj = _rt_obj
         self.info_hash = info_hash  # : info hash for the torrent using this tracker
-        for k in kwargs.keys():
+        for k in kwargs:
             setattr(self, k, kwargs.get(k, None))
 
         # for clarity's sake...
         self.index = self.group  # : position of tracker within the torrent's tracker list
-        self.rpc_id = "{0}:t{1}".format(
+        self.rpc_id = '{0}:t{1}'.format(
             self.info_hash, self.index)  # : unique id to pass to rTorrent
 
     def __repr__(self):
-        return safe_repr("Tracker(index={0}, url=\"{1}\")",
-                        self.index, self.url)
+        return safe_repr('Tracker(index={0}, url="{1}")',
+                         self.index, self.url)
 
     def enable(self):
         """Alias for set_enabled("yes")"""
-        self.set_enabled("yes")
+        self.set_enabled('yes')
 
     def disable(self):
         """Alias for set_enabled("no")"""
-        self.set_enabled("no")
+        self.set_enabled('no')
 
     def update(self):
         """Refresh tracker data
@@ -59,13 +56,12 @@ class Tracker:
 
         @return: None
         """
-        multicall = rtorrent.rpc.Multicall(self)
-        retriever_methods = [m for m in methods
-                             if m.is_retriever() and m.is_available(self._rt_obj)]
-        for method in retriever_methods:
-            multicall.add(method, self.rpc_id)
+        mc = rpc.Multicall(self)
+
+        for method in filter(lambda fx: fx.is_retriever() and fx.is_available(self._rt_obj), methods):
+            mc.add(method, self.rpc_id)
 
-        multicall.call()
+        mc.call()
 
     def append_tracker(self, tracker):
         """
@@ -77,26 +73,38 @@ class Tracker:
         @return: if successful, 0
         @rtype: int
         """
-        m = rtorrent.rpc.Multicall(self)
-        self.multicall_add(m, "d.tracker.insert", self.index, tracker)
+        mc = rpc.Multicall(self)
+
+        self.multicall_add(mc, 'd.tracker.insert', self.index, tracker)
+
+        return mc.call()[-1]
 
-        return (m.call()[-1])
 
 methods = [
     # RETRIEVERS
     Method(Tracker, 'is_enabled', 't.is_enabled', boolean=True),
-    Method(Tracker, 'get_id', 't.get_id'),
-    Method(Tracker, 'get_scrape_incomplete', 't.get_scrape_incomplete'),
+    Method(Tracker, 'get_id', 't.get_id',
+           aliases=('t.id',)),
+    Method(Tracker, 'get_scrape_incomplete', 't.get_scrape_incomplete',
+           aliases=('t.scrape_incomplete',)),
     Method(Tracker, 'is_open', 't.is_open', boolean=True),
-    Method(Tracker, 'get_min_interval', 't.get_min_interval'),
-    Method(Tracker, 'get_scrape_downloaded', 't.get_scrape_downloaded'),
-    Method(Tracker, 'get_group', 't.get_group'),
-    Method(Tracker, 'get_scrape_time_last', 't.get_scrape_time_last'),
-    Method(Tracker, 'get_type', 't.get_type'),
-    Method(Tracker, 'get_normal_interval', 't.get_normal_interval'),
-    Method(Tracker, 'get_url', 't.get_url'),
+    Method(Tracker, 'get_min_interval', 't.get_min_interval',
+           aliases=('t.min_interval',)),
+    Method(Tracker, 'get_scrape_downloaded', 't.get_scrape_downloaded',
+           aliases=('t.scrape_downloaded',)),
+    Method(Tracker, 'get_group', 't.get_group',
+           aliases=('t.group',)),
+    Method(Tracker, 'get_scrape_time_last', 't.get_scrape_time_last',
+           aliases=('t.scrape_time_last',)),
+    Method(Tracker, 'get_type', 't.get_type',
+           aliases=('t.type',)),
+    Method(Tracker, 'get_normal_interval', 't.get_normal_interval',
+           aliases=('t.normal_interval',)),
+    Method(Tracker, 'get_url', 't.get_url',
+           aliases=('t.url',)),
     Method(Tracker, 'get_scrape_complete', 't.get_scrape_complete',
            min_version=(0, 8, 9),
+           aliases=('t.scrape_complete',)
            ),
     Method(Tracker, 'get_activity_time_last', 't.activity_time_last',
            min_version=(0, 8, 9),
@@ -141,13 +149,14 @@ methods = [
            min_version=(0, 9, 1),
            boolean=True,
            ),
-    Method(Tracker, "get_latest_sum_peers", "t.latest_sum_peers",
+    Method(Tracker, 'get_latest_sum_peers', 't.latest_sum_peers',
            min_version=(0, 9, 0)
            ),
-    Method(Tracker, "get_latest_new_peers", "t.latest_new_peers",
+    Method(Tracker, 'get_latest_new_peers', 't.latest_new_peers',
            min_version=(0, 9, 0)
            ),
 
     # MODIFIERS
-    Method(Tracker, 'set_enabled', 't.set_enabled'),
+    Method(Tracker, 'set_enabled', 't.set_enabled',
+           aliases=('t.is_enabled.set',)),
 ]
diff --git a/sickbeard/clients/generic.py b/sickbeard/clients/generic.py
index 14ada6b..48af932 100644
--- a/sickbeard/clients/generic.py
+++ b/sickbeard/clients/generic.py
@@ -152,7 +152,7 @@ class GenericClient(object):
     def _get_torrent_hash(result):
 
         if result.url.startswith('magnet'):
-            result.hash = re.findall('urn:btih:([\w]{32,40})', result.url)[0]
+            result.hash = re.findall(r'urn:btih:([\w]{32,40})', result.url)[0]
             if 32 == len(result.hash):
                 result.hash = b16encode(b32decode(result.hash)).lower()
         else:
diff --git a/sickbeard/clients/rtorrent.py b/sickbeard/clients/rtorrent.py
index fd86844..ac372fc 100644
--- a/sickbeard/clients/rtorrent.py
+++ b/sickbeard/clients/rtorrent.py
@@ -1,5 +1,3 @@
-# Author: jkaberg <joel.kaberg@gmail.com>, based on fuzemans work (https://github.com/RuudBurger/CouchPotatoServer/blob/develop/couchpotato/core/downloaders/rtorrent/main.py)
-# URL: http://code.google.com/p/sickbeard/
 #
 # This file is part of SickGear.
 #
@@ -16,11 +14,11 @@
 # You should have received a copy of the GNU General Public License
 # along with SickGear.  If not, see <http://www.gnu.org/licenses/>.
 
-import xmlrpclib
-import sickbeard
-from sickbeard import helpers
-from sickbeard.clients.generic import GenericClient
+from lib.rtorrent.compat import xmlrpclib
 from lib.rtorrent import RTorrent
+from sickbeard import helpers, logger
+from sickbeard.clients.generic import GenericClient
+import sickbeard
 
 
 class RtorrentAPI(GenericClient):
@@ -31,60 +29,59 @@ class RtorrentAPI(GenericClient):
 
         super(RtorrentAPI, self).__init__('rTorrent', host, username, password)
 
-        # self.url = self.host
-
     def _get_auth(self):
 
         self.auth = None
         if self.host:
             try:
-                if self.host and self.host.startswith('scgi:'):
+                if self.host.startswith('scgi:'):
                     self.username = self.password = None
-                self.auth = RTorrent(self.host, self.username, self.password, True)
-            except (AssertionError, xmlrpclib.ProtocolError) as e:
+                self.auth = RTorrent(self.host, self.username, self.password)
+            except (AssertionError, xmlrpclib.ProtocolError):
                 pass
 
         return self.auth
 
-    def _add_torrent(self, cmd, **kwargs):
+    def _add_torrent(self, cmd, data):
         torrent = None
 
         if self.auth:
             try:
+                if self.auth.has_local_id(data.hash):
+                    logger.log('%s: Item already exists %s' % (self.name, data.name), logger.WARNING)
+                    raise
+
+                params = {
+                    'start': not sickbeard.TORRENT_PAUSED,
+                    'extra': ([], ['d.set_custom1=%s' % sickbeard.TORRENT_LABEL])[any([sickbeard.TORRENT_LABEL])] +
+                             ([], ['d.set_directory=%s' % sickbeard.TORRENT_PATH])[any([sickbeard.TORRENT_PATH])]
+                    or None}
                 # Send magnet to rTorrent
                 if 'file' == cmd:
-                    torrent = self.auth.load_torrent(kwargs['file'])
+                    torrent = self.auth.load_torrent(data.content, **params)
                 elif 'magnet' == cmd:
-                    torrent = self.auth.load_magnet(kwargs['uri'], kwargs['btih'])
+                    torrent = self.auth.load_magnet(data.url, data.hash, **params)
 
-                if torrent:
+                if torrent and sickbeard.TORRENT_LABEL:
+                    label = torrent.get_custom(1)
+                    if sickbeard.TORRENT_LABEL != label:
+                        logger.log('%s: could not change custom1 category \'%s\' to \'%s\' for %s' % (
+                            self.name, label, sickbeard.TORRENT_LABEL, torrent.name), logger.WARNING)
 
-                    if sickbeard.TORRENT_LABEL:
-                        torrent.set_custom(1, sickbeard.TORRENT_LABEL)
-
-                    if sickbeard.TORRENT_PATH:
-                        torrent.set_directory(sickbeard.TORRENT_PATH)
-
-                    torrent.start()
-
-            except (StandardError, Exception) as e:
+            except(Exception, BaseException):
                 pass
 
         return any([torrent])
 
     def _add_torrent_file(self, result):
 
-        if result:
-            return self._add_torrent('file', file=result.content)
-        return False
+        return result and self._add_torrent('file', result) or False
 
     def _add_torrent_uri(self, result):
 
-        if result:
-            return self._add_torrent('magnet', uri=result.url, btih=result.hash)
-        return False
+        return result and self._add_torrent('magnet', result) or False
 
-    #def _set_torrent_ratio(self, name):
+    # def _set_torrent_ratio(self, name):
 
         # if not name:
         # return False
@@ -122,9 +119,7 @@ class RtorrentAPI(GenericClient):
 
     def test_authentication(self):
         try:
-            self._get_auth()
-
-            if None is self.auth:
+            if not self._get_auth():
                 return False, 'Error: Unable to get %s authentication, check your config!' % self.name
             return True, 'Success: Connected and Authenticated'