PEP8: Fix formatting

* Remove redundant backslash between brackets
* Fix multiple statements on one line
* Fix missing/excess whitespace
* Fix comments not starting with a single # and a space
* Convert tabs to spaces
* Use triple-quoted docstring

core/__init__.py

@@ -62,7 +62,8 @@ FORKS[FORK_FAILED_TORRENT] = {"dir": None, "failed": None, "process_method": Non
 FORKS[FORK_SICKRAGETV] = {"proc_dir": None, "failed": None, "process_method": None, "force": None, "delete_on": None}
 FORKS[FORK_SICKRAGE] = {"proc_dir": None, "failed": None, "process_method": None, "force": None, "delete_on": None}
 FORKS[FORK_SICKGEAR] = {"dir": None, "failed": None, "process_method": None, "force": None}
-ALL_FORKS = {"dir": None, "dirName": None, "proc_dir": None, "failed": None, "process_method": None, "force": None, "delete_on": None}
+ALL_FORKS = {"dir": None, "dirName": None, "proc_dir": None, "failed": None, "process_method": None, "force": None,
+             "delete_on": None}
 
 # NZBGet Exit Codes
 NZBGET_POSTPROCESS_PARCHECK = 92
@@ -202,6 +203,7 @@ USER_SCRIPT_RUNONCE = None
 
 __INITIALIZED__ = False
 
+
 def initialize(section=None):
     global NZBGET_POSTPROCESS_ERROR, NZBGET_POSTPROCESS_NONE, NZBGET_POSTPROCESS_PARCHECK, NZBGET_POSTPROCESS_SUCCESS, \
         NZBTOMEDIA_TIMEOUT, FORKS, FORK_DEFAULT, FORK_FAILED_TORRENT, FORK_FAILED, \
@@ -316,7 +318,8 @@ def initialize(section=None):
                 # restart nzbToMedia
                 try:
                     del MYAPP
-                except: pass
+                except:
+                    pass
                 restart()
             else:
                 logger.error("Update wasn't successful, not restarting. Check your log for more information.")
@@ -334,8 +337,10 @@ def initialize(section=None):
     SABNZBDAPIKEY = CFG["Nzb"]["sabnzbd_apikey"]
     NZB_DEFAULTDIR = CFG["Nzb"]["default_downloadDirectory"]
     GROUPS = CFG["Custom"]["remove_group"]
-    if isinstance(GROUPS, str): GROUPS = GROUPS.split(',')
+    if isinstance(GROUPS, str):
-    if GROUPS == ['']: GROUPS = None
+        GROUPS = GROUPS.split(',')
+    if GROUPS == ['']:
+        GROUPS = None
 
     TORRENT_CLIENTAGENT = CFG["Torrent"]["clientAgent"]  # utorrent | deluge | transmission | rtorrent | vuze |other
     USELINK = CFG["Torrent"]["useLink"]  # no | hard | sym
@@ -343,8 +348,10 @@ def initialize(section=None):
     TORRENT_DEFAULTDIR = CFG["Torrent"]["default_downloadDirectory"]
     CATEGORIES = (CFG["Torrent"]["categories"])  # music,music_videos,pictures,software
     NOFLATTEN = (CFG["Torrent"]["noFlatten"])
-    if isinstance(NOFLATTEN, str): NOFLATTEN = NOFLATTEN.split(',')
+    if isinstance(NOFLATTEN, str):
-    if isinstance(CATEGORIES, str): CATEGORIES = CATEGORIES.split(',')
+        NOFLATTEN = NOFLATTEN.split(',')
+    if isinstance(CATEGORIES, str):
+        CATEGORIES = CATEGORIES.split(',')
     DELETE_ORIGINAL = int(CFG["Torrent"]["deleteOriginal"])
     TORRENT_CHMOD_DIRECTORY = int(str(CFG["Torrent"]["chmodDirectory"]), 8)
     TORRENT_RESUME_ON_FAILURE = int(CFG["Torrent"]["resumeOnFailure"])
@@ -365,9 +372,12 @@ def initialize(section=None):
 
     REMOTEPATHS = CFG["Network"]["mount_points"] or []
     if REMOTEPATHS:
-        if isinstance(REMOTEPATHS, list): REMOTEPATHS = ','.join(REMOTEPATHS)  # fix in case this imported as list.
+        if isinstance(REMOTEPATHS, list):
-        REMOTEPATHS = [ tuple(item.split(',')) for item in REMOTEPATHS.split('|') ]  # /volume1/Public/,E:\|/volume2/share/,\\NAS\
+            REMOTEPATHS = ','.join(REMOTEPATHS)  # fix in case this imported as list.
-        REMOTEPATHS = [ (local.strip(), remote.strip()) for local, remote in REMOTEPATHS ] # strip trailing and leading whitespaces
+        REMOTEPATHS = [tuple(item.split(',')) for item in
+                       REMOTEPATHS.split('|')]  # /volume1/Public/,E:\|/volume2/share/,\\NAS\
+        REMOTEPATHS = [(local.strip(), remote.strip()) for local, remote in
+                       REMOTEPATHS]  # strip trailing and leading whitespaces
 
     PLEXSSL = int(CFG["Plex"]["plex_ssl"])
     PLEXHOST = CFG["Plex"]["plex_host"]
@@ -375,26 +385,31 @@ def initialize(section=None):
     PLEXTOKEN = CFG["Plex"]["plex_token"]
     PLEXSEC = CFG["Plex"]["plex_sections"] or []
     if PLEXSEC:
-        if isinstance(PLEXSEC, list): PLEXSEC = ','.join(PLEXSEC)  # fix in case this imported as list.
+        if isinstance(PLEXSEC, list):
+            PLEXSEC = ','.join(PLEXSEC)  # fix in case this imported as list.
         PLEXSEC = [tuple(item.split(',')) for item in PLEXSEC.split('|')]
 
     devnull = open(os.devnull, 'w')
     try:
         subprocess.Popen(["nice"], stdout=devnull, stderr=devnull).communicate()
         NICENESS.extend(['nice', '-n%s' % (int(CFG["Posix"]["niceness"]))])
-    except: pass
+    except:
+        pass
     try:
         subprocess.Popen(["ionice"], stdout=devnull, stderr=devnull).communicate()
         try:
             NICENESS.extend(['ionice', '-c%s' % (int(CFG["Posix"]["ionice_class"]))])
-        except: pass
+        except:
+            pass
         try:
             if 'ionice' in NICENESS:
                 NICENESS.extend(['-n%s' % (int(CFG["Posix"]["ionice_classdata"]))])
             else:
                 NICENESS.extend(['ionice', '-n%s' % (int(CFG["Posix"]["ionice_classdata"]))])
-        except: pass
+        except:
-    except: pass
+            pass
+    except:
+        pass
     devnull.close()
 
     COMPRESSEDCONTAINER = [re.compile('.r\d{2}$', re.I),
@@ -404,33 +419,45 @@ def initialize(section=None):
     MEDIACONTAINER = CFG["Extensions"]["mediaExtensions"]
     AUDIOCONTAINER = CFG["Extensions"]["audioExtensions"]
     METACONTAINER = CFG["Extensions"]["metaExtensions"]  # .nfo,.sub,.srt
-    if isinstance(COMPRESSEDCONTAINER, str): COMPRESSEDCONTAINER = COMPRESSEDCONTAINER.split(',')
+    if isinstance(COMPRESSEDCONTAINER, str):
-    if isinstance(MEDIACONTAINER, str): MEDIACONTAINER = MEDIACONTAINER.split(',')
+        COMPRESSEDCONTAINER = COMPRESSEDCONTAINER.split(',')
-    if isinstance(AUDIOCONTAINER, str): AUDIOCONTAINER = AUDIOCONTAINER.split(',')
+    if isinstance(MEDIACONTAINER, str):
-    if isinstance(METACONTAINER, str): METACONTAINER = METACONTAINER.split(',')
+        MEDIACONTAINER = MEDIACONTAINER.split(',')
+    if isinstance(AUDIOCONTAINER, str):
+        AUDIOCONTAINER = AUDIOCONTAINER.split(',')
+    if isinstance(METACONTAINER, str):
+        METACONTAINER = METACONTAINER.split(',')
 
     GETSUBS = int(CFG["Transcoder"]["getSubs"])
     TRANSCODE = int(CFG["Transcoder"]["transcode"])
     DUPLICATE = int(CFG["Transcoder"]["duplicate"])
     CONCAT = int(CFG["Transcoder"]["concat"])
     IGNOREEXTENSIONS = (CFG["Transcoder"]["ignoreExtensions"])
-    if isinstance(IGNOREEXTENSIONS, str): IGNOREEXTENSIONS = IGNOREEXTENSIONS.split(',')
+    if isinstance(IGNOREEXTENSIONS, str):
+        IGNOREEXTENSIONS = IGNOREEXTENSIONS.split(',')
     OUTPUTFASTSTART = int(CFG["Transcoder"]["outputFastStart"])
     GENERALOPTS = (CFG["Transcoder"]["generalOptions"])
-    if isinstance(GENERALOPTS, str): GENERALOPTS = GENERALOPTS.split(',')
+    if isinstance(GENERALOPTS, str):
-    if GENERALOPTS == ['']: GENERALOPTS = []
+        GENERALOPTS = GENERALOPTS.split(',')
-    if not '-fflags' in GENERALOPTS: GENERALOPTS.append('-fflags')
+    if GENERALOPTS == ['']:
-    if not '+genpts' in GENERALOPTS: GENERALOPTS.append('+genpts')
+        GENERALOPTS = []
+    if not '-fflags' in GENERALOPTS:
+        GENERALOPTS.append('-fflags')
+    if not '+genpts' in GENERALOPTS:
+        GENERALOPTS.append('+genpts')
     try:
         OUTPUTQUALITYPERCENT = int(CFG["Transcoder"]["outputQualityPercent"])
-    except: pass
+    except:
+        pass
     OUTPUTVIDEOPATH = CFG["Transcoder"]["outputVideoPath"]
     PROCESSOUTPUT = int(CFG["Transcoder"]["processOutput"])
     ALANGUAGE = CFG["Transcoder"]["audioLanguage"]
     AINCLUDE = int(CFG["Transcoder"]["allAudioLanguages"])
     SLANGUAGES = CFG["Transcoder"]["subLanguages"]
-    if isinstance(SLANGUAGES, str): SLANGUAGES = SLANGUAGES.split(',')
+    if isinstance(SLANGUAGES, str):
-    if SLANGUAGES == ['']: SLANGUAGES = []
+        SLANGUAGES = SLANGUAGES.split(',')
+    if SLANGUAGES == ['']:
+        SLANGUAGES = []
     SINCLUDE = int(CFG["Transcoder"]["allSubLanguages"])
     SEXTRACT = int(CFG["Transcoder"]["extractSubs"])
     SEMBED = int(CFG["Transcoder"]["embedSubs"])
@@ -438,52 +465,70 @@ def initialize(section=None):
     VEXTENSION = CFG["Transcoder"]["outputVideoExtension"].strip()
     VCODEC = CFG["Transcoder"]["outputVideoCodec"].strip()
     VCODEC_ALLOW = CFG["Transcoder"]["VideoCodecAllow"].strip()
-    if isinstance(VCODEC_ALLOW, str): VCODEC_ALLOW = VCODEC_ALLOW.split(',')
+    if isinstance(VCODEC_ALLOW, str):
-    if VCODEC_ALLOW == ['']: VCODEC_ALLOW = []
+        VCODEC_ALLOW = VCODEC_ALLOW.split(',')
+    if VCODEC_ALLOW == ['']:
+        VCODEC_ALLOW = []
     VPRESET = CFG["Transcoder"]["outputVideoPreset"].strip()
     try:
         VFRAMERATE = float(CFG["Transcoder"]["outputVideoFramerate"].strip())
-    except: pass
+    except:
+        pass
     try:
         VCRF = int(CFG["Transcoder"]["outputVideoCRF"].strip())
-    except: pass
+    except:
+        pass
     try:
         VLEVEL = CFG["Transcoder"]["outputVideoLevel"].strip()
-    except: pass
+    except:
+        pass
     try:
         VBITRATE = int((CFG["Transcoder"]["outputVideoBitrate"].strip()).replace('k', '000'))
-    except: pass
+    except:
+        pass
     VRESOLUTION = CFG["Transcoder"]["outputVideoResolution"]
     ACODEC = CFG["Transcoder"]["outputAudioCodec"].strip()
     ACODEC_ALLOW = CFG["Transcoder"]["AudioCodecAllow"].strip()
-    if isinstance(ACODEC_ALLOW, str): ACODEC_ALLOW = ACODEC_ALLOW.split(',')
+    if isinstance(ACODEC_ALLOW, str):
-    if ACODEC_ALLOW == ['']: ACODEC_ALLOW = []
+        ACODEC_ALLOW = ACODEC_ALLOW.split(',')
+    if ACODEC_ALLOW == ['']:
+        ACODEC_ALLOW = []
     try:
         ACHANNELS = int(CFG["Transcoder"]["outputAudioChannels"].strip())
-    except: pass
+    except:
+        pass
     try:
         ABITRATE = int((CFG["Transcoder"]["outputAudioBitrate"].strip()).replace('k', '000'))
-    except: pass
+    except:
+        pass
     ACODEC2 = CFG["Transcoder"]["outputAudioTrack2Codec"].strip()
     ACODEC2_ALLOW = CFG["Transcoder"]["AudioCodec2Allow"].strip()
-    if isinstance(ACODEC2_ALLOW, str): ACODEC2_ALLOW = ACODEC2_ALLOW.split(',')
+    if isinstance(ACODEC2_ALLOW, str):
-    if ACODEC2_ALLOW == ['']: ACODEC2_ALLOW = []
+        ACODEC2_ALLOW = ACODEC2_ALLOW.split(',')
+    if ACODEC2_ALLOW == ['']:
+        ACODEC2_ALLOW = []
     try:
         ACHANNELS2 = int(CFG["Transcoder"]["outputAudioTrack2Channels"].strip())
-    except: pass
+    except:
+        pass
     try:
         ABITRATE2 = int((CFG["Transcoder"]["outputAudioTrack2Bitrate"].strip()).replace('k', '000'))
-    except: pass
+    except:
+        pass
     ACODEC3 = CFG["Transcoder"]["outputAudioOtherCodec"].strip()
     ACODEC3_ALLOW = CFG["Transcoder"]["AudioOtherCodecAllow"].strip()
-    if isinstance(ACODEC3_ALLOW, str): ACODEC3_ALLOW = ACODEC3_ALLOW.split(',')
+    if isinstance(ACODEC3_ALLOW, str):
-    if ACODEC3_ALLOW == ['']: ACODEC3_ALLOW = []
+        ACODEC3_ALLOW = ACODEC3_ALLOW.split(',')
+    if ACODEC3_ALLOW == ['']:
+        ACODEC3_ALLOW = []
     try:
         ACHANNELS3 = int(CFG["Transcoder"]["outputAudioOtherChannels"].strip())
-    except: pass
+    except:
+        pass
     try:
         ABITRATE3 = int((CFG["Transcoder"]["outputAudioOtherBitrate"].strip()).replace('k', '000'))
-    except: pass
+    except:
+        pass
     SCODEC = CFG["Transcoder"]["outputSubtitleCodec"].strip()
     BURN = int(CFG["Transcoder"]["burnInSubtitle"].strip())
     DEFAULTS = CFG["Transcoder"]["outputDefault"].strip()
@@ -497,107 +542,135 @@ def initialize(section=None):
     }
     transcode_defaults = {
         'iPad': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': None, 'ACHANNELS': 2,
             'ACODEC2': 'ac3', 'ACODEC2_ALLOW': ['ac3'], 'ABITRATE2': None, 'ACHANNELS2': 6,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'iPad-1080p': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':'1920:1080','VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': '1920:1080',
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': None, 'ACHANNELS': 2,
             'ACODEC2': 'ac3', 'ACODEC2_ALLOW': ['ac3'], 'ABITRATE2': None, 'ACHANNELS2': 6,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'iPad-720p': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':'1280:720','VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': '1280:720',
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': None, 'ACHANNELS': 2,
             'ACODEC2': 'ac3', 'ACODEC2_ALLOW': ['ac3'], 'ABITRATE2': None, 'ACHANNELS2': 6,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'Apple-TV': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':'1280:720','VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': '1280:720',
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'ac3', 'ACODEC_ALLOW': ['ac3'], 'ABITRATE': None, 'ACHANNELS': 6,
             'ACODEC2': 'aac', 'ACODEC2_ALLOW': ['libfaac'], 'ABITRATE2': None, 'ACHANNELS2': 2,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'iPod': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':'1280:720','VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': '1280:720',
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': 128000, 'ACHANNELS': 2,
             'ACODEC2': None, 'ACODEC2_ALLOW': [], 'ABITRATE2': None, 'ACHANNELS2': None,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'iPhone': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':'460:320','VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': '460:320',
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': 128000, 'ACHANNELS': 2,
             'ACODEC2': None, 'ACODEC2_ALLOW': [], 'ABITRATE2': None, 'ACHANNELS2': None,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'PS3': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'ac3', 'ACODEC_ALLOW': ['ac3'], 'ABITRATE': None, 'ACHANNELS': 6,
             'ACODEC2': 'aac', 'ACODEC2_ALLOW': ['libfaac'], 'ABITRATE2': None, 'ACHANNELS2': 2,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'xbox': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'ac3', 'ACODEC_ALLOW': ['ac3'], 'ABITRATE': None, 'ACHANNELS': 6,
             'ACODEC2': None, 'ACODEC2_ALLOW': [], 'ABITRATE2': None, 'ACHANNELS2': None,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'Roku-480p': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': 128000, 'ACHANNELS': 2,
             'ACODEC2': 'ac3', 'ACODEC2_ALLOW': ['ac3'], 'ABITRATE2': None, 'ACHANNELS2': 6,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'Roku-720p': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': 128000, 'ACHANNELS': 2,
             'ACODEC2': 'ac3', 'ACODEC2_ALLOW': ['ac3'], 'ABITRATE2': None, 'ACHANNELS2': 6,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'Roku-1080p': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4'],
             'ACODEC': 'aac', 'ACODEC_ALLOW': ['libfaac'], 'ABITRATE': 160000, 'ACHANNELS': 2,
             'ACODEC2': 'ac3', 'ACODEC2_ALLOW': ['ac3'], 'ABITRATE2': None, 'ACHANNELS2': 6,
             'ACODEC3': None, 'ACODEC3_ALLOW': [], 'ABITRATE3': None, 'ACHANNELS3': None,
             'SCODEC': 'mov_text'
         },
         'mkv': {
-            'VEXTENSION':'.mkv','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':None,'VLEVEL':None,
+            'VEXTENSION': '.mkv', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4', 'mpeg2video'],
+            'VCRF': None, 'VLEVEL': None,
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4', 'mpeg2video'],
             'ACODEC': 'dts', 'ACODEC_ALLOW': ['libfaac', 'dts', 'ac3', 'mp2', 'mp3'], 'ABITRATE': None, 'ACHANNELS': 8,
             'ACODEC2': None, 'ACODEC2_ALLOW': [], 'ABITRATE2': None, 'ACHANNELS2': None,
-            'ACODEC3':'ac3','ACODEC3_ALLOW':['libfaac', 'dts', 'ac3', 'mp2', 'mp3'],'ABITRATE3':None, 'ACHANNELS3':8,
+            'ACODEC3': 'ac3', 'ACODEC3_ALLOW': ['libfaac', 'dts', 'ac3', 'mp2', 'mp3'], 'ABITRATE3': None,
+            'ACHANNELS3': 8,
             'SCODEC': 'mov_text'
         },
         'mp4-scene-release': {
-            'VEXTENSION':'.mp4','VCODEC':'libx264','VPRESET':None,'VFRAMERATE':None,'VBITRATE':None,'VCRF':19,'VLEVEL':'3.1',
+            'VEXTENSION': '.mp4', 'VCODEC': 'libx264', 'VPRESET': None, 'VFRAMERATE': None, 'VBITRATE': None,
-            'VRESOLUTION':None,'VCODEC_ALLOW':['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4', 'mpeg2video'],
+            'VCRF': 19, 'VLEVEL': '3.1',
+            'VRESOLUTION': None,
+            'VCODEC_ALLOW': ['libx264', 'h264', 'h.264', 'AVC', 'avc', 'mpeg4', 'msmpeg4', 'MPEG-4', 'mpeg2video'],
             'ACODEC': 'dts', 'ACODEC_ALLOW': ['libfaac', 'dts', 'ac3', 'mp2', 'mp3'], 'ABITRATE': None, 'ACHANNELS': 8,
             'ACODEC2': None, 'ACODEC2_ALLOW': [], 'ABITRATE2': None, 'ACHANNELS2': None,
-            'ACODEC3':'ac3','ACODEC3_ALLOW':['libfaac', 'dts', 'ac3', 'mp2', 'mp3'],'ABITRATE3':None, 'ACHANNELS3':8,
+            'ACODEC3': 'ac3', 'ACODEC3_ALLOW': ['libfaac', 'dts', 'ac3', 'mp2', 'mp3'], 'ABITRATE3': None,
+            'ACHANNELS3': 8,
             'SCODEC': 'mov_text'
         }
     }
