示例#1
0
def filterBadReleases(name):
    """
    Filters out non-english and just all-around stupid releases by comparing them
    to the resultFilters contents.

    name: the release name to check

    Returns: True if the release name is OK, False if it's bad.
    """

    cp = CompleteParser()
    cpr = cp.parse(name)
    parse_result = cpr.parse_result

    # use the extra info and the scene group to filter against
    check_string = ''
    if parse_result.extra_info:
        check_string = parse_result.extra_info
    if parse_result.release_group:
        if check_string:
            check_string = check_string + '-' + parse_result.release_group
        else:
            check_string = parse_result.release_group

    # if there's no info after the season info then assume it's fine
    if not check_string:
        return True

    # if any of the bad strings are in the name then say no
    for x in resultFilters + sickbeard.IGNORE_WORDS.split(','):
        if re.search('(^|[\W_])' + x + '($|[\W_])', check_string, re.I):
            logger.log(u"Invalid scene release: " + name + " contains " + x + ", ignoring it", logger.DEBUG)
            return False

    return True
示例#2
0
    def _addCacheEntry(self, name, url, season=None, episodes=None, tvdb_id=0, tvrage_id=0, quality=None, extraNames=[]):
        """Return False|None
        Parse the name and try to get as much info out of it as we can
        Will use anime regex's if this is called from fanzub
        On a succesfull parse it will add the parsed infos into the cache.db
        This dosen't mean the parsed result is usefull
        """
        myDB = self._getDB()
        show = None
        if tvdb_id:
            show = helpers.findCertainShow(sickbeard.showList, tvdb_id)
        # if we don't have complete info then parse the filename to get it
        for curName in [name] + extraNames:
            cp = CompleteParser(show=show)
            cpr = cp.parse(curName)
            if cpr.sxxexx and cpr.parse_result:
                break
        else:
            return False

        episodeText = "|"+"|".join(map(str, cpr.episodes))+"|"
        # get the current timestamp
        curTimestamp = int(time.mktime(datetime.datetime.today().timetuple()))
        myDB.action("INSERT INTO "+self.providerID+" (name, season, episodes, tvrid, tvdbid, url, time, quality, release_group, proper) VALUES (?,?,?,?,?,?,?,?,?,?)",
                    [name, cpr.season, episodeText, 0, cpr.tvdbid, url, curTimestamp, cpr.quality, cpr.release_group, int(cpr.is_proper)])
示例#3
0
    def findSeasonResults(self, show, season, scene=False):

        itemList = []
        results = {}

        for curString in self._get_season_search_strings(show, season, scene):
            itemList += self._doSearch(curString, show=show)

        for item in itemList:

            (title, url) = self._get_title_and_url(item)
            # parse the file name
            cp = CompleteParser(show=show)
            cpr = cp.parse(title)
            if not cpr:
                continue

            # make sure we want the episode
            wantEp = True
            for epNo in cpr.episodes:
                if not show.wantEpisode(cpr.season, epNo, cpr.quality):
                    wantEp = False
                    break

            if not wantEp:
                logger.log(u"Ignoring result "+title+" because we don't want an episode that is "+Quality.qualityStrings[cpr.quality], logger.DEBUG)
                continue

            logger.log(u"Found result " + title + " at " + url, logger.DEBUG)

            # make a result object
            epObj = []
            for curEp in cpr.episodes:
                epObj.append(show.getEpisode(cpr.season, curEp))

            result = self.getResult(epObj)
            result.url = url
            result.name = title
            result.quality = cpr.quality
            result.release_group = cpr.release_group
            result.is_proper = cpr.is_proper

            if len(epObj) == 1:
                epNum = epObj[0].episode
            elif len(epObj) > 1:
                epNum = MULTI_EP_RESULT
                logger.log(u"Separating multi-episode result to check for later - result contains episodes: " + str(cpr.episodes), logger.DEBUG)
            elif len(epObj) == 0:
                epNum = SEASON_RESULT
                result.extraInfo = [show]
                logger.log(u"Separating full season result to check for later", logger.DEBUG)

            if epNum in results:
                results[epNum].append(result)
            else:
                results[epNum] = [result]

        return results
