From fa7d18784ca18c5c70bbb36cde9d5915843456c3 Mon Sep 17 00:00:00 2001
From: jvoisin
Date: Wed, 16 May 2018 22:36:59 +0200
Subject: Do a pylint pass

---
 src/torrent.py | 42 ++++++++++++++++++++++--------------------
 1 file changed, 22 insertions(+), 20 deletions(-)

(limited to 'src/torrent.py')

diff --git a/src/torrent.py b/src/torrent.py
index bdf83ce..cb4b5e3 100644
--- a/src/torrent.py
+++ b/src/torrent.py
@@ -11,7 +11,7 @@ class TorrentParser(abstract.AbstractParser):
             d = _BencodeHandler().bdecode(f.read())
         if d is None:
             return {'Unknown meta': 'Unable to parse torrent file "%s".' % self.filename}
-        for k,v in d.items():
+        for k, v in d.items():
             if k not in self.whitelist:
                 metadata[k.decode('utf-8')] = v
         return metadata
@@ -23,7 +23,7 @@ class TorrentParser(abstract.AbstractParser):
             d = _BencodeHandler().bdecode(f.read())
         if d is None:
             return False
-        for k,v in d.items():
+        for k, v in d.items():
             if k in self.whitelist:
                 cleaned[k] = v
         with open(self.output_filename, 'wb') as f:
@@ -39,21 +39,22 @@ class _BencodeHandler(object):
     """
     def __init__(self):
         self.__decode_func = {
-                    ord('d'): self.__decode_dict,
-                    ord('i'): self.__decode_int,
-                    ord('l'): self.__decode_list,
-            }
+            ord('d'): self.__decode_dict,
+            ord('i'): self.__decode_int,
+            ord('l'): self.__decode_list,
+        }
         for i in range(0, 10):
             self.__decode_func[ord(str(i))] = self.__decode_string
 
         self.__encode_func = {
-                bytes: self.__encode_string,
-                dict: self.__encode_dict,
-                int: self.__encode_int,
-                list: self.__encode_list,
+            bytes: self.__encode_string,
+            dict: self.__encode_dict,
+            int: self.__encode_int,
+            list: self.__encode_list,
         }
 
-    def __decode_int(self, s:str) -> (int, str):
+    @staticmethod
+    def __decode_int(s: str) -> (int, str):
         s = s[1:]
         next_idx = s.index(b'e')
         if s.startswith(b'-0'):
@@ -62,7 +63,8 @@ class _BencodeHandler(object):
             raise ValueError  # no leading zero except for zero itself
         return int(s[:next_idx]), s[next_idx+1:]
 
-    def __decode_string(self, s:str) -> (str, str):
+    @staticmethod
+    def __decode_string(s: str) -> (str, str):
         sep = s.index(b':')
         str_len = int(s[:sep])
         if str_len < 0:
@@ -72,7 +74,7 @@ class _BencodeHandler(object):
         s = s[1:]
         return s[sep:sep+str_len], s[sep+str_len:]
 
-    def __decode_list(self, s:str) -> (list, str):
+    def __decode_list(self, s: str) -> (list, str):
         r = list()
         s = s[1:]  # skip leading `l`
         while s[0] != ord('e'):
@@ -80,7 +82,7 @@ class _BencodeHandler(object):
             r.append(v)
         return r, s[1:]
 
-    def __decode_dict(self, s:str) -> (dict, str):
+    def __decode_dict(self, s: str) -> (dict, str):
         r = dict()
         s = s[1:]  # skip leading `d`
         while s[0] != ord(b'e'):
@@ -89,30 +91,30 @@ class _BencodeHandler(object):
         return r, s[1:]
 
     @staticmethod
-    def __encode_int(x:str) -> bytes:
+    def __encode_int(x: str) -> bytes:
         return b'i' + bytes(str(x), 'utf-8') + b'e'
 
     @staticmethod
-    def __encode_string(x:str) -> bytes:
+    def __encode_string(x: str) -> bytes:
         return bytes((str(len(x))), 'utf-8') + b':' + x
 
-    def __encode_list(self, x:str) -> bytes:
+    def __encode_list(self, x: str) -> bytes:
         ret = b''
         for i in x:
             ret += self.__encode_func[type(i)](i)
         return b'l' + ret + b'e'
 
-    def __encode_dict(self, x:str) -> bytes:
+    def __encode_dict(self, x: str) -> bytes:
         ret = b''
         for k, v in sorted(x.items()):
             ret += self.__encode_func[type(k)](k)
             ret += self.__encode_func[type(v)](v)
         return b'd' + ret + b'e'
 
-    def bencode(self, s:str) -> bytes:
+    def bencode(self, s: str) -> bytes:
         return self.__encode_func[type(s)](s)
 
-    def bdecode(self, s:str):
+    def bdecode(self, s: str):
         try:
             r, l = self.__decode_func[s[0]](s)
         except (IndexError, KeyError, ValueError) as e:
-- 
cgit v1.3