@@ -630,22 +703,26 @@ def initialize(section=None):
 
     if VEXTENSION in allow_subs:
         ALLOWSUBS = 1
-    if not VCODEC_ALLOW and VCODEC: VCODEC_ALLOW.extend([VCODEC])
+    if not VCODEC_ALLOW and VCODEC:
+        VCODEC_ALLOW.extend([VCODEC])
     for codec in VCODEC_ALLOW:
         if codec in codec_alias:
             extra = [item for item in codec_alias[codec] if item not in VCODEC_ALLOW]
             VCODEC_ALLOW.extend(extra)
-    if not ACODEC_ALLOW and ACODEC: ACODEC_ALLOW.extend([ACODEC])
+    if not ACODEC_ALLOW and ACODEC:
+        ACODEC_ALLOW.extend([ACODEC])
     for codec in ACODEC_ALLOW:
         if codec in codec_alias:
             extra = [item for item in codec_alias[codec] if item not in ACODEC_ALLOW]
             ACODEC_ALLOW.extend(extra)
-    if not ACODEC2_ALLOW and ACODEC2: ACODEC2_ALLOW.extend([ACODEC2])
+    if not ACODEC2_ALLOW and ACODEC2:
+        ACODEC2_ALLOW.extend([ACODEC2])
     for codec in ACODEC2_ALLOW:
         if codec in codec_alias:
             extra = [item for item in codec_alias[codec] if item not in ACODEC2_ALLOW]
             ACODEC2_ALLOW.extend(extra)
-    if not ACODEC3_ALLOW and ACODEC3: ACODEC3_ALLOW.extend([ACODEC3])
+    if not ACODEC3_ALLOW and ACODEC3:
+        ACODEC3_ALLOW.extend([ACODEC3])
     for codec in ACODEC3_ALLOW:
         if codec in codec_alias:
             extra = [item for item in codec_alias[codec] if item not in ACODEC3_ALLOW]
@@ -674,47 +751,59 @@ def initialize(section=None):
     else:
         try:
             SEVENZIP = subprocess.Popen(['which', '7z'], stdout=subprocess.PIPE).communicate()[0].strip()
-        except: pass
+        except:
+            pass
         if not SEVENZIP:
             try:
                 SEVENZIP = subprocess.Popen(['which', '7zr'], stdout=subprocess.PIPE).communicate()[0].strip()
-            except: pass
+            except:
+                pass
         if not SEVENZIP:
             try:
                 SEVENZIP = subprocess.Popen(['which', '7za'], stdout=subprocess.PIPE).communicate()[0].strip()
-            except: pass
+            except:
+                pass
         if not SEVENZIP:
             SEVENZIP = None
-            logger.warning("Failed to locate 7zip. Transcosing of disk images and extraction of .7z files will not be possible!")
+            logger.warning(
-        if os.path.isfile(os.path.join(FFMPEG_PATH, 'ffmpeg')) or os.access(os.path.join(FFMPEG_PATH, 'ffmpeg'), os.X_OK):
+                "Failed to locate 7zip. Transcosing of disk images and extraction of .7z files will not be possible!")
+        if os.path.isfile(os.path.join(FFMPEG_PATH, 'ffmpeg')) or os.access(os.path.join(FFMPEG_PATH, 'ffmpeg'),
+                                                                            os.X_OK):
             FFMPEG = os.path.join(FFMPEG_PATH, 'ffmpeg')
-        elif os.path.isfile(os.path.join(FFMPEG_PATH, 'avconv')) or os.access(os.path.join(FFMPEG_PATH, 'avconv'), os.X_OK):
+        elif os.path.isfile(os.path.join(FFMPEG_PATH, 'avconv')) or os.access(os.path.join(FFMPEG_PATH, 'avconv'),
+                                                                              os.X_OK):
             FFMPEG = os.path.join(FFMPEG_PATH, 'avconv')
         else:
             try:
                 FFMPEG = subprocess.Popen(['which', 'ffmpeg'], stdout=subprocess.PIPE).communicate()[0].strip()
-            except: pass
+            except:
+                pass
             if not FFMPEG:
                 try:
                     FFMPEG = subprocess.Popen(['which', 'avconv'], stdout=subprocess.PIPE).communicate()[0].strip()
-                except: pass
+                except:
+                    pass
         if not FFMPEG:
             FFMPEG = None
             logger.warning("Failed to locate ffmpeg. Transcoding disabled!")
             logger.warning("Install ffmpeg with x264 support to enable this feature  ...")
 
-        if os.path.isfile(os.path.join(FFMPEG_PATH, 'ffprobe')) or os.access(os.path.join(FFMPEG_PATH, 'ffprobe'), os.X_OK):
+        if os.path.isfile(os.path.join(FFMPEG_PATH, 'ffprobe')) or os.access(os.path.join(FFMPEG_PATH, 'ffprobe'),
+                                                                             os.X_OK):
             FFPROBE = os.path.join(FFMPEG_PATH, 'ffprobe')
-        elif os.path.isfile(os.path.join(FFMPEG_PATH, 'avprobe')) or os.access(os.path.join(FFMPEG_PATH, 'avprobe'), os.X_OK):
+        elif os.path.isfile(os.path.join(FFMPEG_PATH, 'avprobe')) or os.access(os.path.join(FFMPEG_PATH, 'avprobe'),
+                                                                               os.X_OK):
             FFPROBE = os.path.join(FFMPEG_PATH, 'avprobe')
         else:
             try:
                 FFPROBE = subprocess.Popen(['which', 'ffprobe'], stdout=subprocess.PIPE).communicate()[0].strip()
-            except: pass
+            except:
+                pass
             if not FFPROBE:
                 try:
                     FFPROBE = subprocess.Popen(['which', 'avprobe'], stdout=subprocess.PIPE).communicate()[0].strip()
-                except: pass
+                except:
+                    pass
         if not FFPROBE:
             FFPROBE = None
             if CHECK_MEDIA:
@@ -733,6 +822,7 @@ def initialize(section=None):
     # finished initalizing
     return True
 
+
 def restart():
     install_type = versionCheck.CheckVersion().install_type
 
@@ -752,6 +842,7 @@ def restart():
 
     os._exit(status)
 
+
 def rchmod(path, mod):
     logger.log("Changing file mode of %s to %s" % (path, oct(mod)))
     os.chmod(path, mod)

core/databases/mainDB.py

@@ -14,6 +14,7 @@ def backupDatabase(version):
     else:
         logger.info("Proceeding with upgrade")
 
+
 # ======================
 # = Main DB Migrations =
 # ======================

core/extractor/extractor.py

@@ -8,6 +8,7 @@ import core
 from subprocess import call, Popen
 import subprocess
 
+
 def extract(filePath, outputDestination):
     success = 0
     # Using Windows
@@ -22,9 +23,9 @@ def extract(filePath, outputDestination):
     # Using unix
     else:
         required_cmds = ["unrar", "unzip", "tar", "unxz", "unlzma", "7zr", "bunzip2"]
-        ## Possible future suport:
+        # ## Possible future suport:
         # gunzip: gz (cmd will delete original archive)
-        ## the following do not extract to dest dir
+        # ## the following do not extract to dest dir
         # ".xz": ["xz", "-d --keep"],
         # ".lzma": ["xz", "-d --format=lzma --keep"],
         # ".bz2": ["bzip2", "-d --keep"],
@@ -43,7 +44,8 @@ def extract(filePath, outputDestination):
         if not os.getenv('TR_TORRENT_DIR'):
             devnull = open(os.devnull, 'w')
             for cmd in required_cmds:
-                if call(['which', cmd], stdout=devnull, stderr=devnull):  #note, returns 0 if exists, or 1 if doesn't exist.
+                if call(['which', cmd], stdout=devnull,
+                        stderr=devnull):  # note, returns 0 if exists, or 1 if doesn't exist.
                     if cmd == "7zr" and not call(["which", "7z"]):  # we do have "7z" command
                         EXTRACT_COMMANDS[".7z"] = ["7z", "x"]
                     elif cmd == "7zr" and not call(["which", "7za"]):  # we do have "7za" command
@@ -112,7 +114,8 @@ def extract(filePath, outputDestination):
         cmd2.append("-p-")  # don't prompt for password.
         p = Popen(cmd2, stdout=devnull, stderr=devnull, startupinfo=info)  # should extract files fine.
         res = p.wait()
-        if (res >= 0 and os.name == 'nt') or res == 0:  # for windows chp returns process id if successful or -1*Error code. Linux returns 0 for successful.
+        if (
+                res >= 0 and os.name == 'nt') or res == 0:  # for windows chp returns process id if successful or -1*Error code. Linux returns 0 for successful.
             core.logger.info("EXTRACTOR: Extraction was successful for %s to %s" % (filePath, outputDestination))
             success = 1
         elif len(passwords) > 0:
@@ -149,12 +152,14 @@ def extract(filePath, outputDestination):
                 if not os.path.join(dir, subdir) in origFiles:
                     try:
                         os.chmod(os.path.join(dir, subdir), perms)
-                    except: pass
+                    except:
+                        pass
             for file in files:
                 if not os.path.join(dir, file) in origFiles:
                     try:
                         shutil.copymode(filePath, os.path.join(dir, file))
-                    except: pass
+                    except:
+                        pass
         return True
     else:
         core.logger.error("EXTRACTOR: Extraction failed for %s. Result was %s" % (filePath, res))

core/gh_api.py

@@ -2,6 +2,7 @@
 import json
 import requests
 