示例#4
0
    def findSeasonResults(self, show, season, scene=False):

        itemList = []
        results = {}

        for curString in self._get_season_search_strings(show, season, scene):
            itemList += self._doSearch(curString, show=show)

        for item in itemList:

            (title, url) = self._get_title_and_url(item)
            # parse the file name
            cp = CompleteParser(show=show)
            cpr = cp.parse(title)
            if not cpr:
                continue

            # make sure we want the episode
            wantEp = True
            for epNo in cpr.episodes:
                if not show.wantEpisode(cpr.season, epNo, cpr.quality):
                    wantEp = False
                    break

            if not wantEp:
                logger.log(u"Ignoring result "+title+" because we don't want an episode that is "+Quality.qualityStrings[cpr.quality], logger.DEBUG)
                continue

            logger.log(u"Found result " + title + " at " + url, logger.DEBUG)

            # make a result object
            epObj = []
            for curEp in cpr.episodes:
                epObj.append(show.getEpisode(cpr.season, curEp))

            result = self.getResult(epObj)
            result.url = url
            result.name = title
            result.quality = cpr.quality
            result.release_group = cpr.release_group
            result.is_proper = cpr.is_proper

            if len(epObj) == 1:
                epNum = epObj[0].episode
            elif len(epObj) > 1:
                epNum = MULTI_EP_RESULT
                logger.log(u"Separating multi-episode result to check for later - result contains episodes: " + str(cpr.episodes), logger.DEBUG)
            elif len(epObj) == 0:
                epNum = SEASON_RESULT
                result.extraInfo = [show]
                logger.log(u"Separating full season result to check for later", logger.DEBUG)

            if epNum in results:
                results[epNum].append(result)
            else:
                results[epNum] = [result]

        return results
示例#5
0
def validate_name(pattern,
                  multi=None,
                  file_only=False,
                  abd=False,
                  anime=False):
    ep = _generate_sample_ep(multi, abd, anime)

    new_name = ep.formatted_filename(pattern, multi) + '.ext'
    new_path = ep.formatted_dir(pattern, multi)
    if not file_only:
        new_name = ek.ek(os.path.join, new_path, new_name)

    if not new_name:
        logger.log(u"Unable to create a name out of " + pattern, logger.DEBUG)
        return False

    logger.log(u"Trying to parse " + new_name, logger.DEBUG)

    cp = CompleteParser(ep.show)
    cpr = cp.parse(new_name)

    if not cpr.parse_result:
        logger.log(u"Unable to parse " + new_name + ", not valid",
                   logger.DEBUG)
        return False

    logger.log("The name " + new_name + " parsed into " + str(cpr),
               logger.DEBUG)

    if abd:
        if cpr.air_date != ep.airdate:
            return False
    elif anime:
        if cpr.ab_episode_numbers != [
                x.absolute_number for x in [ep] + ep.relatedEps
        ]:
            logger.log(
                u"Air date incorrect in parsed episode, pattern isn't valid",
                logger.DEBUG)
            return False
    else:
        if cpr.season != ep.season:
            logger.log(
                u"Season incorrect in parsed episode, pattern isn't valid",
                logger.DEBUG)
            return False
        if cpr.episodes != [x.episode for x in [ep] + ep.relatedEps]:
            logger.log(
                u"Episode incorrect in parsed episode, pattern isn't valid",
                logger.DEBUG)
            return False

    return True
示例#6
0
def filterBadReleases(name):
    """
    Filters out non-english and just all-around stupid releases by comparing them
    to the resultFilters contents.
    
    name: the release name to check
    
    Returns: True if the release name is OK, False if it's bad.
    """
    """
    try:
        parse_result = parse_result_wrapper(None,name)
    except InvalidNameException:
        logger.log(u"Unable to parse the filename "+name+" into a valid episode", logger.WARNING)
        return False
    """
    cp = CompleteParser()
    cpr = cp.parse(name)
    parse_result = cpr.parse_result

    # use the extra info and the scene group to filter against
    check_string = ''
    if parse_result.extra_info:
        check_string = parse_result.extra_info
    if parse_result.release_group:
        if check_string:
            check_string = check_string + '-' + parse_result.release_group
        else:
            check_string = parse_result.release_group

    # if there's no info after the season info then assume it's fine
    if not check_string:
        return True

    # if any of the bad strings are in the name then say no
    for x in resultFilters + sickbeard.IGNORE_WORDS.split(','):
        if re.search('(^|[\W_])' + x + '($|[\W_])', check_string, re.I):
            logger.log(
                u"Invalid scene release: " + name + " contains " + x +
                ", ignoring it", logger.DEBUG)
            return False

    return True
