Merge branch 'add_cleanup_release_name_group' into development

* add_cleanup_release_name_group:
  Fix rescan overwriting existing release_name
  Add cleanup release name, group
  pep8 cleanup

Author: Patrick Vos

sickbeard/helpers.py

@@ -50,6 +50,7 @@
 from sickbeard.exceptions import MultipleShowObjectsException, ex
 from sickbeard import logger, classes
 from sickbeard.common import USER_AGENT, mediaExtensions, XML_NSMAP
+from sickbeard.common import mediaExtensions
 
 from sickbeard import db
 from sickbeard import encodingKludge as ek
@@ -82,6 +83,32 @@ def indentXML(elem, level=0):
             elem.tail = i
 
 
+def remove_extension(name):
+    """
+    Remove download or media extension from name (if any)
+    """
+
+    if name and "." in name:
+        base_name, sep, extension = name.rpartition('.')  # @UnusedVariable
+        if base_name and extension.lower() in ['nzb', 'torrent'] + mediaExtensions:
+            name = base_name
+
+    return name
+
+
+def remove_non_release_groups(name):
+    """
+    Remove non release groups from name
+    """
+
+    if name and "-" in name:
+        name_group = name.rsplit('-', 1)
+        if name_group[-1].upper() in ["RP", "NZBGEEK"]:
+            name = name_group[0]
+
+    return name
+
+
 def replaceExtension(filename, newExt):
     '''
     >>> replaceExtension('foo.avi', 'mkv')

sickbeard/name_parser/parser.py

@@ -25,31 +25,34 @@
 import sickbeard
 
 from sickbeard import logger
+from sickbeard import encodingKludge as ek
+from sickbeard import helpers
+
 
 class NameParser(object):
-    def __init__(self, file_name=True):
+    def __init__(self, is_file_name=True):
 
-        self.file_name = file_name
+        self.is_file_name = is_file_name
         self.compiled_regexes = []
         self._compile_regexes()
 
     def clean_series_name(self, series_name):
         """Cleans up series name by removing any . and _
         characters, along with any trailing hyphens.
-    
+
         Is basically equivalent to replacing all _ and . with a
         space, but handles decimal numbers in string, for example:
-    
+
         >>> cleanRegexedSeriesName("an.example.1.0.test")
         'an example 1.0 test'
         >>> cleanRegexedSeriesName("an_example_1.0_test")
         'an example 1.0 test'
-        
+
         Stolen from dbr's tvnamer
         """
-        
+
         series_name = re.sub("(\D)\.(?!\s)(\D)", "\\1 \\2", series_name)
-        series_name = re.sub("(\d)\.(\d{4})", "\\1 \\2", series_name) # if it ends in a year then don't keep the dot
+        series_name = re.sub("(\d)\.(\d{4})", "\\1 \\2", series_name)  # if it ends in a year then don't keep the dot
         series_name = re.sub("(\D)\.(?!\s)", "\\1 ", series_name)
         series_name = re.sub("\.(?!\s)(\D)", " \\1", series_name)
         series_name = series_name.replace("_", " ")
@@ -66,44 +69,44 @@ def _compile_regexes(self):
                 self.compiled_regexes.append((cur_pattern_name, cur_regex))
 
     def _parse_string(self, name):
-        
+
         if not name:
             return None
-        
+
         for (cur_regex_name, cur_regex) in self.compiled_regexes:
             match = cur_regex.match(name)
 
             if not match:
                 continue
-            
+
             result = ParseResult(name)
             result.which_regex = [cur_regex_name]
-            
+
             named_groups = match.groupdict().keys()
 
             if 'series_name' in named_groups:
                 result.series_name = match.group('series_name')
                 if result.series_name:
                     result.series_name = self.clean_series_name(result.series_name)
-            
+
             if 'season_num' in named_groups:
                 tmp_season = int(match.group('season_num'))
-                if cur_regex_name == 'bare' and tmp_season in (19,20):
+                if cur_regex_name == 'bare' and tmp_season in (19, 20):
                     continue
                 result.season_number = tmp_season
-            
+
             if 'ep_num' in named_groups:
                 ep_num = self._convert_number(match.group('ep_num'))
                 if 'extra_ep_num' in named_groups and match.group('extra_ep_num'):
-                    result.episode_numbers = range(ep_num, self._convert_number(match.group('extra_ep_num'))+1)
+                    result.episode_numbers = range(ep_num, self._convert_number(match.group('extra_ep_num')) + 1)
                 else:
                     result.episode_numbers = [ep_num]
 
             if 'air_year' in named_groups and 'air_month' in named_groups and 'air_day' in named_groups:
                 year = int(match.group('air_year'))
                 month = int(match.group('air_month'))
                 day = int(match.group('air_day'))
-                
+
                 # make an attempt to detect YYYY-DD-MM formats
                 if month > 12:
                     tmp_month = month
@@ -148,18 +151,18 @@ def _combine_results(self, first, second, attr):
         # if the second doesn't exist then return the first
         if not second:
             return getattr(first, attr)
-        
+
         a = getattr(first, attr)
         b = getattr(second, attr)
-        
+
         # if a is good use it
         if a != None or (type(a) == list and len(a)):
             return a
         # if not use b (if b isn't set it'll just be default)
         else:
             return b
 
-    def _unicodify(self, obj, encoding = "utf-8"):
+    def _unicodify(self, obj, encoding="utf-8"):
         if isinstance(obj, basestring):
             if not isinstance(obj, unicode):
                 obj = unicode(obj, encoding)
@@ -203,30 +206,30 @@ def _convert_number(self, number):
         return int(number)
 
     def parse(self, name):
-        
+
         name = self._unicodify(name)
-        
+
         cached = name_parser_cache.get(name)
         if cached:
             return cached
 
         # break it into parts if there are any (dirname, file name, extension)
-        dir_name, file_name = os.path.split(name)
-        ext_match = re.match('(.*)\.\w{3,4}$', file_name)
-        if ext_match and self.file_name:
-            base_file_name = ext_match.group(1)
+        dir_name, file_name = ek.ek(os.path.split, name)
+
+        if self.is_file_name:
+            base_file_name = helpers.remove_extension(file_name)
         else:
             base_file_name = file_name
-        
+
         # use only the direct parent dir
-        dir_name = os.path.basename(dir_name)
-        
+        dir_name = ek.ek(os.path.basename, dir_name)
+
         # set up a result to use
         final_result = ParseResult(name)
-        
+
         # try parsing the file name
         file_name_result = self._parse_string(base_file_name)
-        
+
         # parse the dirname for extra info if needed
         dir_name_result = self._parse_string(dir_name)
 
@@ -263,6 +266,7 @@ def parse(self, name):
         # return it
         return final_result
 
+
 class ParseResult(object):
     def __init__(self,
                  original_name,
@@ -275,7 +279,7 @@ def __init__(self,
                  ):
 
         self.original_name = original_name
-        
+
         self.series_name = series_name
         self.season_number = season_number
         if not episode_numbers:
@@ -285,15 +289,15 @@ def __init__(self,
 
         self.extra_info = extra_info
         self.release_group = release_group
-        
+
         self.air_date = air_date
-        
+
         self.which_regex = None
-        
+
     def __eq__(self, other):
         if not other:
             return False
-        
+
         if self.series_name != other.series_name:
             return False
         if self.season_number != other.season_number:
@@ -306,7 +310,7 @@ def __eq__(self, other):
             return False
         if self.air_date != other.air_date:
             return False
-        
+
         return True
 
     def __str__(self):
@@ -315,10 +319,10 @@ def __str__(self):
         else:
             to_return = u''
         if self.season_number != None:
-            to_return += 'S'+str(self.season_number)
+            to_return += 'S' + str(self.season_number)
         if self.episode_numbers and len(self.episode_numbers):
             for e in self.episode_numbers:
-                to_return += 'E'+str(e)
+                to_return += 'E' + str(e)
 
         if self.air_by_date:
             to_return += str(self.air_date)
@@ -328,7 +332,7 @@ def __str__(self):
         if self.release_group:
             to_return += ' (' + self.release_group + ')'
 
-        to_return += ' [ABD: '+str(self.air_by_date)+']'
+        to_return += ' [ABD: ' + str(self.air_by_date) + ']'
 
         return to_return.encode('utf-8')
 
@@ -338,19 +342,20 @@ def _is_air_by_date(self):
         return False
     air_by_date = property(_is_air_by_date)
 
+
 class NameParserCache(object):
     #TODO: check if the fifo list can beskiped and only use one dict
-    _previous_parsed_list = [] # keep a fifo list of the cached items
+    _previous_parsed_list = []  # keep a fifo list of the cached items
     _previous_parsed = {}
     _cache_size = 100
-    
+
     def add(self, name, parse_result):
         self._previous_parsed[name] = parse_result
         self._previous_parsed_list.append(name)
         while len(self._previous_parsed_list) > self._cache_size:
             del_me = self._previous_parsed_list.pop(0)
             self._previous_parsed.pop(del_me)
-    
+
     def get(self, name):
         if name in self._previous_parsed:
             logger.log("Using cached parse result for: " + name, logger.DEBUG)
@@ -360,5 +365,6 @@ def get(self, name):
 
 name_parser_cache = NameParserCache()
 
+
 class InvalidNameException(Exception):
     "The given name is not valid"

sickbeard/postProcessor.py

@@ -83,12 +83,12 @@ def __init__(self, file_path, nzb_name=None, pp_options={}):
         self.force_replace = pp_options.get('force_replace', False)
 
         self.in_history = False
+
         self.release_group = None
-        self.is_proper = False
 
-        self.good_results = {self.NZB_NAME: False,
-                             self.FOLDER_NAME: False,
-                             self.FILE_NAME: False}
+        self.release_name = None
+
+        self.is_proper = False
 
         self.log = ''
 
@@ -359,8 +359,10 @@ def _analyze_name(self, name, file_name=True):
         if not name:
             return to_return
 
+        name = helpers.remove_non_release_groups(helpers.remove_extension(name))
+
         # parse the name to break it into show name, season, and episode
-        np = NameParser(file_name)
+        np = NameParser(False)
         parse_result = np.parse(name)
         self._log(u"Parsed " + name + " into " + str(parse_result).decode('utf-8', 'xmlcharrefreplace'), logger.DEBUG)
 
@@ -437,16 +439,10 @@ def _finalize(self, parse_result):
         self.is_proper = parse_result.is_proper
 
         # if the result is complete then remember that for later
-        if parse_result.series_name and parse_result.season_number != None and parse_result.episode_numbers and parse_result.release_group:
-            test_name = ek.ek(os.path.basename, parse_result.original_name)
-            if test_name == self.nzb_name:
-                self.good_results[self.NZB_NAME] = True
-            elif test_name == self.folder_name:
-                self.good_results[self.FOLDER_NAME] = True
-            elif test_name == self.file_name:
-                self.good_results[self.FILE_NAME] = True
-            else:
-                logger.log(u"Nothing was good, found " + repr(test_name) + " and wanted either " + repr(self.nzb_name) + ", " + repr(self.folder_name) + ", or " + repr(self.file_name))
+        if parse_result.series_name and parse_result.season_number is not None and parse_result.episode_numbers and parse_result.release_group:
+            if not self.release_name:
+                self.release_name = helpers.remove_extension(ek.ek(os.path.basename, parse_result.original_name))
+
         else:
             logger.log(u"Parse result not sufficient (all following have to be set). will not save release name", logger.DEBUG)
             logger.log(u"Parse result(series_name): " + str(parse_result.series_name), logger.DEBUG)
@@ -813,28 +809,11 @@ def process(self):
 
         # update the ep info before we rename so the quality & release name go into the name properly
         for cur_ep in [ep_obj] + ep_obj.relatedEps:
-            cur_release_name = None
-
-            # use the best possible representation of the release name
-            if self.good_results[self.NZB_NAME]:
-                cur_release_name = self.nzb_name
-                if cur_release_name.lower().endswith('.nzb'):
-                    cur_release_name = cur_release_name.rpartition('.')[0]
-
-            elif self.good_results[self.FILE_NAME]:
-                cur_release_name = self.file_name
-                # take the extension off the filename, it's not needed
-                if '.' in self.file_name:
-                    cur_release_name = self.file_name.rpartition('.')[0]
-
-            elif self.good_results[self.FOLDER_NAME]:
-                cur_release_name = self.folder_name
-
-            if cur_release_name:
-                self._log("Found release name " + cur_release_name, logger.DEBUG)
-                cur_ep.release_name = cur_release_name
+
+            if self.release_name:
+                self._log("Found release name " + self.release_name, logger.DEBUG)
+                cur_ep.release_name = self.release_name
             else:
-                logger.log(u"good results: " + repr(self.good_results), logger.DEBUG)
                 cur_ep.release_name = ""
 
             cur_ep.status = common.Quality.compositeStatus(common.DOWNLOADED, new_ep_quality)