+
 class GitHub(object):
     """
     Simple api wrapper for the Github API v3.

core/linktastic/linktastic.py

@@ -30,6 +30,7 @@ if os.name == 'nt':
     info = subprocess.STARTUPINFO()
     info.dwFlags |= subprocess.STARTF_USESHOWWINDOW
 
+
 # Prevent spaces from messing with us!
 def _escape_param(param):
     return '"%s"' % param
@@ -62,6 +63,7 @@ def _symlink_windows(src, dest):
         # print(stdout)
         # assume if they ret-coded 0 we're good
 
+
 def _dirlink_windows(src, dest):
     try:
         subprocess.check_output(
@@ -74,6 +76,7 @@ def _dirlink_windows(src, dest):
         # print(stdout)
         # assume if they ret-coded 0 we're good
 
+
 def _junctionlink_windows(src, dest):
     try:
         subprocess.check_output(
@@ -86,6 +89,7 @@ def _junctionlink_windows(src, dest):
         # print(stdout)
         # assume if they ret-coded 0 we're good
 
+
 # Create a hard link to src named as dest
 # This version of link, unlike os.link, supports nt systems as well
 def link(src, dest):
@@ -102,6 +106,7 @@ def symlink(src, dest):
     else:
         os.symlink(src, dest)
 
+
 # Create a symlink to src named as dest, but don't fail if you're on nt
 def dirlink(src, dest):
     if os.name == 'nt':
@@ -109,6 +114,7 @@ def dirlink(src, dest):
     else:
         os.symlink(src, dest)
 
+
 # Create a symlink to src named as dest, but don't fail if you're on nt
 def junctionlink(src, dest):
     if os.name == 'nt':

core/logger.py

@@ -27,6 +27,7 @@ reverseNames = {u'ERROR': ERROR,
                 u'POSTPROCESS': POSTPROCESS,
                 u'DB': DB}
 
+
 class NTMRotatingLogHandler(object):
     def __init__(self, log_file, num_files, num_bytes):
         self.num_files = num_files
@@ -234,6 +235,7 @@ class NTMRotatingLogHandler(object):
         else:
             sys.exit(1)
 
+
 class DispatchingFormatter:
     def __init__(self, formatters, default_formatter):
         self._formatters = formatters
@@ -243,31 +245,41 @@ class DispatchingFormatter:
         formatter = self._formatters.get(record.name, self._default_formatter)
         return formatter.format(record)
 
+
 ntm_log_instance = NTMRotatingLogHandler(core.LOG_FILE, NUM_LOGS, LOG_SIZE)
 
+
 def log(toLog, logLevel=MESSAGE, section='MAIN'):
     ntm_log_instance.log(toLog, logLevel, section)
 
+
 def info(toLog, section='MAIN'):
     log(toLog, MESSAGE, section)
 
+
 def error(toLog, section='MAIN'):
     log(toLog, ERROR, section)
 
+
 def warning(toLog, section='MAIN'):
     log(toLog, WARNING, section)
 
+
 def debug(toLog, section='MAIN'):
     log(toLog, DEBUG, section)
 
+
 def postprocess(toLog, section='POSTPROCESS'):
     log(toLog, POSTPROCESS, section)
 
+
 def db(toLog, section='DB'):
     log(toLog, DB, section)
 
+
 def log_error_and_exit(error_msg):
     ntm_log_instance.log_error_and_exit(error_msg)
 
+
 def close():
     ntm_log_instance.close_log()

core/nzbToMediaAutoFork.py

@@ -4,6 +4,7 @@ import core
 import requests
 from core import logger
 
+
 def autoFork(section, inputCategory):
     # auto-detect correct section
     # config settings

core/nzbToMediaConfig.py

@@ -8,13 +8,15 @@ from core import logger
 
 from itertools import chain
 
+
 class Section(configobj.Section):
     def isenabled(section):
         # checks if subsection enabled, returns true/false if subsection specified otherwise returns true/false in {}
         if not section.sections:
             try:
                 value = list(ConfigObj.find_key(section, 'enabled'))[0]
-            except:value = 0
+            except:
+                value = 0
             if int(value) == 1:
                 return section
         else:
@@ -23,7 +25,8 @@ class Section(configobj.Section):
                 for subsection in subsections:
                     try:
                         value = list(ConfigObj.find_key(subsections, 'enabled'))[0]
-                    except:value = 0
+                    except:
+                        value = 0
 
                     if int(value) != 1:
                         del to_return[section_name][subsection]
@@ -39,7 +42,8 @@ class Section(configobj.Section):
         for subsection in to_return:
             try:
                 value = list(ConfigObj.find_key(to_return[subsection], key))[0]
-            except:value = None
+            except:
+                value = None
 
             if not value:
                 del to_return[subsection]
@@ -80,6 +84,7 @@ class Section(configobj.Section):
 
         return to_return
 
+
 class ConfigObj(configobj.ConfigObj, Section):
     def __init__(self, *args, **kw):
         if len(args) == 0:
@@ -190,7 +195,8 @@ class ConfigObj(configobj.ConfigObj, Section):
                 if not list(ConfigObj.find_key(CFG_NEW, option)):
                     try:
                         values.pop(option)
-                    except: pass
+                    except:
+                        pass
 
             return values
 
@@ -247,7 +253,8 @@ class ConfigObj(configobj.ConfigObj, Section):
         try:
             if os.environ.has_key('NZBPO_NDCATEGORY') and os.environ.has_key('NZBPO_SBCATEGORY'):
                 if os.environ['NZBPO_NDCATEGORY'] == os.environ['NZBPO_SBCATEGORY']:
-                    logger.warning("%s category is set for SickBeard and NzbDrone. Please check your config in NZBGet" % (os.environ['NZBPO_NDCATEGORY']))
+                    logger.warning("%s category is set for SickBeard and NzbDrone. "
+                                   "Please check your config in NZBGet" % (os.environ['NZBPO_NDCATEGORY']))
 
             section = "Nzb"
             key = 'NZBOP_DESTDIR'
@@ -278,8 +285,10 @@ class ConfigObj(configobj.ConfigObj, Section):
 
             section = "CouchPotato"
             envCatKey = 'NZBPO_CPSCATEGORY'
-            envKeys = ['ENABLED', 'APIKEY', 'HOST', 'PORT', 'SSL', 'WEB_ROOT', 'METHOD', 'DELETE_FAILED', 'REMOTE_PATH', 'WAIT_FOR', 'WATCH_DIR']
+            envKeys = ['ENABLED', 'APIKEY', 'HOST', 'PORT', 'SSL', 'WEB_ROOT', 'METHOD', 'DELETE_FAILED', 'REMOTE_PATH',
-            cfgKeys = ['enabled', 'apikey', 'host', 'port', 'ssl', 'web_root', 'method', 'delete_failed', 'remote_path', 'wait_for', 'watch_dir']
+                       'WAIT_FOR', 'WATCH_DIR']
+            cfgKeys = ['enabled', 'apikey', 'host', 'port', 'ssl', 'web_root', 'method', 'delete_failed', 'remote_path',
+                       'wait_for', 'watch_dir']
             if os.environ.has_key(envCatKey):
                 for index in range(len(envKeys)):
                     key = 'NZBPO_CPS' + envKeys[index]
@@ -293,8 +302,10 @@ class ConfigObj(configobj.ConfigObj, Section):
 
             section = "SickBeard"
             envCatKey = 'NZBPO_SBCATEGORY'
-            envKeys = ['ENABLED', 'HOST', 'PORT', 'USERNAME', 'PASSWORD', 'SSL', 'WEB_ROOT', 'WATCH_DIR', 'FORK', 'DELETE_FAILED', 'TORRENT_NOLINK', 'NZBEXTRACTIONBY', 'REMOTE_PATH', 'PROCESS_METHOD']
+            envKeys = ['ENABLED', 'HOST', 'PORT', 'USERNAME', 'PASSWORD', 'SSL', 'WEB_ROOT', 'WATCH_DIR', 'FORK',
-            cfgKeys = ['enabled', 'host', 'port', 'username', 'password', 'ssl', 'web_root', 'watch_dir', 'fork', 'delete_failed', 'Torrent_NoLink', 'nzbExtractionBy', 'remote_path', 'process_method']
+                       'DELETE_FAILED', 'TORRENT_NOLINK', 'NZBEXTRACTIONBY', 'REMOTE_PATH', 'PROCESS_METHOD']
+            cfgKeys = ['enabled', 'host', 'port', 'username', 'password', 'ssl', 'web_root', 'watch_dir', 'fork',
+                       'delete_failed', 'Torrent_NoLink', 'nzbExtractionBy', 'remote_path', 'process_method']
             if os.environ.has_key(envCatKey):
                 for index in range(len(envKeys)):
                     key = 'NZBPO_SB' + envKeys[index]
@@ -325,8 +336,10 @@ class ConfigObj(configobj.ConfigObj, Section):
 
             section = "Mylar"
             envCatKey = 'NZBPO_MYCATEGORY'
-            envKeys = ['ENABLED', 'HOST', 'PORT', 'USERNAME', 'PASSWORD', 'APIKEY', 'SSL', 'WEB_ROOT', 'WATCH_DIR', 'REMOTE_PATH']
+            envKeys = ['ENABLED', 'HOST', 'PORT', 'USERNAME', 'PASSWORD', 'APIKEY', 'SSL', 'WEB_ROOT', 'WATCH_DIR',
-            cfgKeys = ['enabled', 'host', 'port', 'username', 'password', 'apikey', 'ssl', 'web_root', 'watch_dir', 'remote_path']
+                       'REMOTE_PATH']
+            cfgKeys = ['enabled', 'host', 'port', 'username', 'password', 'apikey', 'ssl', 'web_root', 'watch_dir',
+                       'remote_path']
             if os.environ.has_key(envCatKey):
                 for index in range(len(envKeys)):
                     key = 'NZBPO_MY' + envKeys[index]
@@ -355,8 +368,10 @@ class ConfigObj(configobj.ConfigObj, Section):
 
             section = "NzbDrone"
             envCatKey = 'NZBPO_NDCATEGORY'
-            envKeys = ['ENABLED', 'HOST', 'APIKEY', 'PORT', 'SSL', 'WEB_ROOT', 'WATCH_DIR', 'FORK', 'DELETE_FAILED', 'TORRENT_NOLINK', 'NZBEXTRACTIONBY', 'WAIT_FOR', 'DELETE_FAILED', 'REMOTE_PATH']
+            envKeys = ['ENABLED', 'HOST', 'APIKEY', 'PORT', 'SSL', 'WEB_ROOT', 'WATCH_DIR', 'FORK', 'DELETE_FAILED',
-            cfgKeys = ['enabled', 'host', 'apikey', 'port', 'ssl', 'web_root', 'watch_dir', 'fork', 'delete_failed', 'Torrent_NoLink', 'nzbExtractionBy', 'wait_for', 'delete_failed', 'remote_path']
+                       'TORRENT_NOLINK', 'NZBEXTRACTIONBY', 'WAIT_FOR', 'DELETE_FAILED', 'REMOTE_PATH']
+            cfgKeys = ['enabled', 'host', 'apikey', 'port', 'ssl', 'web_root', 'watch_dir', 'fork', 'delete_failed',
+                       'Torrent_NoLink', 'nzbExtractionBy', 'wait_for', 'delete_failed', 'remote_path']
             if os.environ.has_key(envCatKey):
                 for index in range(len(envKeys)):
                     key = 'NZBPO_ND' + envKeys[index]
@@ -391,16 +406,26 @@ class ConfigObj(configobj.ConfigObj, Section):
                     CFG_NEW[section][option] = value
 
             section = "Transcoder"
-            envKeys = ['TRANSCODE', 'DUPLICATE', 'IGNOREEXTENSIONS', 'OUTPUTFASTSTART', 'OUTPUTVIDEOPATH', 'PROCESSOUTPUT', 'AUDIOLANGUAGE', 'ALLAUDIOLANGUAGES', 'SUBLANGUAGES', 
+            envKeys = ['TRANSCODE', 'DUPLICATE', 'IGNOREEXTENSIONS', 'OUTPUTFASTSTART', 'OUTPUTVIDEOPATH',
-                          'ALLSUBLANGUAGES', 'EMBEDSUBS', 'BURNINSUBTITLE', 'EXTRACTSUBS', 'EXTERNALSUBDIR', 'OUTPUTDEFAULT', 'OUTPUTVIDEOEXTENSION', 'OUTPUTVIDEOCODEC', 'VIDEOCODECALLOW', 
+                       'PROCESSOUTPUT', 'AUDIOLANGUAGE', 'ALLAUDIOLANGUAGES', 'SUBLANGUAGES',
-                          'OUTPUTVIDEOPRESET', 'OUTPUTVIDEOFRAMERATE', 'OUTPUTVIDEOBITRATE', 'OUTPUTAUDIOCODEC', 'AUDIOCODECALLOW', 'OUTPUTAUDIOBITRATE', 'OUTPUTQUALITYPERCENT', 'GETSUBS', 
+                       'ALLSUBLANGUAGES', 'EMBEDSUBS', 'BURNINSUBTITLE', 'EXTRACTSUBS', 'EXTERNALSUBDIR',
-                          'OUTPUTAUDIOTRACK2CODEC', 'AUDIOCODEC2ALLOW', 'OUTPUTAUDIOTRACK2BITRATE', 'OUTPUTAUDIOOTHERCODEC', 'AUDIOOTHERCODECALLOW', 'OUTPUTAUDIOOTHERBITRATE', 
+                       'OUTPUTDEFAULT', 'OUTPUTVIDEOEXTENSION', 'OUTPUTVIDEOCODEC', 'VIDEOCODECALLOW',
-                          'OUTPUTSUBTITLECODEC', 'OUTPUTAUDIOCHANNELS', 'OUTPUTAUDIOTRACK2CHANNELS', 'OUTPUTAUDIOOTHERCHANNELS']
+                       'OUTPUTVIDEOPRESET', 'OUTPUTVIDEOFRAMERATE', 'OUTPUTVIDEOBITRATE', 'OUTPUTAUDIOCODEC',
-            cfgKeys = ['transcode', 'duplicate', 'ignoreExtensions', 'outputFastStart', 'outputVideoPath', 'processOutput', 'audioLanguage', 'allAudioLanguages', 'subLanguages', 
+                       'AUDIOCODECALLOW', 'OUTPUTAUDIOBITRATE', 'OUTPUTQUALITYPERCENT', 'GETSUBS',
-                          'allSubLanguages', 'embedSubs', 'burnInSubtitle', 'extractSubs', 'externalSubDir', 'outputDefault', 'outputVideoExtension', 'outputVideoCodec', 'VideoCodecAllow', 
+                       'OUTPUTAUDIOTRACK2CODEC', 'AUDIOCODEC2ALLOW', 'OUTPUTAUDIOTRACK2BITRATE',
-                          'outputVideoPreset', 'outputVideoFramerate', 'outputVideoBitrate', 'outputAudioCodec', 'AudioCodecAllow', 'outputAudioBitrate', 'outputQualityPercent', 'getSubs', 
+                       'OUTPUTAUDIOOTHERCODEC', 'AUDIOOTHERCODECALLOW', 'OUTPUTAUDIOOTHERBITRATE',
-                          'outputAudioTrack2Codec', 'AudioCodec2Allow', 'outputAudioTrack2Bitrate', 'outputAudioOtherCodec', 'AudioOtherCodecAllow', 'outputAudioOtherBitrate', 
+                       'OUTPUTSUBTITLECODEC', 'OUTPUTAUDIOCHANNELS', 'OUTPUTAUDIOTRACK2CHANNELS',
-                          'outputSubtitleCodec', 'outputAudioChannels', 'outputAudioTrack2Channels', 'outputAudioOtherChannels']
+                       'OUTPUTAUDIOOTHERCHANNELS']
+            cfgKeys = ['transcode', 'duplicate', 'ignoreExtensions', 'outputFastStart', 'outputVideoPath',
+                       'processOutput', 'audioLanguage', 'allAudioLanguages', 'subLanguages',
+                       'allSubLanguages', 'embedSubs', 'burnInSubtitle', 'extractSubs', 'externalSubDir',
+                       'outputDefault', 'outputVideoExtension', 'outputVideoCodec', 'VideoCodecAllow',
+                       'outputVideoPreset', 'outputVideoFramerate', 'outputVideoBitrate', 'outputAudioCodec',
+                       'AudioCodecAllow', 'outputAudioBitrate', 'outputQualityPercent', 'getSubs',
+                       'outputAudioTrack2Codec', 'AudioCodec2Allow', 'outputAudioTrack2Bitrate',
+                       'outputAudioOtherCodec', 'AudioOtherCodecAllow', 'outputAudioOtherBitrate',
+                       'outputSubtitleCodec', 'outputAudioChannels', 'outputAudioTrack2Channels',
+                       'outputAudioOtherChannels']
             for index in range(len(envKeys)):
                 key = 'NZBPO_' + envKeys[index]
                 if os.environ.has_key(key):
@@ -420,8 +445,10 @@ class ConfigObj(configobj.ConfigObj, Section):
 
             section = "UserScript"
             envCatKey = 'NZBPO_USCATEGORY'
-            envKeys = ['USER_SCRIPT_MEDIAEXTENSIONS', 'USER_SCRIPT_PATH', 'USER_SCRIPT_PARAM', 'USER_SCRIPT_RUNONCE', 'USER_SCRIPT_SUCCESSCODES', 'USER_SCRIPT_CLEAN', 'USDELAY', 'USREMOTE_PATH']
+            envKeys = ['USER_SCRIPT_MEDIAEXTENSIONS', 'USER_SCRIPT_PATH', 'USER_SCRIPT_PARAM', 'USER_SCRIPT_RUNONCE',
-            cfgKeys = ['user_script_mediaExtensions', 'user_script_path', 'user_script_param', 'user_script_runOnce', 'user_script_successCodes', 'user_script_clean', 'delay', 'remote_path']
+                       'USER_SCRIPT_SUCCESSCODES', 'USER_SCRIPT_CLEAN', 'USDELAY', 'USREMOTE_PATH']
+            cfgKeys = ['user_script_mediaExtensions', 'user_script_path', 'user_script_param', 'user_script_runOnce',
+                       'user_script_successCodes', 'user_script_clean', 'delay', 'remote_path']
             if os.environ.has_key(envCatKey):
                 for index in range(len(envKeys)):
                     key = 'NZBPO_' + envKeys[index]
@@ -445,6 +472,7 @@ class ConfigObj(configobj.ConfigObj, Section):
 
         return CFG_NEW
 
+
 configobj.Section = Section
 configobj.ConfigObj = ConfigObj
 config = ConfigObj

core/nzbToMediaDB.py

@@ -8,6 +8,7 @@ import time
 import core
 from core import logger
 
+
 def dbFilename(filename="nzbtomedia.db", suffix=None):
     """
     @param filename: The sqlite database filename to use. If not specified,
@@ -153,7 +154,6 @@ class DBConnection:
 
         return sqlResult
 
-
     def select(self, query, args=None):
 
         sqlResults = self.action(query, args).fetchall()
@@ -264,4 +264,3 @@ class SchemaUpgrade(object):
         new_version = self.checkDBVersion() + 1
         self.connection.action("UPDATE db_version SET db_version = ?", [new_version])
         return new_version
-

core/nzbToMediaSceneExceptions.py

@@ -6,20 +6,25 @@ import shlex
 from core import logger
 from core.nzbToMediaUtil import listMediaFiles
 