示例#7
0
    def _addCacheEntry(self, name, url, season=None, episodes=None, tvdb_id=0, tvrage_id=0, quality=None, extraNames=[]):

        myDB = self._getDB()

        # if we don't have complete info then parse the filename to get it
        for curName in [name] + extraNames:
            try:
                cp = CompleteParser()
                cpr = cp.parse(curName)
            except:
                logger.log(u"Unable to parse the filename "+curName+" into a valid episode", logger.DEBUG)
                return False
            
        episodeText = "|" + "|".join(map(str, cpr.episodes)) + "|"

        # get the current timestamp
        curTimestamp = int(time.mktime(datetime.datetime.today().timetuple()))

        myDB.action("INSERT INTO " + self.providerID + " (name, season, episodes, tvrid, tvdbid, url, time, quality) VALUES (?,?,?,?,?,?,?,?)",
                    [name, cpr.season, episodeText, 0, cpr.tvdbid, url, curTimestamp, cpr.quality])
示例#8
0
    def _addCacheEntry(self,
                       name,
                       url,
                       season=None,
                       episodes=None,
                       tvdb_id=0,
                       tvrage_id=0,
                       quality=None,
                       extraNames=[]):
        """Return False|None
        Parse the name and try to get as much info out of it as we can
        Will use anime regex's if this is called from fanzub
        On a succesfull parse it will add the parsed infos into the cache.db
        This dosen't mean the parsed result is usefull
        """
        myDB = self._getDB()
        show = None
        if tvdb_id:
            show = helpers.findCertainShow(sickbeard.showList, tvdb_id)
        # if we don't have complete info then parse the filename to get it
        for curName in [name] + extraNames:
            cp = CompleteParser(show=show)
            cpr = cp.parse(curName)
            if cpr.sxxexx and cpr.parse_result:
                break
        else:
            return False

        episodeText = "|" + "|".join(map(str, cpr.episodes)) + "|"
        # get the current timestamp
        curTimestamp = int(time.mktime(datetime.datetime.today().timetuple()))
        myDB.action(
            "INSERT INTO " + self.providerID +
            " (name, season, episodes, tvrid, tvdbid, url, time, quality, release_group, proper) VALUES (?,?,?,?,?,?,?,?,?,?)",
            [
                name, cpr.season, episodeText, 0, cpr.tvdbid, url,
                curTimestamp, cpr.quality, cpr.release_group,
                int(cpr.is_proper)
            ])