-reverse_list = [r"\.\d{2}e\d{2}s\.", r"\.[pi]0801\.", r"\.p027\.", r"\.[pi]675\.", r"\.[pi]084\.", r"\.p063\.", r"\b[45]62[xh]\.", r"\.yarulb\.", r"\.vtd[hp]\.", 
+reverse_list = [r"\.\d{2}e\d{2}s\.", r"\.[pi]0801\.", r"\.p027\.", r"\.[pi]675\.", r"\.[pi]084\.", r"\.p063\.",
-                r"\.ld[.-]?bew\.", r"\.pir.?(dov|dvd|bew|db|rb)\.", r"\brdvd\.", r"\.vts\.", r"\.reneercs\.", r"\.dcv\.", r"\b(pir|mac)dh\b", r"\.reporp\.", r"\.kcaper\.", 
+                r"\b[45]62[xh]\.", r"\.yarulb\.", r"\.vtd[hp]\.",
+                r"\.ld[.-]?bew\.", r"\.pir.?(dov|dvd|bew|db|rb)\.", r"\brdvd\.", r"\.vts\.", r"\.reneercs\.",
+                r"\.dcv\.", r"\b(pir|mac)dh\b", r"\.reporp\.", r"\.kcaper\.",
                 r"\.lanretni\.", r"\b3ca\b", r"\.cstn\."]
 reverse_pattern = re.compile('|'.join(reverse_list), flags=re.IGNORECASE)
 season_pattern = re.compile(r"(.*\.\d{2}e\d{2}s\.)(.*)", flags=re.IGNORECASE)
 word_pattern = re.compile(r"([^A-Z0-9]*[A-Z0-9]+)")
-media_list = [r"\.s\d{2}e\d{2}\.", r"\.1080[pi]\.", r"\.720p\.", r"\.576[pi]", r"\.480[pi]\.", r"\.360p\.", r"\.[xh]26[45]\b", r"\.bluray\.", r"\.[hp]dtv\.", 
+media_list = [r"\.s\d{2}e\d{2}\.", r"\.1080[pi]\.", r"\.720p\.", r"\.576[pi]", r"\.480[pi]\.", r"\.360p\.",
-              r"\.web[.-]?dl\.", r"\.(vod|dvd|web|bd|br).?rip\.", r"\.dvdr\b", r"\.stv\.", r"\.screener\.", r"\.vcd\.", r"\bhd(cam|rip)\b", r"\.proper\.", r"\.repack\.", 
+              r"\.[xh]26[45]\b", r"\.bluray\.", r"\.[hp]dtv\.",
+              r"\.web[.-]?dl\.", r"\.(vod|dvd|web|bd|br).?rip\.", r"\.dvdr\b", r"\.stv\.", r"\.screener\.", r"\.vcd\.",
+              r"\bhd(cam|rip)\b", r"\.proper\.", r"\.repack\.",
               r"\.internal\.", r"\bac3\b", r"\.ntsc\.", r"\.pal\.", r"\.secam\.", r"\bdivx\b", r"\bxvid\b"]
 media_pattern = re.compile('|'.join(media_list), flags=re.IGNORECASE)
 garbage_name = re.compile(r"^[a-zA-Z0-9]*$")
 char_replace = [[r"(\w)1\.(\w)", r"\1i\2"]
                 ]
 
+
 def process_all_exceptions(name, dirname):
     rename_script(dirname)
     for filename in listMediaFiles(dirname):
@@ -40,6 +45,7 @@ def process_all_exceptions(name, dirname):
         if newfilename != filename:
             rename_file(filename, newfilename)
 
+
 def strip_groups(filename):
     if not core.GROUPS:
         return filename
@@ -53,6 +59,7 @@ def strip_groups(filename):
     newfilePath = os.path.join(dirname, newfile)
     return newfilePath
 
+
 def rename_file(filename, newfilePath):
     logger.debug("Replacing file name %s with download name %s" % (filename, newfilePath), "EXCEPTION")
     try:
@@ -60,6 +67,7 @@ def rename_file(filename, newfilePath):
     except Exception, e:
         logger.error("Unable to rename file due to: %s" % (str(e)), "EXCEPTION")
 
+
 def replace_filename(filename, dirname, name):
     head, fileExtension = os.path.splitext(os.path.basename(filename))
     if media_pattern.search(os.path.basename(dirname).replace(' ', '.')) is not None:
@@ -75,6 +83,7 @@ def replace_filename(filename, dirname, name):
     newfilePath = os.path.join(dirname, newfile)
     return newfilePath
 
+
 def reverse_filename(filename, dirname, name):
     head, fileExtension = os.path.splitext(os.path.basename(filename))
     na_parts = season_pattern.search(head)
@@ -99,6 +108,7 @@ def reverse_filename(filename, dirname, name):
     newfilePath = os.path.join(dirname, newfile)
     return newfilePath
 
+
 def rename_script(dirname):
     rename_file = ""
     for dir, dirs, files in os.walk(dirname):
@@ -127,5 +137,4 @@ def rename_script(dirname):
 
 # dict for custom groups
 # we can add more to this list
-#__customgroups__ = {'Q o Q': process_qoq, '-ECI': process_eci}
+# _customgroups = {'Q o Q': process_qoq, '-ECI': process_eci}
-                

core/nzbToMediaUserScript.py

@@ -6,12 +6,14 @@ from core.transcoder import transcoder
 from core.nzbToMediaUtil import import_subs, listMediaFiles, rmDir
 from core import logger
 
+
 def external_script(outputDestination, torrentName, torrentLabel, settings):
     final_result = 0  # start at 0.
     num_files = 0
     try:
         core.USER_SCRIPT_MEDIAEXTENSIONS = settings["user_script_mediaExtensions"]
-        if isinstance(core.USER_SCRIPT_MEDIAEXTENSIONS, str): core.USER_SCRIPT_MEDIAEXTENSIONS = core.USER_SCRIPT_MEDIAEXTENSIONS.split(',')
+        if isinstance(core.USER_SCRIPT_MEDIAEXTENSIONS, str):
+            core.USER_SCRIPT_MEDIAEXTENSIONS = core.USER_SCRIPT_MEDIAEXTENSIONS.split(',')
     except:
         core.USER_SCRIPT_MEDIAEXTENSIONS = []
     try:
@@ -22,12 +24,14 @@ def external_script(outputDestination, torrentName, torrentLabel, settings):
         return [0, ""]
     try:
         core.USER_SCRIPT_PARAM = settings["user_script_param"]
-        if isinstance(core.USER_SCRIPT_PARAM, str): core.USER_SCRIPT_PARAM = core.USER_SCRIPT_PARAM.split(',')
+        if isinstance(core.USER_SCRIPT_PARAM, str):
+            core.USER_SCRIPT_PARAM = core.USER_SCRIPT_PARAM.split(',')
     except:
         core.USER_SCRIPT_PARAM = []
     try:
         core.USER_SCRIPT_SUCCESSCODES = settings["user_script_successCodes"]
-        if isinstance(core.USER_SCRIPT_SUCCESSCODES, str): core.USER_SCRIPT_SUCCESSCODES = core.USER_SCRIPT_SUCCESSCODES.split(',')
+        if isinstance(core.USER_SCRIPT_SUCCESSCODES, str):
+            core.USER_SCRIPT_SUCCESSCODES = core.USER_SCRIPT_SUCCESSCODES.split(',')
     except:
         core.USER_SCRIPT_SUCCESSCODES = 0
     try:

core/nzbToMediaUtil.py

@@ -25,6 +25,7 @@ from core import logger, nzbToMediaDB
 
 requests.packages.urllib3.disable_warnings()
 
+
 def reportNzb(failure_link, clientAgent):
     # Contact indexer site
     logger.info("Sending failure notification to indexer site")
@@ -40,8 +41,9 @@ def reportNzb(failure_link, clientAgent):
         logger.error("Unable to open URL %s due to %s" % (failure_link, e))
     return
 
+
 def sanitizeName(name):
-    '''
+    """
     >>> sanitizeName('a/b/c')
     'a-b-c'
     >>> sanitizeName('abc')
@@ -50,7 +52,7 @@ def sanitizeName(name):
     'ab'
     >>> sanitizeName('.a.b..')
     'a.b'
-    '''
+    """
 
     # remove bad chars from the filename
     name = re.sub(r'[\\\/*]', '-', name)
@@ -60,10 +62,12 @@ def sanitizeName(name):
     name = name.strip(' .')
     try:
         name = name.encode(core.SYS_ENCODING)
-    except: pass
+    except:
+        pass
 
     return name
 
+
 def makeDir(path):
     if not os.path.isdir(path):
         try:
@@ -72,6 +76,7 @@ def makeDir(path):
             return False
     return True
 
+
 def remoteDir(path):
     if not core.REMOTEPATHS:
         return path
@@ -89,15 +94,18 @@ def remoteDir(path):
             return new_path
     return path
 
+
 def category_search(inputDirectory, inputName, inputCategory, root, categories):
     tordir = False
 
     try:
         inputName = inputName.encode(core.SYS_ENCODING)
-    except: pass
+    except:
+        pass
     try:
         inputDirectory = inputDirectory.encode(core.SYS_ENCODING)
-    except: pass
+    except:
+        pass
 
     if inputDirectory is None:  # =Nothing to process here.
         return inputDirectory, inputName, inputCategory, root
@@ -116,7 +124,8 @@ def category_search(inputDirectory, inputName, inputCategory, root, categories):
             inputCategory = ""
             logger.debug("SEARCH: Could not find a category in the directory structure")
     if not os.path.isdir(inputDirectory) and os.path.isfile(inputDirectory):  # If the input directory is a file
-        if not inputName: inputName = os.path.split(os.path.normpath(inputDirectory))[1]
+        if not inputName:
+            inputName = os.path.split(os.path.normpath(inputDirectory))[1]
         return inputDirectory, inputName, inputCategory, root
 
     if inputCategory and os.path.isdir(os.path.join(inputDirectory, inputCategory)):
@@ -158,7 +167,8 @@ def category_search(inputDirectory, inputName, inputCategory, root, categories):
             if index + 1 < len(pathlist):
                 tordir = True
                 logger.info("SEARCH: Found a unique directory %s in the category directory" % (pathlist[index + 1]))
-                if not inputName: inputName = pathlist[index + 1]
+                if not inputName:
+                    inputName = pathlist[index + 1]
         except ValueError:
             pass
 
@@ -177,15 +187,17 @@ def category_search(inputDirectory, inputName, inputCategory, root, categories):
 
     return inputDirectory, inputName, inputCategory, root
 
+
 def getDirSize(inputPath):
     from functools import partial
     prepend = partial(os.path.join, inputPath)
-   return sum([(os.path.getsize(f) if os.path.isfile(f) else getDirSize(f)) for f in map(prepend, os.listdir(inputPath))])
+    return sum(
+        [(os.path.getsize(f) if os.path.isfile(f) else getDirSize(f)) for f in map(prepend, os.listdir(inputPath))])
+
 
 def is_minSize(inputName, minSize):
     fileName, fileExt = os.path.splitext(os.path.basename(inputName))
 
-
     # audio files we need to check directory size not file size
     inputSize = os.path.getsize(inputName)
     if fileExt in (core.AUDIOCONTAINER):
@@ -199,11 +211,13 @@ def is_minSize(inputName, minSize):
     if inputSize > minSize * 1048576:
         return True
 
+
 def is_sample(inputName):
     # Ignore 'sample' in files
     if re.search('(^|[\W_])sample\d*[\W_]', inputName.lower()):
         return True
 
+
 def copy_link(src, targetLink, useLink):
     logger.info("MEDIAFILE: [%s]" % (os.path.basename(targetLink)), 'COPYLINK')
     logger.info("SOURCE FOLDER: [%s]" % (os.path.dirname(src)), 'COPYLINK')
@@ -254,6 +268,7 @@ def copy_link(src, targetLink, useLink):
 
     return True
 
+
 def replace_links(link):
     n = 0
     target = link
@@ -277,6 +292,7 @@ def replace_links(link):
         os.unlink(link)
         linktastic.symlink(target, link)
 
+
 def flatten(outputDestination):
     logger.info("FLATTEN: Flattening directory: %s" % (outputDestination))
     for outputFile in listMediaFiles(outputDestination):
@@ -295,8 +311,9 @@ def flatten(outputDestination):
 
     removeEmptyFolders(outputDestination)  # Cleanup empty directories
 
+
 def removeEmptyFolders(path, removeRoot=True):
-  'Function to remove empty folders'
+    """Function to remove empty folders"""
     if not os.path.isdir(path):
         return
 
@@ -315,6 +332,7 @@ def removeEmptyFolders(path, removeRoot=True):
         logger.debug("Removing empty folder:%s" % (path))
         os.rmdir(path)
 
+
 def rmReadOnly(filename):
     if os.path.isfile(filename):
         # check first the read-only attribute
@@ -327,6 +345,7 @@ def rmReadOnly(filename):
             except:
                 logger.warning('Cannot change permissions of ' + filename, logger.WARNING)
 
+
 # Wake function
 def WakeOnLan(ethernet_address):
     addr_byte = ethernet_address.split(':')
@@ -392,7 +411,8 @@ def CharReplace(Name):
         # /!\ detection is done 2char by 2char for UTF-8 special character
         if (len(Name) != 1) & (Idx < (len(Name) - 1)):
             # Detect UTF-8
-            if ((Name[Idx] == '\xC2') | (Name[Idx] == '\xC3')) & ((Name[Idx+1] >= '\xA0') & (Name[Idx+1] <= '\xFF')):
+            if ((Name[Idx] == '\xC2') | (Name[Idx] == '\xC3')) & (
+                        (Name[Idx + 1] >= '\xA0') & (Name[Idx + 1] <= '\xFF')):
                 encoding = 'utf-8'
                 break
             # Detect CP850
@@ -628,7 +648,8 @@ def getDirs(section, subsection, link = 'hard'):
 
                 try:
                     newPath = newPath.encode(core.SYS_ENCODING)
-                except: pass
+                except:
+                    pass
 
                 # Just fail-safe incase we already have afile with this clean-name (was actually a bug from earlier code, but let's be safe).
                 if os.path.isfile(newPath):
@@ -642,7 +663,8 @@ def getDirs(section, subsection, link = 'hard'):
                 newfile = os.path.join(newPath, sanitizeName(os.path.split(mediafile)[1]))
                 try:
                     newfile = newfile.encode(core.SYS_ENCODING)
-                except: pass
+                except:
+                    pass
 
                 # link file to its new path
                 copy_link(mediafile, newfile, link)
@@ -667,7 +689,8 @@ def getDirs(section, subsection, link = 'hard'):
         elif os.path.exists(core.CFG[section][subsection]["watch_dir"]):
             to_return.extend(processDir(core.CFG[section][subsection]["watch_dir"]))
     except Exception as e:
-        logger.error("Failed to add directories from %s for post-processing: %s" % (core.CFG[section][subsection]["watch_dir"], e))
+        logger.error("Failed to add directories from %s for post-processing: %s" % (
+            core.CFG[section][subsection]["watch_dir"], e))
 
     if core.USELINK == 'move':
         try:
@@ -682,6 +705,7 @@ def getDirs(section, subsection, link = 'hard'):
 
     return list(set(to_return))
 
+
 def onerror(func, path, exc_info):
     """
     Error handler for ``shutil.rmtree``.
@@ -700,6 +724,7 @@ def onerror(func, path, exc_info):
     else:
         raise
 
+
 def rmDir(dirName):
     logger.info("Deleting %s" % (dirName))
     try:
@@ -707,6 +732,7 @@ def rmDir(dirName):
     except:
         logger.error("Unable to delete folder %s" % (dirName))
 
+
 def cleanDir(path, section, subsection):
     if not os.path.exists(path):
         logger.info('Directory %s has been processed and removed ...' % (path), 'CLEANDIR')
@@ -717,10 +743,12 @@ def cleanDir(path, section, subsection):
         return
     try:
         minSize = int(core.CFG[section][subsection]['minSize'])
-    except:minSize = 0
+    except:
+        minSize = 0
     try:
         delete_ignored = int(core.CFG[section][subsection]['delete_ignored'])
-    except:delete_ignored = 0
+    except:
+        delete_ignored = 0
     try:
         num_files = len(listMediaFiles(path, minSize=minSize, delete_ignored=delete_ignored))
     except:
@@ -737,6 +765,7 @@ def cleanDir(path, section, subsection):
     except:
         logger.error("Unable to delete directory %s" % (path))
 
+
 def create_torrent_class(clientAgent):
     # Hardlink solution for Torrents
     tc = None
@@ -769,6 +798,7 @@ def create_torrent_class(clientAgent):
 
     return tc
 
+
 def pause_torrent(clientAgent, inputHash, inputID, inputName):
     logger.debug("Stopping torrent %s in %s while processing" % (inputName, clientAgent))
     try:
@@ -782,6 +812,7 @@ def pause_torrent(clientAgent, inputHash, inputID, inputName):
     except:
         logger.warning("Failed to stop torrent %s in %s" % (inputName, clientAgent))
 
+
 def resume_torrent(clientAgent, inputHash, inputID, inputName):
     if not core.TORRENT_RESUME == 1:
         return
@@ -797,6 +828,7 @@ def resume_torrent(clientAgent, inputHash, inputID, inputName):
     except:
         logger.warning("Failed to start torrent %s in %s" % (inputName, clientAgent))
 
+
 def remove_torrent(clientAgent, inputHash, inputID, inputName):
     if core.DELETE_ORIGINAL == 1 or core.USELINK == 'move':
         logger.debug("Deleting torrent %s from %s" % (inputName, clientAgent))
@@ -814,6 +846,7 @@ def remove_torrent(clientAgent, inputHash, inputID, inputName):
     else:
         resume_torrent(clientAgent, inputHash, inputID, inputName)
 
+
 def find_download(clientAgent, download_id):
     logger.debug("Searching for Download on %s ..." % (clientAgent))
     if clientAgent == 'utorrent':
@@ -851,6 +884,7 @@ def find_download(clientAgent, download_id):
             return True
     return False
 
+
 def get_nzoid(inputName):
     nzoid = None
     slots = []
@@ -923,6 +957,7 @@ def is_archive_file(filename):
             return regext.split(filename)[0]
     return False
 
+
 def isMediaFile(mediafile, media=True, audio=True, meta=True, archives=True):
     fileName, fileExt = os.path.splitext(mediafile)
 
@@ -941,6 +976,7 @@ def isMediaFile(mediafile, media=True, audio=True, meta=True, archives=True):
     else:
         return False
 
+
 def listMediaFiles(path, minSize=0, delete_ignored=0, media=True, audio=True, meta=True, archives=True):
     files = []
     if not os.path.isdir(path):
@@ -953,7 +989,8 @@ def listMediaFiles(path, minSize=0, delete_ignored=0, media=True, audio=True, me
                         try:
                             os.unlink(path)
                             logger.debug('Ignored file %s has been removed ...' % (curFile))
-                        except:pass
+                        except:
+                            pass
                 else:
                     files.append(path)
 
@@ -973,13 +1010,15 @@ def listMediaFiles(path, minSize=0, delete_ignored=0, media=True, audio=True, me
                     try:
                         os.unlink(fullCurFile)
                         logger.debug('Ignored file %s has been removed ...' % (curFile))
-                    except:pass
+                    except:
+                        pass
                 continue
 
             files.append(fullCurFile)
 
     return sorted(files, key=len)
 
+
 def find_imdbid(dirName, inputName):
     imdbid = None
 
@@ -1045,6 +1084,7 @@ def find_imdbid(dirName, inputName):
     logger.warning('Unable to find a imdbID for %s' % (inputName))
     return imdbid
 
+
 def extractFiles(src, dst=None, keep_archive=None):
     extracted_folder = []
     extracted_archive = []
@@ -1081,6 +1121,7 @@ def extractFiles(src, dst=None, keep_archive = None):
             except Exception as e:
                 logger.error("Unable to remove file %s due to: %s" % (inputFile, e))
 
+
 def import_subs(filename):
     if not core.GETSUBS:
         return
@@ -1106,6 +1147,7 @@ def import_subs(filename):
     except Exception as e:
         logger.error("Failed to download subtitles for %s due to: %s" % (filename, e), 'SUBTITLES')
 
+
 def server_responding(baseURL):
     try:
         requests.get(baseURL, timeout=(60, 120), verify=False)
@@ -1113,6 +1155,7 @@ def server_responding(baseURL):
     except (requests.ConnectionError, requests.exceptions.Timeout):
         return False
 
+
 def plex_update(category):
     if core.FAILED:
         return
@@ -1136,6 +1179,7 @@ def plex_update(category):
     else:
         logger.debug("Could not identify section for plex update", 'PLEX')
 
+
 def backupVersionedFile(old_file, version):
     numTries = 0
 
@@ -1152,7 +1196,8 @@ def backupVersionedFile(old_file, version):
             logger.log(u"Backup done", logger.DEBUG)
             break
         except Exception, e:
-            logger.log(u"Error while trying to back up " + old_file + " to " + new_file + " : " + str(e), logger.WARNING)
+            logger.log(u"Error while trying to back up " + old_file + " to " + new_file + " : " + str(e),
+                       logger.WARNING)
             numTries += 1
             time.sleep(1)
             logger.log(u"Trying again.", logger.DEBUG)
@@ -1181,6 +1226,7 @@ def get_downloadInfo(inputName, status):
 
     return sqlResults
 
+
 class RunningProcess():
     """ Limits application to single instance """
 
@@ -1196,8 +1242,8 @@ class RunningProcess():
         # def __del__(self):
         #    self.process.__del__()
 
-class WindowsProcess():
 
+class WindowsProcess():
     def __init__(self):
         self.mutexname = "nzbtomedia_" + core.PID_FILE.replace('\\', '/')  # {D0E858DF-985E-4907-B7FB-8D732C3FC3B9}"
         if platform.system() == 'Windows':
@@ -1218,13 +1264,12 @@ class WindowsProcess():
         else:
             return False
 
-
     def __del__(self):
         if self.mutex:
             self.CloseHandle(self.mutex)
 
-class PosixProcess():
 
+class PosixProcess():
     def __init__(self):
         self.pidpath = core.PID_FILE
         self.lock_socket = None
@@ -1239,7 +1284,8 @@ class PosixProcess():
             if "Address already in use" in e:
                 self.lasterror = True
                 return self.lasterror
-        except AttributeError: pass
+        except AttributeError:
+            pass
         if os.path.exists(self.pidpath):
             # Make sure it is not a "stale" pidFile
             try:
@@ -1264,7 +1310,8 @@ class PosixProcess():
                 fp = open(self.pidpath, 'w')
                 fp.write(str(os.getpid()))
                 fp.close()
-            except: pass
+            except:
+                pass
 
         return self.lasterror
 

core/synchronousdeluge/client.py

@@ -8,10 +8,8 @@ from exceptions import DelugeRPCError
 from protocol import DelugeRPCRequest, DelugeRPCResponse
 from transfer import DelugeTransfer
 
-
 __all__ = ["DelugeClient"]
 
-
 RPC_RESPONSE = 1
 RPC_ERROR = 2
 RPC_EVENT = 3
@@ -31,7 +29,8 @@ class DelugeClient(object):
             appDataPath = os.environ.get("APPDATA")
             if not appDataPath:
                 import _winreg
-                hkey = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders")
+                hkey = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER,
+                                       "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Shell Folders")
                 appDataReg = _winreg.QueryValueEx(hkey, "AppData")
                 appDataPath = appDataReg[0]
                 _winreg.CloseKey(hkey)
@@ -44,7 +43,6 @@ class DelugeClient(object):
             except OSError, e:
                 return username, password
 
-
         if os.path.exists(auth_file):
             for line in open(auth_file):
                 if line.startswith("#"):
@@ -160,4 +158,3 @@ class DelugeClient(object):
     def disconnect(self):
         """Disconnects from the daemon."""
         self.transfer.disconnect()
-

core/synchronousdeluge/exceptions.py

@@ -1,6 +1,7 @@
 # coding=utf-8
 __all__ = ["DelugeRPCError"]
 
+
 class DelugeRPCError(Exception):
     def __init__(self, name, msg, traceback):
         self.name = name
@@ -9,4 +10,3 @@ class DelugeRPCError(Exception):
 
     def __str__(self):
         return "{0}: {1}: {2}".format(self.__class__.__name__, self.name, self.msg)
-

core/synchronousdeluge/protocol.py

@@ -1,6 +1,7 @@
 # coding=utf-8
 __all__ = ["DelugeRPCRequest", "DelugeRPCResponse"]
 
+
 class DelugeRPCRequest(object):
     def __init__(self, request_id, method, *args, **kwargs):
         self.request_id = request_id
@@ -11,6 +12,7 @@ class DelugeRPCRequest(object):
     def format(self):
         return (self.request_id, self.method, self.args, self.kwargs)
 
+
 class DelugeRPCResponse(object):
     def __init__(self):
         self.value = None
@@ -36,4 +38,3 @@ class DelugeRPCResponse(object):
             return self.value
         else:
             raise self._exception
-

core/synchronousdeluge/rencode.py

@@ -107,6 +107,7 @@ STR_FIXED_COUNT = 64
 LIST_FIXED_START = STR_FIXED_START + STR_FIXED_COUNT
 LIST_FIXED_COUNT = 64
 
+
 def decode_int(x, f):
     f += 1
     newf = x.index(CHR_TERM, f)
@@ -123,32 +124,39 @@ def decode_int(x, f):
         raise ValueError
     return (n, newf + 1)
 
+
 def decode_intb(x, f):
     f += 1
     return (struct.unpack('!b', x[f:f + 1])[0], f + 1)
 
+
 def decode_inth(x, f):
     f += 1
     return (struct.unpack('!h', x[f:f + 2])[0], f + 2)
 
+
 def decode_intl(x, f):
     f += 1
     return (struct.unpack('!l', x[f:f + 4])[0], f + 4)
 
+
 def decode_intq(x, f):
     f += 1
     return (struct.unpack('!q', x[f:f + 8])[0], f + 8)
 
+
 def decode_float32(x, f):
     f += 1
     n = struct.unpack('!f', x[f:f + 4])[0]
     return (n, f + 4)
 
+
 def decode_float64(x, f):
     f += 1
     n = struct.unpack('!d', x[f:f + 8])[0]
     return (n, f + 8)
 
+
 def decode_string(x, f):
     colon = x.index(':', f)
     try:
@@ -167,6 +175,7 @@ def decode_string(x, f):
         pass
     return (s, colon + n)
 
+
 def decode_list(x, f):
     r, f = [], f + 1
     while x[f] != CHR_TERM:
@@ -174,6 +183,7 @@ def decode_list(x, f):
         r.append(v)
     return (tuple(r), f + 1)
 
+
 def decode_dict(x, f):
     r, f = {}, f + 1
     while x[f] != CHR_TERM:
@@ -181,15 +191,19 @@ def decode_dict(x, f):
         r[k], f = decode_func[x[f]](x, f)
     return (r, f + 1)
 
+
 def decode_true(x, f):
     return (True, f + 1)
 
+
 def decode_false(x, f):
     return (False, f + 1)
 
+
 def decode_none(x, f):
     return (None, f + 1)
 
+
 decode_func = {}
 decode_func['0'] = decode_string
 decode_func['1'] = decode_string
@@ -214,6 +228,7 @@ decode_func[CHR_TRUE   ] = decode_true
 decode_func[CHR_FALSE] = decode_false
 decode_func[CHR_NONE] = decode_none
 
+
 def make_fixed_length_string_decoders():
     def make_decoder(slen):
         def f(x, f):
@@ -225,12 +240,16 @@ def make_fixed_length_string_decoders():
             except UnicodeDecodeError:
                 pass
             return (s, f + 1 + slen)
+
         return f
+
     for i in range(STR_FIXED_COUNT):
         decode_func[chr(STR_FIXED_START + i)] = make_decoder(i)
 
+
 make_fixed_length_string_decoders()
 
+
 def make_fixed_length_list_decoders():
     def make_decoder(slen):
         def f(x, f):
@@ -239,24 +258,32 @@ def make_fixed_length_list_decoders():
                 v, f = decode_func[x[f]](x, f)
                 r.append(v)
             return (tuple(r), f)
+
         return f
+
     for i in range(LIST_FIXED_COUNT):
         decode_func[chr(LIST_FIXED_START + i)] = make_decoder(i)
 
+
 make_fixed_length_list_decoders()
 
+
 def make_fixed_length_int_decoders():
     def make_decoder(j):
         def f(x, f):
             return (j, f + 1)
+
         return f
+
     for i in range(INT_POS_FIXED_COUNT):
         decode_func[chr(INT_POS_FIXED_START + i)] = make_decoder(i)
     for i in range(INT_NEG_FIXED_COUNT):
         decode_func[chr(INT_NEG_FIXED_START + i)] = make_decoder(-1 - i)
 
+
 make_fixed_length_int_decoders()
 
+
 def make_fixed_length_dict_decoders():
     def make_decoder(slen):
         def f(x, f):
@@ -265,12 +292,16 @@ def make_fixed_length_dict_decoders():
                 k, f = decode_func[x[f]](x, f)
                 r[k], f = decode_func[x[f]](x, f)
             return (r, f)
+
         return f
+
     for i in range(DICT_FIXED_COUNT):
         decode_func[chr(DICT_FIXED_START + i)] = make_decoder(i)
 
+
 make_fixed_length_dict_decoders()
 
+
 def encode_dict(x, r):
     r.append(CHR_DICT)
     for k, v in x.items():
@@ -288,8 +319,10 @@ def loads(x):
         raise ValueError
     return r
 
+
 from types import StringType, IntType, LongType, DictType, ListType, TupleType, FloatType, NoneType, UnicodeType
 
+
 def encode_int(x, r):
     if 0 <= x < INT_POS_FIXED_COUNT:
         r.append(chr(INT_POS_FIXED_START + x))
@@ -309,27 +342,34 @@ def encode_int(x, r):
             raise ValueError('overflow')
         r.extend((CHR_INT, s, CHR_TERM))
 
+
 def encode_float32(x, r):
     r.extend((CHR_FLOAT32, struct.pack('!f', x)))
 
+
 def encode_float64(x, r):
     r.extend((CHR_FLOAT64, struct.pack('!d', x)))
 
+
 def encode_bool(x, r):
     r.extend({False: CHR_FALSE, True: CHR_TRUE}[bool(x)])
 
+
 def encode_none(x, r):
     r.extend(CHR_NONE)
 
+
 def encode_string(x, r):
     if len(x) < STR_FIXED_COUNT:
         r.extend((chr(STR_FIXED_START + len(x)), x))
     else:
         r.extend((str(len(x)), ':', x))
 
+
 def encode_unicode(x, r):
     encode_string(x.encode("utf8"), r)
 
+
 def encode_list(x, r):
     if len(x) < LIST_FIXED_COUNT:
         r.append(chr(LIST_FIXED_START + len(x)))
@@ -341,6 +381,7 @@ def encode_list(x, r):
             encode_func[type(i)](i, r)
         r.append(CHR_TERM)
 
+
 def encode_dict(x, r):
     if len(x) < DICT_FIXED_COUNT:
         r.append(chr(DICT_FIXED_START + len(x)))
@@ -354,6 +395,7 @@ def encode_dict(x,r):
             encode_func[type(v)](v, r)
         r.append(CHR_TERM)
 
+
 encode_func = {}
 encode_func[IntType] = encode_int
 encode_func[LongType] = encode_int
@@ -368,10 +410,12 @@ lock = Lock()
 
 try:
     from types import BooleanType
+
     encode_func[BooleanType] = encode_bool
 except ImportError:
     pass
 
+
 def dumps(x, float_bits=DEFAULT_FLOAT_BITS):
     """
     Dump data structure to str.
@@ -392,11 +436,14 @@ def dumps(x, float_bits=DEFAULT_FLOAT_BITS):
         lock.release()
     return ''.join(r)
 
+
 def test():
     f1 = struct.unpack('!f', struct.pack('!f', 25.5))[0]
     f2 = struct.unpack('!f', struct.pack('!f', 29.3))[0]
     f3 = struct.unpack('!f', struct.pack('!f', -0.6))[0]
-    L = (({'a':15, 'bb':f1, 'ccc':f2, '':(f3,(),False,True,'')},('a',10**20),tuple(range(-100000,100000)),'b'*31,'b'*62,'b'*64,2**30,2**33,2**62,2**64,2**30,2**33,2**62,2**64,False,False, True, -1, 2, 0),)
+    L = (({'a': 15, 'bb': f1, 'ccc': f2, '': (f3, (), False, True, '')}, ('a', 10 ** 20), tuple(range(-100000, 100000)),
+          'b' * 31, 'b' * 62, 'b' * 64, 2 ** 30, 2 ** 33, 2 ** 62, 2 ** 64, 2 ** 30, 2 ** 33, 2 ** 62, 2 ** 64, False,
+          False, True, -1, 2, 0),)
     assert loads(dumps(L)) == L
     d = dict(zip(range(-100000, 100000), range(-100000, 100000)))
     d.update({'a': 20, 20: 40, 40: 41, f1: f2, f2: f3, f3: False, False: True, True: False})
@@ -420,13 +467,15 @@ def test():
     assert 1e-10 < abs(loads(dumps(1.1, 32)) - 1.1) < 1e-6
     assert abs(loads(dumps(1.1, 64)) - 1.1) < 1e-12
     assert loads(dumps(u"Hello World!!"))
+
+
 try:
     import psyco
+
     psyco.bind(dumps)
     psyco.bind(loads)
 except ImportError:
     pass
 
-
 if __name__ == '__main__':
     test()

core/synchronousdeluge/transfer.py

@@ -6,9 +6,9 @@ import ssl
 
 from core.synchronousdeluge import rencode
 
-
 __all__ = ["DelugeTransfer"]
 
+
 class DelugeTransfer(object):
     def __init__(self):
         self.sock = None
@@ -54,5 +54,3 @@ class DelugeTransfer(object):
                 buf = dobj.unused_data
 
             yield message
-
-

core/transcoder/transcoder.py

@@ -12,6 +12,7 @@ import re
 from core import logger
 from core.nzbToMediaUtil import makeDir
 
+
 def isVideoGood(videofile, status):
     fileNameExt = os.path.basename(videofile)
     fileName, fileExt = os.path.splitext(fileNameExt)
@@ -28,7 +29,8 @@ def isVideoGood(videofile, status):
             audStreams = [item for item in test_details["streams"] if item["codec_type"] == "audio"]
             if not (len(vidStreams) > 0 and len(audStreams) > 0):
                 disable = True
-                logger.info("DISABLED: ffprobe failed to analyse streams from test file. Stopping corruption check.", 'TRANSCODER')
+                logger.info("DISABLED: ffprobe failed to analyse streams from test file. Stopping corruption check.",
+                            'TRANSCODER')
     if disable:
         if status:  # if the download was "failed", assume bad. If it was successful, assume good.
             return False
@@ -51,9 +53,11 @@ def isVideoGood(videofile, status):
             logger.info("SUCCESS: [%s] has no corruption." % (fileNameExt), 'TRANSCODER')
             return True
         else:
-            logger.info("FAILED: [%s] has %s video streams and %s audio streams. Assume corruption." % (fileNameExt, str(len(videoStreams)), str(len(audioStreams))), 'TRANSCODER')
+            logger.info("FAILED: [%s] has %s video streams and %s audio streams. Assume corruption." % (
+                fileNameExt, str(len(videoStreams)), str(len(audioStreams))), 'TRANSCODER')
             return False
 
+
 def zip_out(file, img, bitbucket):
     procin = None
     cmd = [core.SEVENZIP, '-so', 'e', img, file]
@@ -63,6 +67,7 @@ def zip_out(file, img, bitbucket):
         logger.error("Extracting [%s] has failed" % (file), 'TRANSCODER')
     return procin
 
+
 def getVideoDetails(videofile, img=None, bitbucket=None):
     video_details = {}
     result = 1
@@ -76,7 +81,8 @@ def getVideoDetails(videofile, img=None, bitbucket=None):
     try:
         if img:
             videofile = '-'
-        command = [core.FFPROBE, '-v', 'quiet', print_format, 'json', '-show_format', '-show_streams', '-show_error', videofile]
+        command = [core.FFPROBE, '-v', 'quiet', print_format, 'json', '-show_format', '-show_streams', '-show_error',
+                   videofile]
         print_cmd(command)
         if img:
             procin = zip_out(file, img, bitbucket)
@@ -87,7 +93,8 @@ def getVideoDetails(videofile, img=None, bitbucket=None):
         out, err = proc.communicate()
         result = proc.returncode
         video_details = json.loads(out)
-    except: pass
+    except:
+        pass
     if not video_details:
         try:
             command = [core.FFPROBE, '-v', 'quiet', print_format, 'json', '-show_format', '-show_streams', videofile]
@@ -104,6 +111,7 @@ def getVideoDetails(videofile, img=None, bitbucket=None):
             logger.error("Checking [%s] has failed" % (file), 'TRANSCODER')
     return video_details, result
 
+
 def buildCommands(file, newDir, movieName, bitbucket):
     if isinstance(file, str):
         inputFile = file
@@ -139,7 +147,8 @@ def buildCommands(file, newDir, movieName, bitbucket):
     meta_cmd = []
     other_cmd = []
 
-    if not video_details or not video_details.get("streams"):  # we couldn't read streams with ffprobe. Set defaults to try transcoding.
+    if not video_details or not video_details.get(
+            "streams"):  # we couldn't read streams with ffprobe. Set defaults to try transcoding.
         videoStreams = []
         audioStreams = []
         subStreams = []
@@ -166,7 +175,8 @@ def buildCommands(file, newDir, movieName, bitbucket):
 
         if core.ACODEC:
             audio_cmd.extend(['-c:a', core.ACODEC])
-            if core.ACODEC in ['aac', 'dts']: # Allow users to use the experimental AAC codec that's built into recent versions of ffmpeg
+            if core.ACODEC in ['aac',
+                               'dts']:  # Allow users to use the experimental AAC codec that's built into recent versions of ffmpeg
                 audio_cmd.extend(['-strict', '-2'])
         else:
             audio_cmd.extend(['-c:a', 'copy'])
@@ -192,23 +202,29 @@ def buildCommands(file, newDir, movieName, bitbucket):
         audioStreams = [item for item in video_details["streams"] if item["codec_type"] == "audio"]
         subStreams = [item for item in video_details["streams"] if item["codec_type"] == "subtitle"]
         if core.VEXTENSION not in ['.mkv', '.mpegts']:
-            subStreams = [item for item in video_details["streams"] if item["codec_type"] == "subtitle" and item["codec_name"] != "hdmv_pgs_subtitle" and item["codec_name"] != "pgssub"]
+            subStreams = [item for item in video_details["streams"] if
+                          item["codec_type"] == "subtitle" and item["codec_name"] != "hdmv_pgs_subtitle" and item[
+                              "codec_name"] != "pgssub"]
 
     for video in videoStreams:
         codec = video["codec_name"]
         try:
             fr = video["avg_frame_rate"]
-        except: fr = 0
+        except:
+            fr = 0
         try:
             width = video["width"]
-        except: width = 0
+        except:
+            width = 0
         try:
             height = video["height"]
-        except: height = 0
+        except:
+            height = 0
         scale = core.VRESOLUTION
         try:
             framerate = float(fr.split('/')[0]) / float(fr.split('/')[1])
-        except: framerate = 0
+        except:
+            framerate = 0
         if codec in core.VCODEC_ALLOW or not core.VCODEC:
             video_cmd.extend(['-c:v', 'copy'])
         else:
@@ -260,20 +276,24 @@ def buildCommands(file, newDir, movieName, bitbucket):
             a_mapped.extend([audio2[0]["index"]])
             try:
                 bitrate = int(audio2[0]["bit_rate"]) / 1000
-            except: bitrate = 0
+            except:
+                bitrate = 0
             try:
                 channels = int(audio2[0]["channels"])
-            except: channels = 0
+            except:
+                channels = 0
             audio_cmd.extend(['-c:a:' + str(used_audio), 'copy'])
         elif audio1:  # right language wrong codec.
             map_cmd.extend(['-map', '0:' + str(audio1[0]["index"])])
             a_mapped.extend([audio1[0]["index"]])
             try:
                 bitrate = int(audio1[0]["bit_rate"]) / 1000
-            except: bitrate = 0
+            except:
+                bitrate = 0
             try:
                 channels = int(audio1[0]["channels"])
-            except: channels = 0
+            except:
+                channels = 0
             if core.ACODEC:
                 audio_cmd.extend(['-c:a:' + str(used_audio), core.ACODEC])
             else:
@@ -283,10 +303,12 @@ def buildCommands(file, newDir, movieName, bitbucket):
             a_mapped.extend([audio3[0]["index"]])
             try:
                 bitrate = int(audio3[0]["bit_rate"]) / 1000
-            except: bitrate = 0
+            except:
+                bitrate = 0
             try:
                 channels = int(audio3[0]["channels"])
-            except: channels = 0
+            except:
+                channels = 0
             if core.ACODEC:
                 audio_cmd.extend(['-c:a:' + str(used_audio), core.ACODEC])
             else:
@@ -315,20 +337,24 @@ def buildCommands(file, newDir, movieName, bitbucket):
                 a_mapped.extend([audio4[0]["index"]])
                 try:
                     bitrate = int(audio4[0]["bit_rate"]) / 1000
-                except: bitrate = 0
+                except:
+                    bitrate = 0
                 try:
                     channels = int(audio4[0]["channels"])
-                except: channels = 0
+                except:
+                    channels = 0
                 audio_cmd2.extend(['-c:a:' + str(used_audio), 'copy'])
             elif audio1:  # right language wrong codec.
                 map_cmd.extend(['-map', '0:' + str(audio1[0]["index"])])
                 a_mapped.extend([audio1[0]["index"]])
                 try:
                     bitrate = int(audio1[0]["bit_rate"]) / 1000
-                except: bitrate = 0
+                except:
+                    bitrate = 0
                 try:
                     channels = int(audio1[0]["channels"])
-                except: channels = 0
+                except:
+                    channels = 0
                 if core.ACODEC2:
                     audio_cmd2.extend(['-c:a:' + str(used_audio), core.ACODEC2])
                 else:
@@ -338,10 +364,12 @@ def buildCommands(file, newDir, movieName, bitbucket):
                 a_mapped.extend([audio3[0]["index"]])
                 try:
                     bitrate = int(audio3[0]["bit_rate"]) / 1000
-                except: bitrate = 0
+                except:
+                    bitrate = 0
                 try:
                     channels = int(audio3[0]["channels"])
-                except: channels = 0
+                except:
+                    channels = 0
                 if core.ACODEC2:
                     audio_cmd2.extend(['-c:a:' + str(used_audio), core.ACODEC2])
                 else:
@@ -372,10 +400,12 @@ def buildCommands(file, newDir, movieName, bitbucket):
                 audio_cmd3 = []
                 try:
                     bitrate = int(audio["bit_rate"]) / 1000
-                except: bitrate = 0
+                except:
+                    bitrate = 0
                 try:
                     channels = int(audio["channels"])
-                except: channels = 0
+                except:
+                    channels = 0
                 if audio["codec_name"] in core.ACODEC3_ALLOW:
                     audio_cmd3.extend(['-c:a:' + str(used_audio), 'copy'])
                 else:
@@ -407,7 +437,8 @@ def buildCommands(file, newDir, movieName, bitbucket):
     for lan in core.SLANGUAGES:
         try:
             subs1 = [item for item in subStreams if item["tags"]["language"] == lan]
-        except: subs1 = []
+        except:
+            subs1 = []
         if core.BURN and not subs1 and not burnt and os.path.isfile(file):
             for subfile in get_subs(file):
                 if lan in os.path.split(subfile)[1]:
@@ -478,6 +509,7 @@ def buildCommands(file, newDir, movieName, bitbucket):
         command = core.NICENESS + command
     return command
 
+
 def get_subs(file):
     filepaths = []
     subExt = ['.srt', '.sub', '.idx']
@@ -489,6 +521,7 @@ def get_subs(file):
     subfiles = [item for item in filepaths if os.path.splitext(item)[1] in subExt and name in item]
     return subfiles
 
+
 def extract_subs(file, newfilePath, bitbucket):
     video_details, result = getVideoDetails(file)
     if not video_details:
@@ -501,9 +534,13 @@ def extract_subs(file, newfilePath, bitbucket):
     name = os.path.splitext(os.path.split(newfilePath)[1])[0]
 
     try:
-        subStreams = [item for item in video_details["streams"] if item["codec_type"] == "subtitle" and item["tags"]["language"] in core.SLANGUAGES and item["codec_name"] != "hdmv_pgs_subtitle" and item["codec_name"] != "pgssub"]
+        subStreams = [item for item in video_details["streams"] if
+                      item["codec_type"] == "subtitle" and item["tags"]["language"] in core.SLANGUAGES and item[
+                          "codec_name"] != "hdmv_pgs_subtitle" and item["codec_name"] != "pgssub"]
     except:
-        subStreams = [item for item in video_details["streams"] if item["codec_type"] == "subtitle" and item["codec_name"] != "hdmv_pgs_subtitle" and item["codec_name"] != "pgssub"]
+        subStreams = [item for item in video_details["streams"] if
+                      item["codec_type"] == "subtitle" and item["codec_name"] != "hdmv_pgs_subtitle" and item[
+                          "codec_name"] != "pgssub"]
     num = len(subStreams)
     for n in range(num):
         sub = subStreams[n]
@@ -522,7 +559,8 @@ def extract_subs(file, newfilePath, bitbucket):
             if os.path.isfile(outputFile):
                 outputFile = os.path.join(subdir, "%s.%s.%s.srt" % (name, lan, n))
 
-        command = [core.FFMPEG, '-loglevel', 'warning', '-i', file, '-vn', '-an', '-codec:' + str(idx), 'srt', outputFile]
+        command = [core.FFMPEG, '-loglevel', 'warning', '-i', file, '-vn', '-an', '-codec:' + str(idx), 'srt',
+                   outputFile]
         if platform.system() != 'Windows':
             command = core.NICENESS + command
 
@@ -539,11 +577,13 @@ def extract_subs(file, newfilePath, bitbucket):
         if result == 0:
             try:
                 shutil.copymode(file, outputFile)
-            except: pass
+            except:
+                pass
             logger.info("Extracting %s subtitle from %s has succeeded" % (lan, file))
         else:
             logger.error("Extracting subtitles has failed")
 
+
 def processList(List, newDir, bitbucket):
     remList = []
     newList = []
@@ -571,7 +611,8 @@ def processList(List, newDir, bitbucket):
         elif core.CONCAT and re.match(".+[cC][dD][0-9].", item):
             remList.append(item)
             combine.append(item)
-        else: continue     
+        else:
+            continue
     if vtsPath:
         newList.extend(combineVTS(vtsPath))
     if combine:
@@ -591,6 +632,7 @@ def processList(List, newDir, bitbucket):
         logger.error("Failed extracting .vob files from disk image. Stopping transcoding.", "TRANSCODER")
     return List, remList, newList, success
 
+
 def ripISO(item, newDir, bitbucket):
     newFiles = []
     failure_dir = 'failure'
@@ -606,7 +648,8 @@ def ripISO(item, newDir, bitbucket):
         proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=bitbucket)
         out, err = proc.communicate()
         result = proc.returncode
-        fileList = [ re.match(".+(VIDEO_TS[\\\/]VTS_[0-9][0-9]_[0-9].[Vv][Oo][Bb])", line).groups()[0] for line in out.splitlines() if re.match(".+VIDEO_TS[\\\/]VTS_[0-9][0-9]_[0-9].[Vv][Oo][Bb]", line) ]
+        fileList = [re.match(".+(VIDEO_TS[\\\/]VTS_[0-9][0-9]_[0-9].[Vv][Oo][Bb])", line).groups()[0] for line in
+                    out.splitlines() if re.match(".+VIDEO_TS[\\\/]VTS_[0-9][0-9]_[0-9].[Vv][Oo][Bb]", line)]
         combined = []
         for n in range(99):
             concat = []
@@ -636,6 +679,7 @@ def ripISO(item, newDir, bitbucket):
         newFiles = [failure_dir]
     return newFiles
 
+
 def combineVTS(vtsPath):
     newFiles = []
     combined = ''
@@ -659,12 +703,14 @@ def combineVTS(vtsPath):
         newFiles.append('concat:%s' % combined[:-1])
     return newFiles
 
+
 def combineCD(combine):
     newFiles = []
     for item in set([re.match("(.+)[cC][dD][0-9].", item).groups()[0] for item in combine]):
         concat = ''
         for n in range(99):
-            files = [ file for file in combine if n+1 == int(re.match(".+[cC][dD]([0-9]+).",file).groups()[0]) and item in file ] 
+            files = [file for file in combine if
+                     n + 1 == int(re.match(".+[cC][dD]([0-9]+).", file).groups()[0]) and item in file]
             if files:
                 concat = concat + files[0] + '|'
             else:
@@ -673,12 +719,14 @@ def combineCD(combine):
             newFiles.append('concat:%s' % concat[:-1])
     return newFiles
 
+
 def print_cmd(command):
     cmd = ""
     for item in command:
         cmd = cmd + " " + str(item)
     logger.debug("calling command:%s" % (cmd))
 
+
 def Transcode_directory(dirName):
     if not core.FFMPEG:
         return 1, dirName
@@ -752,12 +800,14 @@ def Transcode_directory(dirName):
         if result == 0:
             try:
                 shutil.copymode(file, newfilePath)
-            except: pass
+            except:
+                pass
             logger.info("Transcoding of video to %s succeeded" % (newfilePath))
             if os.path.isfile(newfilePath) and (file in newList or not core.DUPLICATE):
                 try:
                     os.unlink(file)
-                except: pass 
+                except:
+                    pass
         else:
             logger.error("Transcoding of video to %s failed with result %s" % (newfilePath, str(result)))
         # this will be 0 (successful) it all are successful, else will return a positive integer for failure.
@@ -766,7 +816,8 @@ def Transcode_directory(dirName):
         for file in remList:
             try:
                 os.unlink(file)
-            except: pass
+            except:
+                pass
     if not os.listdir(newDir):  # this is an empty directory and we didn't transcode into it.
         os.rmdir(newDir)
         newDir = dirName

core/transmissionrpc/client.py

@@ -18,7 +18,6 @@ from core.transmissionrpc.torrent import Torrent
 from core.transmissionrpc.session import Session
 from six import PY3, integer_types, string_types, iteritems
 
-
 if PY3:
     from urllib.parse import urlparse
     from urllib.request import urlopen
@@ -26,6 +25,7 @@ else:
     from urlparse import urlparse
     from urllib2 import urlopen
 
+
 def debug_httperror(error):
     """
     Log the Transmission RPC HTTP error.
@@ -49,6 +49,7 @@ def debug_httperror(error):
         )
     )
 
+
 def parse_torrent_id(arg):
     """Parse an torrent id or torrent hashString."""
     torrent_id = None
@@ -75,6 +76,7 @@ def parse_torrent_id(arg):
                 pass
     return torrent_id
 
+
 def parse_torrent_ids(args):
     """
     Take things and make them valid torrent identifiers
@@ -115,6 +117,7 @@ def parse_torrent_ids(args):
             ids = [torrent_id]
     return ids
 
+
 """
 Torrent ids
 
@@ -129,12 +132,14 @@ possible to provide a argument called ``timeout``. Timeout is only effective
 when using Python 2.6 or later and the default timeout is 30 seconds.
 """
 
+
 class Client(object):
     """
     Client is the class handling the Transmission JSON-RPC client protocol.
     """
 
-    def __init__(self, address='localhost', port=DEFAULT_PORT, user=None, password=None, http_handler=None, timeout=None):
+    def __init__(self, address='localhost', port=DEFAULT_PORT, user=None, password=None, http_handler=None,
+                 timeout=None):
         if isinstance(timeout, (integer_types, float)):
             self._query_timeout = float(timeout)
         else:
@@ -204,7 +209,8 @@ class Client(object):
         if timeout is None:
             timeout = self._query_timeout
         while True:
-            LOGGER.debug(json.dumps({'url': self.url, 'headers': headers, 'query': query, 'timeout': timeout}, indent=2))
+            LOGGER.debug(
+                json.dumps({'url': self.url, 'headers': headers, 'query': query, 'timeout': timeout}, indent=2))
             try:
                 result = self.http_handler.request(self.url, query, headers, timeout)
                 break
@@ -244,8 +250,7 @@ class Client(object):
         elif require_ids:
             raise ValueError('request require ids')
 
-        query = json.dumps({'tag': self._sequence, 'method': method
+        query = json.dumps({'tag': self._sequence, 'method': method, 'arguments': arguments})
-                            , 'arguments': arguments})
         self._sequence += 1
         start = time.time()
         http_data = self._http_query(query, timeout)
@@ -606,9 +611,9 @@ class Client(object):
             the new methods. list returns a dictionary indexed by torrent id.
         """
         warnings.warn('list has been deprecated, please use get_torrent or get_torrents instead.', DeprecationWarning)
-        fields = ['id', 'hashString', 'name', 'sizeWhenDone', 'leftUntilDone'
+        fields = ['id', 'hashString', 'name', 'sizeWhenDone', 'leftUntilDone',
-            , 'eta', 'status', 'rateUpload', 'rateDownload', 'uploadedEver'
+                  'eta', 'status', 'rateUpload', 'rateDownload', 'uploadedEver',
-            , 'downloadedEver', 'uploadRatio', 'queuePosition']
+                  'downloadedEver', 'uploadRatio', 'queuePosition']
         return self._request('torrent-get', {'fields': fields}, timeout=timeout)
 
     def get_files(self, ids=None, timeout=None):

core/transmissionrpc/constants.py

@@ -6,10 +6,10 @@ import logging
 
 from core.transmissionrpc.six import iteritems
 
-
 LOGGER = logging.getLogger('transmissionrpc')
 LOGGER.setLevel(logging.ERROR)
 
+
 def mirror_dict(source):
     """
     Creates a dictionary with all values as keys and all keys as values.
@@ -17,6 +17,7 @@ def mirror_dict(source):
     source.update(dict((value, key) for key, value in iteritems(source)))
     return source
 
+
 DEFAULT_PORT = 9091
 
 DEFAULT_TIMEOUT = 30.0
@@ -79,13 +80,19 @@ TORRENT_ARGS = {
         'downloaders': ('number', 4, 7, None, None, 'Number of downloaders.'),
         'downloadLimit': ('number', 1, None, None, None, 'Download limit in Kbps.'),
         'downloadLimited': ('boolean', 5, None, None, None, 'Download limit is enabled'),
-        'downloadLimitMode':            ('number', 1, 5, None, None, 'Download limit mode. 0 means global, 1 means signle, 2 unlimited.'),
+        'downloadLimitMode': (
-        'error':                        ('number', 1, None, None, None, 'Kind of error. 0 means OK, 1 means tracker warning, 2 means tracker error, 3 means local error.'),
+            'number', 1, 5, None, None, 'Download limit mode. 0 means global, 1 means signle, 2 unlimited.'),
+        'error': ('number', 1, None, None, None,
+                  'Kind of error. 0 means OK, 1 means tracker warning, 2 means tracker error, 3 means local error.'),
         'errorString': ('number', 1, None, None, None, 'Error message.'),
-        'eta':                          ('number', 1, None, None, None, 'Estimated number of seconds left when downloading or seeding. -1 means not available and -2 means unknown.'),
+        'eta': ('number', 1, None, None, None,
-        'etaIdle':                      ('number', 15, None, None, None, 'Estimated number of seconds left until the idle time limit is reached. -1 means not available and -2 means unknown.'),        
+                'Estimated number of seconds left when downloading or seeding. -1 means not available and -2 means unknown.'),
-        'files':                        ('array', 1, None, None, None, 'Array of file object containing key, bytesCompleted, length and name.'),
+        'etaIdle': ('number', 15, None, None, None,
-        'fileStats':                    ('array', 5, None, None, None, 'Aray of file statistics containing bytesCompleted, wanted and priority.'),
+                    'Estimated number of seconds left until the idle time limit is reached. -1 means not available and -2 means unknown.'),
+        'files': (
+            'array', 1, None, None, None, 'Array of file object containing key, bytesCompleted, length and name.'),
+        'fileStats': (
+            'array', 5, None, None, None, 'Aray of file statistics containing bytesCompleted, wanted and priority.'),
         'hashString': ('string', 1, None, None, None, 'Hashstring unique for the torrent even between sessions.'),
         'haveUnchecked': ('number', 1, None, None, None, 'Number of bytes of partial pieces.'),
         'haveValid': ('number', 1, None, None, None, 'Number of bytes of checksum verified data.'),
@@ -108,7 +115,8 @@ TORRENT_ARGS = {
         'peer-limit': ('number', 5, None, None, None, 'Maximum number of peers.'),
         'peers': ('array', 2, None, None, None, 'Array of peer objects.'),
         'peersConnected': ('number', 1, None, None, None, 'Number of peers we are connected to.'),
-        'peersFrom':                    ('object', 1, None, None, None, 'Object containing download peers counts for different peer types.'),
+        'peersFrom': (
+            'object', 1, None, None, None, 'Object containing download peers counts for different peer types.'),
         'peersGettingFromUs': ('number', 1, None, None, None, 'Number of peers we are sending data to.'),
         'peersKnown': ('number', 1, 13, None, None, 'Number of peers that the tracker knows.'),
         'peersSendingToUs': ('number', 1, None, None, None, 'Number of peers sending to us'),
@@ -141,7 +149,8 @@ TORRENT_ARGS = {
         'torrentFile': ('string', 5, None, None, None, 'Path to .torrent file.'),
         'uploadedEver': ('number', 1, None, None, None, 'Number of bytes uploaded, ever.'),
         'uploadLimit': ('number', 1, None, None, None, 'Upload limit in Kbps'),
-        'uploadLimitMode':              ('number', 1, 5, None, None, 'Upload limit mode. 0 means global, 1 means signle, 2 unlimited.'),
+        'uploadLimitMode': (
+            'number', 1, 5, None, None, 'Upload limit mode. 0 means global, 1 means signle, 2 unlimited.'),
         'uploadLimited': ('boolean', 5, None, None, None, 'Upload limit enabled.'),
         'uploadRatio': ('double', 1, None, None, None, 'Seed ratio.'),
         'wanted': ('array', 1, None, None, None, 'Array of booleans indicated wanted files.'),
@@ -154,7 +163,8 @@ TORRENT_ARGS = {
         'downloadLimited': ('boolean', 5, None, 'speed-limit-down-enabled', None, 'Enable download speed limiter.'),
         'files-wanted': ('array', 1, None, None, None, "A list of file id's that should be downloaded."),
         'files-unwanted': ('array', 1, None, None, None, "A list of file id's that shouldn't be downloaded."),
-        'honorsSessionLimits':          ('boolean', 5, None, None, None, "Enables or disables the transfer to honour the upload limit set in the session."),
+        'honorsSessionLimits': ('boolean', 5, None, None, None,
+                                "Enables or disables the transfer to honour the upload limit set in the session."),
         'location': ('array', 1, None, None, None, 'Local download location.'),
         'peer-limit': ('number', 1, None, None, None, 'The peer limit for the torrents.'),
         'priority-high': ('array', 1, None, None, None, "A list of file id's that should have high priority."),
@@ -162,22 +172,26 @@ TORRENT_ARGS = {
         'priority-normal': ('array', 1, None, None, None, "A list of file id's that should have low priority."),
         'queuePosition': ('number', 14, None, None, None, 'Position of this transfer in its queue.'),
         'seedIdleLimit': ('number', 10, None, None, None, 'Seed inactivity limit in minutes.'),
-        'seedIdleMode':                 ('number', 10, None, None, None, 'Seed inactivity mode. 0 = Use session limit, 1 = Use transfer limit, 2 = Disable limit.'),
+        'seedIdleMode': ('number', 10, None, None, None,
+                         'Seed inactivity mode. 0 = Use session limit, 1 = Use transfer limit, 2 = Disable limit.'),
         'seedRatioLimit': ('double', 5, None, None, None, 'Seeding ratio.'),
-        'seedRatioMode':                ('number', 5, None, None, None, 'Which ratio to use. 0 = Use session limit, 1 = Use transfer limit, 2 = Disable limit.'),
+        'seedRatioMode': ('number', 5, None, None, None,
+                          'Which ratio to use. 0 = Use session limit, 1 = Use transfer limit, 2 = Disable limit.'),
         'speed-limit-down': ('number', 1, 5, None, 'downloadLimit', 'Set the speed limit for download in Kib/s.'),
         'speed-limit-down-enabled': ('boolean', 1, 5, None, 'downloadLimited', 'Enable download speed limiter.'),
         'speed-limit-up': ('number', 1, 5, None, 'uploadLimit', 'Set the speed limit for upload in Kib/s.'),
         'speed-limit-up-enabled': ('boolean', 1, 5, None, 'uploadLimited', 'Enable upload speed limiter.'),
         'trackerAdd': ('array', 10, None, None, None, 'Array of string with announce URLs to add.'),
         'trackerRemove': ('array', 10, None, None, None, 'Array of ids of trackers to remove.'),
-        'trackerReplace':               ('array', 10, None, None, None, 'Array of (id, url) tuples where the announce URL should be replaced.'),
+        'trackerReplace': (
+            'array', 10, None, None, None, 'Array of (id, url) tuples where the announce URL should be replaced.'),
         'uploadLimit': ('number', 5, None, 'speed-limit-up', None, 'Set the speed limit for upload in Kib/s.'),
         'uploadLimited': ('boolean', 5, None, 'speed-limit-up-enabled', None, 'Enable upload speed limiter.'),
     },
     'add': {
         'bandwidthPriority': ('number', 8, None, None, None, 'Priority for this transfer.'),
-        'download-dir':                 ('string', 1, None, None, None, 'The directory where the downloaded contents will be saved in.'),
+        'download-dir': (
+            'string', 1, None, None, None, 'The directory where the downloaded contents will be saved in.'),
         'cookies': ('string', 13, None, None, None, 'One or more HTTP cookie(s).'),
         'filename': ('string', 1, None, None, None, "A file path or URL to a torrent file or a magnet link."),
         'files-wanted': ('array', 1, None, None, None, "A list of file id's that should be downloaded."),
@@ -195,10 +209,13 @@ TORRENT_ARGS = {
 SESSION_ARGS = {
     'get': {
         "alt-speed-down": ('number', 5, None, None, None, 'Alternate session download speed limit (in Kib/s).'),
-        "alt-speed-enabled":            ('boolean', 5, None, None, None, 'True if alternate global download speed limiter is ebabled.'),
+        "alt-speed-enabled": (
-        "alt-speed-time-begin":         ('number', 5, None, None, None, 'Time when alternate speeds should be enabled. Minutes after midnight.'),
+            'boolean', 5, None, None, None, 'True if alternate global download speed limiter is ebabled.'),
+        "alt-speed-time-begin": (
+            'number', 5, None, None, None, 'Time when alternate speeds should be enabled. Minutes after midnight.'),
         "alt-speed-time-enabled": ('boolean', 5, None, None, None, 'True if alternate speeds scheduling is enabled.'),
-        "alt-speed-time-end":           ('number', 5, None, None, None, 'Time when alternate speeds should be disabled. Minutes after midnight.'),
+        "alt-speed-time-end": (
+            'number', 5, None, None, None, 'Time when alternate speeds should be disabled. Minutes after midnight.'),
         "alt-speed-time-day": ('number', 5, None, None, None, 'Days alternate speeds scheduling is enabled.'),
         "alt-speed-up": ('number', 5, None, None, None, 'Alternate session upload speed limit (in Kib/s)'),
         "blocklist-enabled": ('boolean', 5, None, None, None, 'True when blocklist is enabled.'),
@@ -211,10 +228,12 @@ SESSION_ARGS = {
         "download-dir-free-space": ('number', 12, None, None, None, 'Free space in the download directory, in bytes'),
         "download-queue-size": ('number', 14, None, None, None, 'Number of slots in the download queue.'),
         "download-queue-enabled": ('boolean', 14, None, None, None, 'True if the download queue is enabled.'),
-        "encryption":                   ('string', 1, None, None, None, 'Encryption mode, one of ``required``, ``preferred`` or ``tolerated``.'),
+        "encryption": (
+            'string', 1, None, None, None, 'Encryption mode, one of ``required``, ``preferred`` or ``tolerated``.'),
         "idle-seeding-limit": ('number', 10, None, None, None, 'Seed inactivity limit in minutes.'),
         "idle-seeding-limit-enabled": ('boolean', 10, None, None, None, 'True if the seed activity limit is enabled.'),
-        "incomplete-dir":               ('string', 7, None, None, None, 'The path to the directory for incomplete torrent transfer data.'),
+        "incomplete-dir": (
+            'string', 7, None, None, None, 'The path to the directory for incomplete torrent transfer data.'),
         "incomplete-dir-enabled": ('boolean', 7, None, None, None, 'True if the incomplete dir is enabled.'),
         "lpd-enabled": ('boolean', 9, None, None, None, 'True if local peer discovery is enabled.'),
         "peer-limit": ('number', 1, 5, None, 'peer-limit-global', 'Maximum number of peers.'),
@@ -224,15 +243,18 @@ SESSION_ARGS = {
         "pex-enabled": ('boolean', 5, None, 'pex-allowed', None, 'True if PEX is enabled.'),
         "port": ('number', 1, 5, None, 'peer-port', 'Peer port.'),
         "peer-port": ('number', 5, None, 'port', None, 'Peer port.'),
-        "peer-port-random-on-start":    ('boolean', 5, None, None, None, 'Enables randomized peer port on start of Transmission.'),
+        "peer-port-random-on-start": (
+            'boolean', 5, None, None, None, 'Enables randomized peer port on start of Transmission.'),
         "port-forwarding-enabled": ('boolean', 1, None, None, None, 'True if port forwarding is enabled.'),
-        "queue-stalled-minutes":        ('number', 14, None, None, None, 'Number of minutes of idle that marks a transfer as stalled.'),
+        "queue-stalled-minutes": (
+            'number', 14, None, None, None, 'Number of minutes of idle that marks a transfer as stalled.'),
         "queue-stalled-enabled": ('boolean', 14, None, None, None, 'True if stalled tracking of transfers is enabled.'),
         "rename-partial-files": ('boolean', 8, None, None, None, 'True if ".part" is appended to incomplete files'),
         "rpc-version": ('number', 4, None, None, None, 'Transmission RPC API Version.'),
         "rpc-version-minimum": ('number', 4, None, None, None, 'Minimum accepted RPC API Version.'),
         "script-torrent-done-enabled": ('boolean', 9, None, None, None, 'True if the done script is enabled.'),
-        "script-torrent-done-filename": ('string', 9, None, None, None, 'Filename of the script to run when the transfer is done.'),
+        "script-torrent-done-filename": (
+            'string', 9, None, None, None, 'Filename of the script to run when the transfer is done.'),
         "seedRatioLimit": ('double', 5, None, None, None, 'Seed ratio limit. 1.0 means 1:1 download and upload ratio.'),
         "seedRatioLimited": ('boolean', 5, None, None, None, 'True if seed ration limit is enabled.'),
         "seed-queue-size": ('number', 14, None, None, None, 'Number of slots in the upload queue.'),
@@ -242,7 +264,8 @@ SESSION_ARGS = {
         "speed-limit-up": ('number', 1, None, None, None, 'Upload speed limit (in Kib/s).'),
         "speed-limit-up-enabled": ('boolean', 1, None, None, None, 'True if the upload speed is limited.'),
         "start-added-torrents": ('boolean', 9, None, None, None, 'When true uploaded torrents will start right away.'),
-        "trash-original-torrent-files": ('boolean', 9, None, None, None, 'When true added .torrent files will be deleted.'),
+        "trash-original-torrent-files": (
+            'boolean', 9, None, None, None, 'When true added .torrent files will be deleted.'),
         'units': ('object', 10, None, None, None, 'An object containing units for size and speed.'),
         'utp-enabled': ('boolean', 13, None, None, None, 'True if Micro Transport Protocol (UTP) is enabled.'),
         "version": ('string', 3, None, None, None, 'Transmission version.'),
@@ -250,9 +273,11 @@ SESSION_ARGS = {
     'set': {
         "alt-speed-down": ('number', 5, None, None, None, 'Alternate session download speed limit (in Kib/s).'),
         "alt-speed-enabled": ('boolean', 5, None, None, None, 'Enables alternate global download speed limiter.'),
-        "alt-speed-time-begin":         ('number', 5, None, None, None, 'Time when alternate speeds should be enabled. Minutes after midnight.'),
+        "alt-speed-time-begin": (
+            'number', 5, None, None, None, 'Time when alternate speeds should be enabled. Minutes after midnight.'),
         "alt-speed-time-enabled": ('boolean', 5, None, None, None, 'Enables alternate speeds scheduling.'),
-        "alt-speed-time-end":           ('number', 5, None, None, None, 'Time when alternate speeds should be disabled. Minutes after midnight.'),
+        "alt-speed-time-end": (
+            'number', 5, None, None, None, 'Time when alternate speeds should be disabled. Minutes after midnight.'),
         "alt-speed-time-day": ('number', 5, None, None, None, 'Enables alternate speeds scheduling these days.'),
         "alt-speed-up": ('number', 5, None, None, None, 'Alternate session upload speed limit (in Kib/s).'),
         "blocklist-enabled": ('boolean', 5, None, None, None, 'Enables the block list'),
@@ -262,11 +287,13 @@ SESSION_ARGS = {
         "download-dir": ('string', 1, None, None, None, 'Set the session download directory.'),
         "download-queue-size": ('number', 14, None, None, None, 'Number of slots in the download queue.'),
         "download-queue-enabled": ('boolean', 14, None, None, None, 'Enables download queue.'),
-        "encryption":                   ('string', 1, None, None, None, 'Set the session encryption mode, one of ``required``, ``preferred`` or ``tolerated``.'),
+        "encryption": ('string', 1, None, None, None,
+                       'Set the session encryption mode, one of ``required``, ``preferred`` or ``tolerated``.'),
         "idle-seeding-limit": ('number', 10, None, None, None, 'The default seed inactivity limit in minutes.'),
         "idle-seeding-limit-enabled": ('boolean', 10, None, None, None, 'Enables the default seed inactivity limit'),
         "incomplete-dir": ('string', 7, None, None, None, 'The path to the directory of incomplete transfer data.'),
-        "incomplete-dir-enabled":       ('boolean', 7, None, None, None, 'Enables the incomplete transfer data directory. Otherwise data for incomplete transfers are stored in the download target.'),
+        "incomplete-dir-enabled": ('boolean', 7, None, None, None,
+                                   'Enables the incomplete transfer data directory. Otherwise data for incomplete transfers are stored in the download target.'),
         "lpd-enabled": ('boolean', 9, None, None, None, 'Enables local peer discovery for public torrents.'),
         "peer-limit": ('number', 1, 5, None, 'peer-limit-global', 'Maximum number of peers.'),
         "peer-limit-global": ('number', 5, None, 'peer-limit', None, 'Maximum number of peers.'),
@@ -275,13 +302,16 @@ SESSION_ARGS = {
         "pex-enabled": ('boolean', 5, None, 'pex-allowed', None, 'Allowing PEX in public torrents.'),
         "port": ('number', 1, 5, None, 'peer-port', 'Peer port.'),
         "peer-port": ('number', 5, None, 'port', None, 'Peer port.'),
-        "peer-port-random-on-start":    ('boolean', 5, None, None, None, 'Enables randomized peer port on start of Transmission.'),
+        "peer-port-random-on-start": (
+            'boolean', 5, None, None, None, 'Enables randomized peer port on start of Transmission.'),
         "port-forwarding-enabled": ('boolean', 1, None, None, None, 'Enables port forwarding.'),
         "rename-partial-files": ('boolean', 8, None, None, None, 'Appends ".part" to incomplete files'),
-        "queue-stalled-minutes":        ('number', 14, None, None, None, 'Number of minutes of idle that marks a transfer as stalled.'),
+        "queue-stalled-minutes": (
+            'number', 14, None, None, None, 'Number of minutes of idle that marks a transfer as stalled.'),
         "queue-stalled-enabled": ('boolean', 14, None, None, None, 'Enable tracking of stalled transfers.'),
         "script-torrent-done-enabled": ('boolean', 9, None, None, None, 'Whether or not to call the "done" script.'),
-        "script-torrent-done-filename": ('string', 9, None, None, None, 'Filename of the script to run when the transfer is done.'),
+        "script-torrent-done-filename": (
+            'string', 9, None, None, None, 'Filename of the script to run when the transfer is done.'),
         "seed-queue-size": ('number', 14, None, None, None, 'Number of slots in the upload queue.'),
         "seed-queue-enabled": ('boolean', 14, None, None, None, 'Enables upload queue.'),
         "seedRatioLimit": ('double', 5, None, None, None, 'Seed ratio limit. 1.0 means 1:1 download and upload ratio.'),
@@ -291,7 +321,8 @@ SESSION_ARGS = {
         "speed-limit-up": ('number', 1, None, None, None, 'Upload speed limit (in Kib/s).'),
         "speed-limit-up-enabled": ('boolean', 1, None, None, None, 'Enables upload speed limiting.'),
         "start-added-torrents": ('boolean', 9, None, None, None, 'Added torrents will be started right away.'),
-        "trash-original-torrent-files": ('boolean', 9, None, None, None, 'The .torrent file of added torrents will be deleted.'),
+        "trash-original-torrent-files": (
+            'boolean', 9, None, None, None, 'The .torrent file of added torrents will be deleted.'),
         'utp-enabled': ('boolean', 13, None, None, None, 'Enables Micro Transport Protocol (UTP).'),
     },
 }

core/transmissionrpc/error.py

@@ -4,11 +4,13 @@
 
 from core.transmissionrpc.six import string_types, integer_types
 
+
 class TransmissionError(Exception):
     """
     This exception is raised when there has occurred an error related to
     communication with Transmission. It is a subclass of Exception.
     """
+
     def __init__(self, message='', original=None):
         Exception.__init__(self)
         self.message = message
@@ -21,11 +23,13 @@ class TransmissionError(Exception):
         else:
             return self.message
 
+
 class HTTPHandlerError(Exception):
     """
     This exception is raised when there has occurred an error related to
     the HTTP handler. It is a subclass of Exception.
     """
+
     def __init__(self, httpurl=None, httpcode=None, httpmsg=None, httpheaders=None, httpdata=None):
         Exception.__init__(self)
         self.url = ''

core/transmissionrpc/httphandler.py

@@ -18,10 +18,12 @@ else:
     from urllib2 import HTTPError, URLError
     from httplib import BadStatusLine
 
+
 class HTTPHandler(object):
     """
     Prototype for HTTP handling.
     """
+
     def set_authentication(self, uri, login, password):
         """
         Transmission use basic authentication in earlier versions and digest
@@ -44,10 +46,12 @@ class HTTPHandler(object):
         """
         raise NotImplementedError("Bad HTTPHandler, failed to implement request.")
 
+
 class DefaultHTTPHandler(HTTPHandler):
     """
     The default HTTP handler provided with transmissionrpc.
     """
+
     def __init__(self):
         HTTPHandler.__init__(self)
         self.http_opener = build_opener()

core/transmissionrpc/session.py

@@ -6,6 +6,7 @@ from core.transmissionrpc.utils import Field
 
 from core.transmissionrpc.six import iteritems, integer_types
 
+
 class Session(object):
     """
     Session is a class holding the session data for a Transmission daemon.

core/transmissionrpc/six.py

@@ -28,7 +28,6 @@ import types
 __author__ = "Benjamin Peterson <benjamin@python.org>"
 __version__ = "1.4.1"
 
-
 # Useful for very coarse version differentiation.
 PY2 = sys.version_info[0] == 2
 PY3 = sys.version_info[0] == 3
@@ -56,6 +55,8 @@ else:
         class X(object):
             def __len__(self):
                 return 1 << 31
+
+
         try:
             len(X())
         except OverflowError:
@@ -79,7 +80,6 @@ def _import_module(name):
 
 
 class _LazyDescr(object):
-
     def __init__(self, name):
         self.name = name
 
@@ -92,7 +92,6 @@ class _LazyDescr(object):
 
 
 class MovedModule(_LazyDescr):
-
     def __init__(self, name, old, new=None):
         super(MovedModule, self).__init__(name)
         if PY3:
@@ -107,7 +106,6 @@ class MovedModule(_LazyDescr):
 
 
 class MovedAttribute(_LazyDescr):
-
     def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None):
         super(MovedAttribute, self).__init__(name)
         if PY3:
@@ -131,7 +129,6 @@ class MovedAttribute(_LazyDescr):
         return getattr(module, self.attr)
 
 
-
 class _MovedItems(types.ModuleType):
     """Lazy loading of moved objects"""
 
@@ -199,7 +196,6 @@ del attr
 moves = sys.modules[__name__ + ".moves"] = _MovedItems(__name__ + ".moves")
 
 
-
 class Module_six_moves_urllib_parse(types.ModuleType):
     """Lazy loading of moved objects in six.moves.urllib_parse"""
 
@@ -320,8 +316,10 @@ for attr in _urllib_robotparser_moved_attributes:
     setattr(Module_six_moves_urllib_robotparser, attr.name, attr)
 del attr
 
-sys.modules[__name__ + ".moves.urllib_robotparser"] = Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib_robotparser")
+sys.modules[__name__ + ".moves.urllib_robotparser"] = Module_six_moves_urllib_robotparser(
-sys.modules[__name__ + ".moves.urllib.robotparser"] = Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser")
+    __name__ + ".moves.urllib_robotparser")
+sys.modules[__name__ + ".moves.urllib.robotparser"] = Module_six_moves_urllib_robotparser(
+    __name__ + ".moves.urllib.robotparser")
 
 
 class Module_six_moves_urllib(types.ModuleType):