示例#9
0
def validate_name(pattern, multi=None, file_only=False, abd=False, anime=False):
    ep = _generate_sample_ep(multi, abd, anime)

    new_name = ep.formatted_filename(pattern, multi) + '.ext'
    new_path = ep.formatted_dir(pattern, multi)
    if not file_only:
        new_name = ek.ek(os.path.join, new_path, new_name)

    if not new_name:
        logger.log(u"Unable to create a name out of "+pattern, logger.DEBUG)
        return False

    logger.log(u"Trying to parse " + new_name, logger.DEBUG)
    
    cp = CompleteParser(ep.show)
    cpr = cp.parse(new_name)
    
    if not cpr.parse_result:
        logger.log(u"Unable to parse "+new_name+", not valid", logger.DEBUG)
        return False

    logger.log("The name "+new_name + " parsed into " + str(cpr), logger.DEBUG)

    if abd:
        if cpr.air_date != ep.airdate:
            return False
    elif anime:
        if cpr.ab_episode_numbers != [x.absolute_number for x in [ep] + ep.relatedEps]:
            logger.log(u"Air date incorrect in parsed episode, pattern isn't valid", logger.DEBUG)
            return False
    else:
        if cpr.season != ep.season:
            logger.log(u"Season incorrect in parsed episode, pattern isn't valid", logger.DEBUG)
            return False
        if cpr.episodes != [x.episode for x in [ep] + ep.relatedEps]:
            logger.log(u"Episode incorrect in parsed episode, pattern isn't valid", logger.DEBUG)
            return False

    return True
    def _analyze_name(self, name, file=True):
        """
        Takes a name and tries to figure out a show, season, and episode from it.
        
        name: A string which we want to analyze to determine show info from (unicode)
        
        Returns a (tvdb_id, season, [episodes]) tuple. The first two may be None and episodes may be []
        if none were found.
        """
        logger.log(u"Analyzing name "+repr(name))

        to_return = (None, None, [])

        if not name:
            return to_return

        cp = CompleteParser(log=self._log, tvdbActiveLookUp=True)
        cpr = cp.parse(name)
        self.is_proper = cpr.is_proper
        self.series_name = cpr.series_name

        return (cpr.tvdbid, cpr.season, cpr.episodes)
    def _analyze_name(self, name, file=True):
        """
        Takes a name and tries to figure out a show, season, and episode from it.
        
        name: A string which we want to analyze to determine show info from (unicode)
        
        Returns a (tvdb_id, season, [episodes]) tuple. The first two may be None and episodes may be []
        if none were found.
        """
        logger.log(u"Analyzing name " + repr(name))

        to_return = (None, None, [])

        if not name:
            return to_return

        cp = CompleteParser(log=self._log, tvdbActiveLookUp=True)
        cpr = cp.parse(name)
        self.is_proper = cpr.is_proper
        self.series_name = cpr.series_name

        return (cpr.tvdbid, cpr.season, cpr.episodes)
示例#12
0
    def findSeasonResults(self, show, season, scene):

        itemList = []
        results = {}

        for cur_string in self._get_season_search_strings(show, season):
            itemList += self._doSearch(cur_string)

        for item in itemList:

            (title, url) = self._get_title_and_url(item)

            quality = self.getQuality(item)

            # parse the file name
            cp = CompleteParser(show=show)
            cpr = cp.parse(title)
            if not cpr:
                continue
            """
            try:
                #myParser = NameParser(False)
                #parse_result = myParser.parse(title)
                parse_result = None
            except InvalidNameException:
                logger.log(u"Unable to parse the filename " + title + " into a valid episode", logger.WARNING)
                continue

            if not show.air_by_date:
                # this check is meaningless for non-season searches
                if (parse_result.season_number != None and parse_result.season_number != season) or (parse_result.season_number == None and season != 1):
                    logger.log(u"The result " + title + " doesn't seem to be a valid episode for season " + str(season) + ", ignoring")
                    continue

                # we just use the existing info for normal searches
                actual_season = season
                actual_episodes = parse_result.episode_numbers

            else:
                if not parse_result.air_by_date:
                    logger.log(u"This is supposed to be an air-by-date search but the result " + title + " didn't parse as one, skipping it", logger.DEBUG)
                    continue

                myDB = db.DBConnection()
                sql_results = myDB.select("SELECT season, episode FROM tv_episodes WHERE showid = ? AND airdate = ?", [show.tvdbid, parse_result.air_date.toordinal()])

                if len(sql_results) != 1:
                    logger.log(u"Tried to look up the date for the episode " + title + " but the database didn't give proper results, skipping it", logger.WARNING)
                    continue

                actual_season = int(sql_results[0]["season"])
                actual_episodes = [int(sql_results[0]["episode"])]

            """
            # make sure we want the episode
            wantEp = True
            for epNo in cpr.episodes:
                if not show.wantEpisode(cpr.season, epNo, cpr.quality):
                    wantEp = False
                    break

            if not wantEp:
                logger.log(u"Ignoring result " + title + " because we don't want an episode (" + str(cpr.season) + "x" + str(epNo) + ") that is " + Quality.qualityStrings[quality], logger.DEBUG)
                continue

            logger.log(u"Found result " + title + " at " + url, logger.DEBUG)

            # make a result object
            epObj = []
            for curEp in cpr.episodes:
                epObj.append(show.getEpisode(cpr.season, curEp))

            result = self.getResult(epObj)
            result.url = url
            result.name = title
            result.quality = cpr.quality

            if len(epObj) == 1:
                epNum = epObj[0].episode
            elif len(epObj) > 1:
                epNum = MULTI_EP_RESULT
                logger.log(u"Separating multi-episode result to check for later - result contains episodes: " + str(parse_result.episode_numbers), logger.DEBUG)
            elif len(epObj) == 0:
                epNum = SEASON_RESULT
                result.extraInfo = [show]
                logger.log(u"Separating full season result to check for later", logger.DEBUG)

            if epNum in results:
                results[epNum].append(result)
            else:
                results[epNum] = [result]

        return results
示例#13
0
    def _analyze_name(self, name, file=True):
        """
        Takes a name and tries to figure out a show, season, and episode from it.

        name: A string which we want to analyze to determine show info from (unicode)

        Returns a (tvdb_id, season, [episodes]) tuple. The first two may be None and episodes may be []
        if none were found.
        """

        logger.log(u"Analyzing name " + repr(name))

        to_return = (None, None, [])

        if not name:
            return to_return
        
        cp = CompleteParser(log=self._log, tvdbActiveLookUp=True)
        cpr = cp.parse(name)
        self.is_proper = cpr.is_proper
        self.series_name = cpr.series_name

        return (cpr.tvdbid, cpr.season, cpr.episodes)
        """
        # parse the name to break it into show name, season, and episode
        np = NameParser(file)
        parse_result = np.parse(name)
        self._log("Parsed " + name + " into " + str(parse_result).decode('utf-8'), logger.DEBUG)

        if parse_result.air_by_date:
            season = -1
            episodes = [parse_result.air_date]
        else:
            season = parse_result.season_number
            episodes = parse_result.episode_numbers

        to_return = (None, season, episodes)

        # do a scene reverse-lookup to get a list of all possible names
        name_list = show_name_helpers.sceneToNormalShowNames(parse_result.series_name)

        if not name_list:
            return (None, season, episodes)
        """
        
        def _finalize(parse_result):
            self.release_group = parse_result.release_group

            # remember whether it's a proper
            if parse_result.extra_info:
                self.is_proper = re.search('(^|[\. _-])(proper|repack)([\. _-]|$)', parse_result.extra_info, re.I) != None

            # 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 = os.path.basename(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))
            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)
                logger.log(u"Parse result(season_number): " + str(parse_result.season_number), logger.DEBUG)
                logger.log(u"Parse result(episode_numbers): " + str(parse_result.episode_numbers), logger.DEBUG)
                logger.log(u"Parse result(release_group): " + str(parse_result.release_group), logger.DEBUG)

        # for each possible interpretation of that scene name
        for cur_name in name_list:
            self._log(u"Checking scene exceptions for a match on " + cur_name, logger.DEBUG)
            scene_id = scene_exceptions.get_scene_exception_by_name(cur_name)
            if scene_id:
                self._log(u"Scene exception lookup got tvdb id " + str(scene_id) + u", using that", logger.DEBUG)
                _finalize(parse_result)
                return (scene_id, season, episodes)

        # see if we can find the name directly in the DB, if so use it
        for cur_name in name_list:
            self._log(u"Looking up " + cur_name + u" in the DB", logger.DEBUG)
            db_result = helpers.searchDBForShow(cur_name)
            if db_result:
                self._log(u"Lookup successful, using tvdb id " + str(db_result[0]), logger.DEBUG)
                _finalize(parse_result)
                return (int(db_result[0]), season, episodes)

        # see if we can find the name with a TVDB lookup
        for cur_name in name_list:
            try:
                t = tvdb_api.Tvdb(custom_ui=classes.ShowListUI, **sickbeard.TVDB_API_PARMS)

                self._log(u"Looking up name " + cur_name + u" on TVDB", logger.DEBUG)
                showObj = t[cur_name]
            except (tvdb_exceptions.tvdb_exception):
                # if none found, search on all languages
                try:
                    # There's gotta be a better way of doing this but we don't wanna
                    # change the language value elsewhere
                    ltvdb_api_parms = sickbeard.TVDB_API_PARMS.copy()

                    ltvdb_api_parms['search_all_languages'] = True
                    t = tvdb_api.Tvdb(custom_ui=classes.ShowListUI, **ltvdb_api_parms)

                    self._log(u"Looking up name " + cur_name + u" in all languages on TVDB", logger.DEBUG)
                    showObj = t[cur_name]
                except (tvdb_exceptions.tvdb_exception, IOError):
                    pass

                continue
            except (IOError):
                continue

            self._log(u"Lookup successful, using tvdb id " + str(showObj["id"]), logger.DEBUG)
            _finalize(parse_result)
            return (int(showObj["id"]), season, episodes)

        _finalize(parse_result)
        return to_return