@@ -379,7 +377,6 @@ else:
     _iteritems = "iteritems"
     _iterlists = "iterlists"
 
-
 try:
     advance_iterator = next
 except NameError:
@@ -387,18 +384,17 @@ except NameError:
         return it.next()
 next = advance_iterator
 
-
 try:
     callable = callable
 except NameError:
     def callable(obj):
         return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
 
-
 if PY3:
     def get_unbound_function(unbound):
         return unbound
 
+
     create_bound_method = types.MethodType
 
     Iterator = object
@@ -406,19 +402,21 @@ else:
     def get_unbound_function(unbound):
         return unbound.im_func
 
+
     def create_bound_method(func, obj):
         return types.MethodType(func, obj, obj.__class__)
 
+
     class Iterator(object):
 
         def next(self):
             return type(self).__next__(self)
 
+
     callable = callable
 _add_doc(get_unbound_function,
          """Get the function out of a possibly unbound function""")
 
-
 get_method_function = operator.attrgetter(_meth_func)
 get_method_self = operator.attrgetter(_meth_self)
 get_function_closure = operator.attrgetter(_func_closure)
@@ -431,14 +429,17 @@ def iterkeys(d, **kw):
     """Return an iterator over the keys of a dictionary."""
     return iter(getattr(d, _iterkeys)(**kw))
 