示例#14
0
    def _getProperList(self):

        propers = {}

        # for each provider get a list of the propers
        for curProvider in providers.sortedProviderList():

            if not curProvider.isActive():
                continue

            date = datetime.datetime.today() - datetime.timedelta(days=2)

            logger.log(u"Searching for any new PROPER releases from "+curProvider.name)
            curPropers = curProvider.findPropers(date)

            # if they haven't been added by a different provider than add the proper to the list
            for x in curPropers:
                name = self._genericName(x.name)
                
                if not name in propers:
                    logger.log(u"Found new proper: "+x.name, logger.DEBUG)
                    x.provider = curProvider
                    propers[name] = x

        # take the list of unique propers and get it sorted by
        sortedPropers = sorted(propers.values(), key=operator.attrgetter('date'), reverse=True)
        finalPropers = []

        for curProper in sortedPropers:

            # parse the file name
            cp = CompleteParser()
            cpr = cp.parse(curProper.name)
            parse_result = cpr.parse_result

            if not parse_result.episode_numbers and not parse_result.is_anime:
                logger.log(u"Ignoring "+curProper.name+" because it's for a full season rather than specific episode", logger.DEBUG)
                continue

            # populate our Proper instance
            if parse_result.air_by_date:
                curProper.season = -1
                curProper.episode = parse_result.air_date
            else:
                curProper.season = parse_result.season_number if parse_result.season_number != None else 1
                if parse_result.is_anime:
                    logger.log(u"I am sorry '"+curProper.name+"' seams to be an anime proper seach is not yet suported", logger.DEBUG)
                    continue
                    curProper.episode = parse_result.ab_episode_numbers[0]
                else:
                    curProper.episode = parse_result.episode_numbers[0]
            
            curProper.quality = Quality.nameQuality(curProper.name,parse_result.is_anime)

            # for each show in our list
            for curShow in sickbeard.showList:

                genericName = self._genericName(parse_result.series_name)

                # get the scene name masks
                sceneNames = set(show_name_helpers.makeSceneShowSearchStrings(curShow))

                # for each scene name mask
                for curSceneName in sceneNames:

                    # if it matches
                    if genericName == self._genericName(curSceneName):
                        logger.log(u"Successful match! Result "+parse_result.series_name+" matched to show "+curShow.name, logger.DEBUG)

                        # set the tvdbid in the db to the show's tvdbid
                        curProper.tvdbid = curShow.tvdbid

                        # since we found it, break out
                        break

                # if we found something in the inner for loop break out of this one
                if curProper.tvdbid != -1:
                    break

            if curProper.tvdbid == -1:
                continue
            
            if not show_name_helpers.filterBadReleases(curProper.name):
                logger.log(u"Proper "+curProper.name+" isn't a valid scene release that we want, igoring it", logger.DEBUG)
                continue

            # if we have an air-by-date show then get the real season/episode numbers
            if curProper.season == -1 and curProper.tvdbid:
                showObj = helpers.findCertainShow(sickbeard.showList, curProper.tvdbid)
                if not showObj:
                    logger.log(u"This should never have happened, post a bug about this!", logger.ERROR)
                    raise Exception("BAD STUFF HAPPENED")

                tvdb_lang = showObj.lang
                # There's gotta be a better way of doing this but we don't wanna
                # change the language value elsewhere
                ltvdb_api_parms = sickbeard.TVDB_API_PARMS.copy()

                if tvdb_lang and not tvdb_lang == 'en':
                    ltvdb_api_parms['language'] = tvdb_lang

                try:
                    t = tvdb_api.Tvdb(**ltvdb_api_parms)
                    epObj = t[curProper.tvdbid].airedOn(curProper.episode)[0]
                    curProper.season = int(epObj["seasonnumber"])
                    curProper.episodes = [int(epObj["episodenumber"])]
                except tvdb_exceptions.tvdb_episodenotfound:
                    logger.log(u"Unable to find episode with date "+str(curProper.episode)+" for show "+parse_result.series_name+", skipping", logger.WARNING)
                    continue

            # check if we actually want this proper (if it's the right quality)
            sqlResults = db.DBConnection().select("SELECT status FROM tv_episodes WHERE showid = ? AND season = ? AND episode = ?", [curProper.tvdbid, curProper.season, curProper.episode])
            if not sqlResults:
                continue
            oldStatus, oldQuality = Quality.splitCompositeStatus(int(sqlResults[0]["status"]))

            # only keep the proper if we have already retrieved the same quality ep (don't get better/worse ones)
            if oldStatus not in (DOWNLOADED, SNATCHED) or oldQuality != curProper.quality:
                continue

            # if the show is in our list and there hasn't been a proper already added for that particular episode then add it to our list of propers
            if curProper.tvdbid != -1 and (curProper.tvdbid, curProper.season, curProper.episode) not in map(operator.attrgetter('tvdbid', 'season', 'episode'), finalPropers):
                logger.log(u"Found a proper that we need: "+str(curProper.name))
                finalPropers.append(curProper)

        return finalPropers
示例#15
0
    def findEpisode(self, episode, manualSearch=False):

        logger.log(u"Searching " + self.name + " for " + episode.prettyName())

        self.cache.updateCache()
        results = self.cache.searchCache(episode, manualSearch)
        logger.log(u"Cache results: " + str(results), logger.DEBUG)

        # if we got some results then use them no matter what.
        # OR
        # return anyway unless we're doing a manual search
        if results or not manualSearch:
            return results

        itemList = []

        for cur_search_string in self._get_episode_search_strings(episode):
            itemList += self._doSearch(cur_search_string, show=episode.show)

        for item in itemList:

            (title, url) = self._get_title_and_url(item)

            """
            # parse the file name
            try:
                myParser = NameParser()
                parse_result = myParser.parse(title)
            except InvalidNameException:
                logger.log(u"Unable to parse the filename " + title + " into a valid episode", logger.WARNING)
                continue
            """
            cp = CompleteParser(show=episode.show, tvdbActiveLookUp=True)
            cpr = cp.parse(title)
            parse_result = cpr.parse_result

            if episode.show.air_by_date:
                if parse_result.air_date != episode.airdate:

                    logger.log(u"Episode " + title + " didn't air on " + str(episode.airdate) + ", skipping it", logger.DEBUG)
                    continue

            elif parse_result.season_number != episode.scene_season or episode.scene_episode not in parse_result.episode_numbers:
                logger.log(u"Episode " + title + " isn't " + str(episode.season) + "x" + str(episode.episode) + ", skipping it", logger.DEBUG)
                continue

            quality = cpr.quality #self.getQuality(item)

            if not episode.show.wantEpisode(episode.season, episode.episode, quality, manualSearch):
                logger.log(u"Ignoring result " + title + " because we don't want an episode that is " + Quality.qualityStrings[quality], logger.DEBUG)
                continue

            logger.log(u"Found result " + title + " at " + url, logger.DEBUG)

            result = self.getResult([episode])
            result.url = url
            result.name = title
            result.quality = quality

            results.append(result)

        return results