+
 def itervalues(d, **kw):
     """Return an iterator over the values of a dictionary."""
     return iter(getattr(d, _itervalues)(**kw))
 
+
 def iteritems(d, **kw):
     """Return an iterator over the (key, value) pairs of a dictionary."""
     return iter(getattr(d, _iteritems)(**kw))
 
+
 def iterlists(d, **kw):
     """Return an iterator over the (key, [values]) pairs of a dictionary."""
     return iter(getattr(d, _iterlists)(**kw))
@@ -447,8 +448,12 @@ def iterlists(d, **kw):
 if PY3:
     def b(s):
         return s.encode("latin-1")
+
+
     def u(s):
         return s
+
+
     unichr = chr
     if sys.version_info[1] <= 1:
         def int2byte(i):
@@ -460,29 +465,43 @@ if PY3:
     indexbytes = operator.getitem
     iterbytes = iter
     import io
+
     StringIO = io.StringIO
     BytesIO = io.BytesIO
 else:
     def b(s):
         return s
+
+
     def u(s):
         return unicode(s, "unicode_escape")
+
+
     unichr = unichr
     int2byte = chr
+
+
     def byte2int(bs):
         return ord(bs[0])
+
+
     def indexbytes(buf, i):
         return ord(buf[i])
+
+
     def iterbytes(buf):
         return (ord(byte) for byte in buf)
+
+
     import StringIO
+
     StringIO = BytesIO = StringIO.StringIO
 _add_doc(b, """Byte literal""")
 _add_doc(u, """Text literal""")
 
-
 if PY3:
     import builtins
+
     exec_ = getattr(builtins, "exec")
 
 
@@ -519,10 +538,12 @@ else:
         fp = kwargs.pop("file", sys.stdout)
         if fp is None:
             return
+
         def write(data):
             if not isinstance(data, basestring):
                 data = str(data)
             fp.write(data)
+
         want_unicode = False
         sep = kwargs.pop("sep", None)
         if sep is not None:
@@ -566,8 +587,10 @@ def with_metaclass(meta, *bases):
     """Create a base class with a metaclass."""
     return meta("NewBase", bases, {})
 
+
 def add_metaclass(metaclass):
     """Class decorator for creating a class with a metaclass."""
+
     def wrapper(cls):
         orig_vars = cls.__dict__.copy()
         orig_vars.pop('__dict__', None)
@@ -575,4 +598,5 @@ def add_metaclass(metaclass):
         for slots_var in orig_vars.get('__slots__', ()):
             orig_vars.pop(slots_var)
         return metaclass(cls.__name__, cls.__bases__, orig_vars)
+
     return wrapper

core/transmissionrpc/torrent.py

@@ -21,6 +21,7 @@ def get_status_old(code):
     }
     return mapping[code]
 
+
 def get_status_new(code):
     """Get the torrent status using new status codes"""
     mapping = {
@@ -34,6 +35,7 @@ def get_status_new(code):
     }
     return mapping[code]
 
+
 class Torrent(object):
     """
     Torrent is a class holding the data received from Transmission regarding a bittorrent transfer.
@@ -99,8 +101,9 @@ class Torrent(object):
 
     def _dirty_fields(self):
         """Enumerate changed fields"""
-        outgoing_keys = ['bandwidthPriority', 'downloadLimit', 'downloadLimited', 'peer_limit', 'queuePosition'
+        outgoing_keys = ['bandwidthPriority', 'downloadLimit', 'downloadLimited', 'peer_limit', 'queuePosition',
-            , 'seedIdleLimit', 'seedIdleMode', 'seedRatioLimit', 'seedRatioMode', 'uploadLimit', 'uploadLimited']
+                         'seedIdleLimit', 'seedIdleMode', 'seedRatioLimit', 'seedRatioMode', 'uploadLimit',
+                         'uploadLimited']
         fields = []
         for key in outgoing_keys:
             if key in self._fields and self._fields[key].dirty:
@@ -270,7 +273,8 @@ class Torrent(object):
         else:
             raise ValueError("Not a valid limit")
 
-    download_limit = property(_get_download_limit, _set_download_limit, None, "Download limit in Kbps or None. This is a mutator.")
+    download_limit = property(_get_download_limit, _set_download_limit, None,
+                              "Download limit in Kbps or None. This is a mutator.")
 
     def _get_peer_limit(self):
         """
@@ -428,7 +432,8 @@ class Torrent(object):
         else:
             raise ValueError("Not a valid limit")
 
-    upload_limit = property(_get_upload_limit, _set_upload_limit, None, "Upload limit in Kbps or None. This is a mutator.")
+    upload_limit = property(_get_upload_limit, _set_upload_limit, None,
+                            "Upload limit in Kbps or None. This is a mutator.")
 
     def _get_queue_position(self):
         """Get the queue position for this torrent."""

core/transmissionrpc/utils.py

@@ -10,6 +10,7 @@ from six import string_types, iteritems
 
 UNITS = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB']
 
+
 def format_size(size):
     """
     Format byte size into IEC prefixes, B, KiB, MiB ...
@@ -21,6 +22,7 @@ def format_size(size):
         size /= 1024.0
     return (size, UNITS[i])
 
+
 def format_speed(size):
     """
     Format bytes per second speed into IEC prefixes, B/s, KiB/s, MiB/s ...
@@ -28,6 +30,7 @@ def format_speed(size):
     (size, unit) = format_size(size)
     return (size, unit + '/s')
 
+
 def format_timedelta(delta):
     """
     Format datetime.timedelta into <days> <hours>:<minutes>:<seconds>.
@@ -36,6 +39,7 @@ def format_timedelta(delta):
     hours, minutes = divmod(minutes, 60)
     return '%d %02d:%02d:%02d' % (delta.days, hours, minutes, seconds)
 
+
 def format_timestamp(timestamp, utc=False):
     """
     Format unix timestamp into ISO date format.
@@ -49,12 +53,14 @@ def format_timestamp(timestamp, utc=False):
     else:
         return '-'
 
+
 class INetAddressError(Exception):
     """
     Error parsing / generating a internet address.
     """
     pass
 
+
 def inet_address(address, default_port, default_address='localhost'):
     """
     Parse internet address.
@@ -84,6 +90,7 @@ def inet_address(address, default_port, default_address='localhost'):
         raise INetAddressError('Cannot look up address "%s".' % address)
     return (addr, port)
 
+
 def rpc_bool(arg):
     """
     Convert between Python boolean and Transmission RPC boolean.
@@ -95,6 +102,7 @@ def rpc_bool(arg):
             arg = arg.lower() in ['true', 'yes']
     return 1 if bool(arg) else 0
 
+
 TR_TYPE_MAP = {
     'number': int,
     'string': str,
@@ -104,18 +112,21 @@ TR_TYPE_MAP = {
     'object': dict
 }
 
+
 def make_python_name(name):
     """
     Convert Transmission RPC name to python compatible name.
     """
     return name.replace('-', '_')
 
+
 def make_rpc_name(name):
     """
     Convert python compatible name to Transmission RPC name.
     """
     return name.replace('_', '-')
 
+
 def argument_value_convert(method, argument, value, rpc_version):
     """
     Check and fix Transmission RPC issues with regards to methods, arguments and values.
@@ -154,6 +165,7 @@ def argument_value_convert(method, argument, value, rpc_version):
         raise ValueError('Argument "%s" does not exists for method "%s".',
                          (argument, method))
 
+
 def get_arguments(method, rpc_version):
     """
     Get arguments for method in specified Transmission RPC version.
@@ -175,6 +187,7 @@ def get_arguments(method, rpc_version):
             accessible.append(argument)
     return accessible
 
+
 def add_stdout_logger(level='debug'):
     """
     Add a stdout target for the transmissionrpc logging.
@@ -189,6 +202,7 @@ def add_stdout_logger(level='debug'):
         loghandler.setLevel(loglevel)
     trpc_logger.addHandler(loghandler)
 
+
 def add_file_logger(filepath, level='debug'):
     """
     Add a stdout target for the transmissionrpc logging.
@@ -203,4 +217,5 @@ def add_file_logger(filepath, level='debug'):
         loghandler.setLevel(loglevel)
     trpc_logger.addHandler(loghandler)
 
+
 Field = namedtuple('Field', ['value', 'dirty'])

core/utorrent/client.py

@@ -1,10 +1,12 @@
 # coding=utf8
+
 import urllib
 import urllib2
 import urlparse
 import cookielib
 import re
 import StringIO
+
 try:
     import json
 except ImportError:
@@ -12,8 +14,8 @@ except ImportError:
 
 from core.utorrent.upload import MultiPartForm
 
-class UTorrentClient(object):
 
+class UTorrentClient(object):
     def __init__(self, base_url, username, password):
         self.base_url = base_url
         self.username = username
@@ -23,7 +25,7 @@ class UTorrentClient(object):
         # TODO refresh token, when necessary
 
     def _make_opener(self, realm, base_url, username, password):
-        '''uTorrent API need HTTP Basic Auth and cookie support for token verify.'''
+        """uTorrent API need HTTP Basic Auth and cookie support for token verify."""
 
         auth_handler = urllib2.HTTPBasicAuthHandler()
         auth_handler.add_password(realm=realm,
@@ -47,7 +49,6 @@ class UTorrentClient(object):
         match = re.search(token_re, response.read())
         return match.group(1)
 
-       
     def list(self, **kwargs):
         params = [('list', '1')]
         params += kwargs.items()
@@ -139,4 +140,3 @@ class UTorrentClient(object):
             return response.code, json.loads(response.read())
         except urllib2.HTTPError, e:
             raise
-        

core/utorrent/upload.py

@@ -53,8 +53,7 @@ class MultiPartForm(object):
         # Add the files to upload
         parts.extend(
             [part_boundary,
-              'Content-Disposition: file; name="%s"; filename="%s"' % \
+             'Content-Disposition: file; name="%s"; filename="%s"' % (field_name, filename),
-                 (field_name, filename),
              'Content-Type: %s' % content_type,
              '',
              body,

core/versionCheck.py

@@ -16,6 +16,7 @@ import gh_api as github
 import core
 from core import logger
 
+
 class CheckVersion():
     """
     Version check class meant to run as a thread object with the SB scheduler.
@@ -80,6 +81,7 @@ class CheckVersion():
         if self.updater.need_update():
             return self.updater.update()
 
+
 class UpdateManager():
     def get_github_repo_user(self):
         return core.GIT_USER
@@ -90,6 +92,7 @@ class UpdateManager():
     def get_github_branch(self):
         return core.GIT_BRANCH
 
+
 class GitUpdateManager(UpdateManager):
     def __init__(self):
         self._git_path = self._find_working_git()
@@ -103,7 +106,8 @@ class GitUpdateManager(UpdateManager):
         self._num_commits_ahead = 0
 
     def _git_error(self):
-        logger.debug('Unable to find your git executable - Set git_path in your autoProcessMedia.cfg OR delete your .git folder and run from source to enable updates.')
+        logger.debug(
+            'Unable to find your git executable - Set git_path in your autoProcessMedia.cfg OR delete your .git folder and run from source to enable updates.')
 
     def _find_working_git(self):
         test_cmd = 'version'
@@ -148,7 +152,8 @@ class GitUpdateManager(UpdateManager):
                     logger.log(u"Not using: " + cur_git, logger.DEBUG)
 
         # Still haven't found a working git
-        logger.debug('Unable to find your git executable - Set git_path in your autoProcessMedia.cfg OR delete your .git folder and run from source to enable updates.')
+        logger.debug(
+            'Unable to find your git executable - Set git_path in your autoProcessMedia.cfg OR delete your .git folder and run from source to enable updates.')
 
         return None
 
@@ -279,9 +284,10 @@ class GitUpdateManager(UpdateManager):
                 logger.log(u"git didn't return numbers for behind and ahead, not using it", logger.DEBUG)
                 return
 
-        logger.log(u"cur_commit = " + str(self._cur_commit_hash) + u" % (newest_commit)= " + str(self._newest_commit_hash)
+        logger.log(
-                   + u", num_commits_behind = " + str(self._num_commits_behind) + u", num_commits_ahead = " + str(
+            u"cur_commit = " + str(self._cur_commit_hash) + u" % (newest_commit)= " + str(self._newest_commit_hash) +
-            self._num_commits_ahead), logger.DEBUG)
+            u", num_commits_behind = " + str(self._num_commits_behind) + u", num_commits_ahead = " +
+            str(self._num_commits_ahead), logger.DEBUG)
 
     def set_newest_text(self):
         if self._num_commits_ahead:
@@ -411,8 +417,9 @@ class SourceUpdateManager(UpdateManager):
                 # when _cur_commit_hash doesn't match anything _num_commits_behind == 100
                 self._num_commits_behind += 1
 
-        logger.log(u"cur_commit = " + str(self._cur_commit_hash) + u" % (newest_commit)= " + str(self._newest_commit_hash)
+        logger.log(
-                   + u", num_commits_behind = " + str(self._num_commits_behind), logger.DEBUG)
+            u"cur_commit = " + str(self._cur_commit_hash) + u" % (newest_commit)= " + str(self._newest_commit_hash) +
+            u", num_commits_behind = " + str(self._num_commits_behind), logger.DEBUG)
 
     def set_newest_text(self):