示例#16
0
    def findEpisode(self, episode, manualSearch=False, searchString=None):

        self._checkAuth()
        if searchString:
            logger.log(u"Searching " + self.name + " for '" +
                       ek.ek(str, searchString) + "'")
        else:
            logger.log(u"Searching " + self.name + " for episode " +
                       episode.prettyName(True))

        logger.log(u"Searching " + self.name + " for " + episode.prettyName())

        self.cache.updateCache()
        results = self.cache.searchCache(episode, manualSearch)
        logger.log(u"Cache results: " + str(results), logger.DEBUG)

        # if we got some results then use them no matter what.
        # OR
        # return anyway unless we're doing a manual search
        if results or not manualSearch:
            return results

        if searchString:  # if we already got a searchstring don't bother make one
            search_strings = [searchString]
        else:
            search_strings = self._get_episode_search_strings(episode)

        itemList = []
        for cur_search_string in search_strings:
            itemList += self._doSearch(cur_search_string, show=episode.show)

        for item in itemList:

            (title, url) = self._get_title_and_url(item)

            cp = CompleteParser(show=episode.show, tvdbActiveLookUp=True)
            cpr = cp.parse(title)

            parse_result = cpr.parse_result

            if episode.show.air_by_date:
                if parse_result.air_date != episode.airdate:
                    logger.log(
                        "Episode " + title + " didn't air on " +
                        str(episode.airdate) + ", skipping it", logger.DEBUG)
                    continue
            elif cpr.season != episode.season or episode.episode not in cpr.episodes:
                logger.log(
                    "Episode " + title + " isn't " +
                    str(episode.scene_season) + "x" +
                    str(episode.scene_episode) +
                    " (beware of scene conversion) , skipping it",
                    logger.DEBUG)
                continue

            if not episode.show.wantEpisode(episode.season, episode.episode,
                                            cpr.quality, manualSearch):
                logger.log(
                    u"Ignoring result " + title +
                    " because we don't want an episode that is " +
                    Quality.qualityStrings[cpr.quality], logger.DEBUG)
                continue

            logger.log(u"Found result " + title + " at " + url, logger.DEBUG)

            result = self.getResult([episode])
            result.url = url
            result.name = title
            result.quality = cpr.quality
            result.release_group = parse_result.release_group
            result.is_proper = cpr.is_proper

            results.append(result)

        return results
示例#17
0
    def findEpisode (self, episode, manualSearch=False, searchString=None):

        self._checkAuth()
        if searchString:
            logger.log(u"Searching "+self.name+" for '" + ek.ek(str, searchString) + "'")
        else:
            logger.log(u"Searching "+self.name+" for episode " + episode.prettyName(True))

        logger.log(u"Searching "+self.name+" for " + episode.prettyName())

        self.cache.updateCache()
        results = self.cache.searchCache(episode, manualSearch)
        logger.log(u"Cache results: "+str(results), logger.DEBUG)

        # if we got some results then use them no matter what.
        # OR
        # return anyway unless we're doing a manual search
        if results or not manualSearch:
            return results

        if searchString: # if we already got a searchstring don't bother make one
            search_strings = [searchString]
        else:
            search_strings = self._get_episode_search_strings(episode)

        itemList = []
        for cur_search_string in search_strings:
            itemList += self._doSearch(cur_search_string, show=episode.show)


        for item in itemList:

            (title, url) = self._get_title_and_url(item)

            cp = CompleteParser(show=episode.show, tvdbActiveLookUp=True)
            cpr = cp.parse(title)

            parse_result = cpr.parse_result

            if episode.show.air_by_date:
                if parse_result.air_date != episode.airdate:
                    logger.log("Episode " + title + " didn't air on " + str(episode.airdate) + ", skipping it", logger.DEBUG)
                    continue
            elif cpr.season != episode.season or episode.episode not in cpr.episodes:
                logger.log("Episode " + title + " isn't " + str(episode.scene_season) + "x" + str(episode.scene_episode) + " (beware of scene conversion) , skipping it", logger.DEBUG)
                continue

            if not episode.show.wantEpisode(episode.season, episode.episode, cpr.quality, manualSearch):
                logger.log(u"Ignoring result " + title + " because we don't want an episode that is " + Quality.qualityStrings[cpr.quality], logger.DEBUG)
                continue

            logger.log(u"Found result " + title + " at " + url, logger.DEBUG)

            result = self.getResult([episode])
            result.url = url
            result.name = title
            result.quality = cpr.quality
            result.release_group = parse_result.release_group
            result.is_proper = cpr.is_proper

            results.append(result)

        return results