Exemple #1
0
    def test_process(self):
        show = TVShow(3, 1)
        show.name = self.SHOWNAME
        show.location = self.SHOWDIR
        sickrage.app.showlist = [show]
        ep = TVEpisode(show, self.SEASON, self.EPISODE)
        ep.name = "some ep name"
        ep.save()

        self.post_processor = PostProcessor(self.FILEPATH, process_method='move')
        self.post_processor._log = _log
        self.assertTrue(self.post_processor.process)
Exemple #2
0
    def test_process(self):
        show = TVShow(1, 3)
        show.name = self.SHOWNAME
        show.location = self.SHOWDIR
        show.saveToDB()
        sickrage.app.showlist = [show]
        ep = TVEpisode(show, self.SEASON, self.EPISODE)
        ep.name = "some ep name"
        ep.saveToDB()

        sickrage.app.name_cache.put('show name', 3)
        self.pp = PostProcessor(self.FILEPATH, process_method='move')
        self.assertTrue(self.pp.process)
Exemple #3
0
    def test_process(self):
        show = TVShow(1, 3)
        show.name = SHOWNAME
        show.location = SHOWDIR
        show.saveToDB()
        show.loadFromDB(skipNFO=True)
        sickrage.srCore.SHOWLIST = [show]
        ep = TVEpisode(show, SEASON, EPISODE)
        ep.name = "some ep name"
        ep.saveToDB()

        sickrage.srCore.NAMECACHE.put('show name', 3)
        self.pp = PostProcessor(FILEPATH, process_method='move')
        self.assertTrue(self.pp.process)
Exemple #4
0
    def test_process(self):
        show = TVShow(1, 3)
        show.name = self.SHOWNAME
        show.location = self.SHOWDIR
        show.save_to_db()
        sickrage.app.showlist = [show]
        ep = TVEpisode(show, self.SEASON, self.EPISODE)
        ep.name = "some ep name"
        ep.save_to_db()

        sickrage.app.name_cache.put('show name', 3)
        self.post_processor = PostProcessor(self.FILEPATH, process_method='move')
        self.post_processor._log = _log
        self.assertTrue(self.post_processor.process)
Exemple #5
0
    def test_process(self):
        show = TVShow(1, 3)
        show.name = SHOWNAME
        show.location = SHOWDIR
        show.saveToDB()
        show.loadFromDB(skipNFO=True)
        sickrage.srCore.SHOWLIST = [show]
        ep = TVEpisode(show, SEASON, EPISODE)
        ep.name = "some ep name"
        ep.saveToDB()

        sickrage.srCore.NAMECACHE.addNameToCache('show name', 3)
        self.pp = PostProcessor(FILEPATH, process_method='move')
        self.assertTrue(self.pp.process)
Exemple #6
0
    def test_process(self):
        show = TVShow(1, 3)
        show.name = SHOWNAME
        show.location = SHOWDIR
        show.saveToDB()

        sickrage.showList = [show]
        ep = TVEpisode(show, SEASON, EPISODE)
        ep.name = "some ep name"
        ep.saveToDB()

        sickrage.NAMECACHE.addNameToCache("show name", 3)
        self.pp = PostProcessor(FILEPATH, process_method="move")
        self.assertTrue(self.pp.process)
Exemple #7
0
        def setUp(self):
            super(ProviderTests.ProviderTest, self).setUp()
            self.show = TVShow(
                1,
                test_string_overrides.get(self.provider.name,
                                          {'ID': 82066})['ID'], "en")
            self.show.name = test_string_overrides.get(
                self.provider.name, {'Name': 'Fringe'})['Name']
            self.show.anime = test_string_overrides.get(
                self.provider.name, {'Anime': False})['Anime']

            self.ep = TVEpisode(
                self.show,
                test_string_overrides.get(self.provider.name,
                                          {'Season': 1})['Season'],
                test_string_overrides.get(self.provider.name,
                                          {'Episode': 1})['Episode'])
            self.ep.absolute_number = test_string_overrides.get(
                self.provider.name, {'ABS': 0})['ABS']
            self.ep.scene_season = self.ep.season
            self.ep.scene_episode = self.ep.episode
            self.ep.scene_absolute_number = self.ep.absolute_number

            self.provider.username = self.username
            self.provider.password = self.password
Exemple #8
0
    def load_episodes_from_indexer(self, cache=True):
        scanned_eps = {}

        l_indexer_api_parms = IndexerApi(self.indexer).api_params.copy()
        l_indexer_api_parms['cache'] = cache

        l_indexer_api_parms[
            'language'] = self.lang or sickrage.app.config.indexer_default_language

        if self.dvdorder != 0:
            l_indexer_api_parms['dvdorder'] = True

        t = IndexerApi(self.indexer).indexer(**l_indexer_api_parms)

        sickrage.app.log.debug(
            str(self.indexer_id) + ": Loading all episodes from " +
            IndexerApi(self.indexer).name + "..")

        for season in t[self.indexer_id]:
            scanned_eps[season] = {}
            for episode in t[self.indexer_id][season]:
                # need some examples of wtf episode 0 means to decide if we want it or not
                if episode == 0:
                    continue

                try:
                    episode_obj = self.get_episode(season, episode)
                except EpisodeNotFoundException:
                    object_session(self).add(
                        TVEpisode(
                            **{
                                'showid': self.indexer_id,
                                'indexer': self.indexer,
                                'season': season,
                                'episode': episode,
                                'location': ''
                            }))
                    object_session(self).commit()
                    episode_obj = self.get_episode(season, episode)

                sickrage.app.log.debug(
                    "%s: Loading info from %s for episode S%02dE%02d" %
                    (self.indexer_id, IndexerApi(self.indexer).name, season
                     or 0, episode or 0))

                try:
                    episode_obj.populate_episode(season, episode, tvapi=t)
                except EpisodeNotFoundException:
                    continue

                scanned_eps[season][episode] = True

        # Done updating save last update date
        self.last_update = datetime.date.today().toordinal()

        object_session(self).commit()

        return scanned_eps
Exemple #9
0
 def test_init_empty_db(self):
     show = TVShow(1, 0001, "en")
     ep = TVEpisode(show, 1, 1)
     ep.name = "asdasdasdajkaj"
     ep.saveToDB()
     ep.loadFromDB(1, 1)
     self.assertEqual(ep.name, "asdasdasdajkaj")
Exemple #10
0
 def test_init_empty_db(self):
     show = TVShow(1, 0001, "en")
     show.save_to_db()
     ep = TVEpisode(show, 1, 1)
     ep.name = "asdasdasdajkaj"
     ep.save_to_db()
     ep.load_from_db(1, 1)
     self.assertEqual(ep.name, "asdasdasdajkaj")
Exemple #11
0
    def test(self):
        global searchItems
        searchItems = curData[b"i"]
        show = TVShow(1, tvdbdid)
        show.name = show_name
        show.quality = curData[b"q"]
        show.saveToDB()
        sickrage.showList.append(show)
        episode = None

        for epNumber in curData[b"e"]:
            episode = TVEpisode(show, curData[b"s"], epNumber)
            episode.status = WANTED
            episode.saveToDB()

        bestResult = searchProviders(show, episode.episode, forceSearch)
        if not bestResult:
            self.assertEqual(curData[b"b"], bestResult)
        self.assertEqual(curData[b"b"], bestResult.name)  # first is expected, second is choosen one
Exemple #12
0
    def test(self):
        global searchItems
        searchItems = curData["i"]
        show = TVShow(1, tvdbdid)
        show.name = show_name
        show.quality = curData["q"]
        show.saveToDB()
        show.loadFromDB(skipNFO=True)
        sickrage.srCore.SHOWLIST.append(show)
        episode = None

        for epNumber in curData["e"]:
            episode = TVEpisode(show, curData["s"], epNumber)
            episode.status = WANTED
            episode.saveToDB()

        bestResult = searchProviders(show, episode.episode, forceSearch)
        if not bestResult:
            self.assertEqual(curData["b"], bestResult)
        self.assertEqual(curData["b"], bestResult.name)  # first is expected, second is choosen one
Exemple #13
0
    def test_unaired(self):
        count = 0

        for episode in sickrage.app.main_db.all('tv_episodes'):
            if all([
                    episode['status'] == UNAIRED, episode['season'] > 0,
                    episode['airdate'] > 1
            ]):
                count += 1

                show = helpers.findCertainShow(int(episode["showid"]))

                ep = TVEpisode(show, 1, episode['episode'])
                ep.indexerid = episode['episode']
                ep.name = "test episode {}".format(episode['episode'])
                ep.airdate = datetime.date.fromordinal(733832)
                ep.status = UNAIRED

                ep.saveToDB()

        self.assertEqual(count, 3)
Exemple #14
0
    def test_unaired(self):
        count = 0

        for episode in sickrage.app.main_db.all('tv_episodes'):
            if all([episode['status'] == UNAIRED, episode['season'] > 0, episode['airdate'] > 1]):
                count += 1

                show = helpers.findCertainShow(int(episode["showid"]))

                ep = TVEpisode(show, 1, episode['episode'])
                ep.indexerid = episode['episode']
                ep.name = "test episode {}".format(episode['episode'])
                ep.airdate = datetime.date.fromordinal(733832)
                ep.status = UNAIRED

                ep.save_to_db()

        self.assertEqual(count, 3)
Exemple #15
0
    def test_unaired(self, session=None):
        count = 0

        for episode_obj in session.query(TVEpisode):
            if all([
                    episode_obj.status == UNAIRED, episode_obj.season > 0,
                    episode_obj.airdate > datetime.date.min
            ]):
                count += 1

                ep = TVEpisode(**{
                    'indexer': 1,
                    'episode': episode_obj.episode
                })
                ep.indexer_id = episode_obj.episode
                ep.name = "test episode {}".format(episode_obj.episode)
                ep.airdate = datetime.date.fromordinal(733832)
                ep.status = UNAIRED

        self.assertEqual(count, 3)
Exemple #16
0
    def setUp(self):
        super(DBBasicTests, self).setUp()
        show = TVShow(1, 0001, "en")
        show.saveToDB()
        sickrage.app.showlist += [show]

        ep = TVEpisode(show, 1, 1)
        ep.indexerid = 1
        ep.name = "test episode 1"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        ep.saveToDB()
        ep = TVEpisode(show, 1, 2)
        ep.indexerid = 2
        ep.name = "test episode 2"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        ep.saveToDB()
        ep = TVEpisode(show, 1, 3)
        ep.indexerid = 3
        ep.name = "test episode 3"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        ep.saveToDB()
Exemple #17
0
 def formatted_dir(self, *args, **kwargs):
     return TVEpisode.formatted_dir(self, *args, **kwargs)
Exemple #18
0
    def test(self):
        show = TVShow(1, int(curData[b"tvdbid"]))
        show.name = name
        show.quality = ANY | Quality.UNKNOWN | Quality.RAWHDTV
        show.saveToDB()
        sickrage.showList.append(show)

        for epNumber in curData[b"e"]:
            episode = TVEpisode(show, curData[b"s"], epNumber)
            episode.status = WANTED

            # We arent updating scene numbers, so fake it here
            episode.scene_season = curData[b"s"]
            episode.scene_episode = epNumber

            episode.saveToDB()

            provider.show = show
            season_strings = provider._get_season_search_strings(episode)
            episode_strings = provider._get_episode_search_strings(episode)

            fail = False
            for cur_string in season_strings, episode_strings:
                if not all([
                        isinstance(cur_string, list),
                        isinstance(cur_string[0], dict)
                ]):
                    print(" %s is using a wrong string format!" %
                          provider.name)
                    print(cur_string)
                    fail = True
                    continue

            if fail:
                continue

            try:
                assert (season_strings == curData[b"s_strings"])
                assert (episode_strings == curData[b"e_strings"])
            except AssertionError:
                continue

            search_strings = episode_strings[0]
            # search_strings.update(season_strings[0])
            # search_strings.update({"RSS":['']})

            # print search_strings

            if not provider.public:
                continue

            items = provider._doSearch(search_strings)
            if not items:
                print("No results from provider?")
                continue

            title, url = provider._get_title_and_url(items[0])
            for word in show.name.split(" "):
                if not word.lower() in title.lower():
                    print("Show name not in title: %s. URL: %s" % (title, url))
                    continue

            if not url:
                print("url is empty")
                continue

            quality = provider.getQuality(items[0])
            size = provider._get_size(items[0])
            if not show.quality & quality:
                print("Quality not in ANY, %r" % quality)
                continue
Exemple #19
0
 def _ep_name(self):
     return TVEpisode._ep_name(self)
Exemple #20
0
 def _replace_map(self):
     return TVEpisode._replace_map(self)
Exemple #21
0
    def setUp(self):
        super(DBBasicTests, self).setUp()
        show = TVShow(1, 0001, "en")
        show.save_to_db()
        sickrage.app.showlist += [show]

        ep = TVEpisode(show, 1, 1)
        ep.indexerid = 1
        ep.name = "test episode 1"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        ep.save_to_db()
        ep = TVEpisode(show, 1, 2)
        ep.indexerid = 2
        ep.name = "test episode 2"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        ep.save_to_db()
        ep = TVEpisode(show, 1, 3)
        ep.indexerid = 3
        ep.name = "test episode 3"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        ep.save_to_db()
Exemple #22
0
    def make_ep_from_file(self, filename):
        if not os.path.isfile(filename):
            sickrage.app.log.info(
                str(self.indexer_id) +
                ": That isn't even a real file dude... " + filename)
            return None

        sickrage.app.log.debug(
            str(self.indexer_id) + ": Creating episode object from " +
            filename)

        try:
            parse_result = NameParser(validate_show=False).parse(
                filename, skip_scene_detection=True)
        except InvalidNameException:
            sickrage.app.log.debug("Unable to parse the filename " + filename +
                                   " into a valid episode")
            return None
        except InvalidShowException:
            sickrage.app.log.debug("Unable to parse the filename " + filename +
                                   " into a valid show")
            return None

        if not len(parse_result.episode_numbers):
            sickrage.app.log.info("parse_result: " + str(parse_result))
            sickrage.app.log.warning("No episode number found in " + filename +
                                     ", ignoring it")
            return None

        # for now lets assume that any episode in the show dir belongs to that show
        season = parse_result.season_number if parse_result.season_number is not None else 1
        root_ep = None

        for curEpNum in parse_result.episode_numbers:
            episode = int(curEpNum)

            sickrage.app.log.debug("%s: %s parsed to %s S%02dE%02d" %
                                   (self.indexer_id, filename, self.name,
                                    season or 0, episode or 0))

            check_quality_again = False

            try:
                episode_obj = self.get_episode(season, episode)
            except EpisodeNotFoundException:
                object_session(self).add(
                    TVEpisode(
                        **{
                            'showid': self.indexer_id,
                            'indexer': self.indexer,
                            'season': season,
                            'episode': episode,
                            'location': filename
                        }))
                object_session(self).commit()
                episode_obj = self.get_episode(season, episode)

            # if there is a new file associated with this ep then re-check the quality
            if episode_obj.location and os.path.normpath(
                    episode_obj.location) != os.path.normpath(filename):
                sickrage.app.log.debug(
                    "The old episode had a different file associated with it, I will re-check "
                    "the quality based on the new filename " + filename)
                check_quality_again = True

            # if the sizes are the same then it's probably the same file
            old_size = episode_obj.file_size
            episode_obj.location = filename
            same_file = old_size and episode_obj.file_size == old_size
            episode_obj.checkForMetaFiles()

            if root_ep is None:
                root_ep = episode_obj
            else:
                if episode_obj not in root_ep.related_episodes:
                    root_ep.related_episodes.append(episode_obj)

            # if it's a new file then
            if not same_file:
                episode_obj.release_name = ''

            # if they replace a file on me I'll make some attempt at re-checking the quality unless I know it's the
            # same file
            if check_quality_again and not same_file:
                new_quality = Quality.name_quality(filename, self.is_anime)
                sickrage.app.log.debug("Since this file has been renamed")

                episode_obj.status = Quality.composite_status(
                    DOWNLOADED, new_quality)

            # check for status/quality changes as long as it's a new file
            elif not same_file and is_media_file(
                    filename
            ) and episode_obj.status not in Quality.DOWNLOADED + Quality.ARCHIVED + [
                    IGNORED
            ]:
                old_status, old_quality = Quality.split_composite_status(
                    episode_obj.status)
                new_quality = Quality.name_quality(filename, self.is_anime)

                new_status = None

                # if it was snatched and now exists then set the status correctly
                if old_status == SNATCHED and old_quality <= new_quality:
                    sickrage.app.log.debug(
                        "STATUS: this ep used to be snatched with quality " +
                        Quality.qualityStrings[old_quality] +
                        " but a file exists with quality " +
                        Quality.qualityStrings[new_quality] +
                        " so I'm setting the status to DOWNLOADED")
                    new_status = DOWNLOADED

                # if it was snatched proper and we found a higher quality one then allow the status change
                elif old_status == SNATCHED_PROPER and old_quality < new_quality:
                    sickrage.app.log.debug(
                        "STATUS: this ep used to be snatched proper with quality "
                        + Quality.qualityStrings[old_quality] +
                        " but a file exists with quality " +
                        Quality.qualityStrings[new_quality] +
                        " so I'm setting the status to DOWNLOADED")
                    new_status = DOWNLOADED

                elif old_status not in (SNATCHED, SNATCHED_PROPER):
                    new_status = DOWNLOADED

                if new_status is not None:
                    sickrage.app.log.debug(
                        "STATUS: we have an associated file, so setting the status from "
                        + str(episode_obj.status) + " to DOWNLOADED/" + str(
                            Quality.status_from_name(filename,
                                                     anime=self.is_anime)))
                    episode_obj.status = Quality.composite_status(
                        new_status, new_quality)

        # creating metafiles on the root should be good enough
        if root_ep:
            root_ep.create_meta_files()

        object_session(self).commit()

        return root_ep
Exemple #23
0
    def setUp(self, session=None):
        super(DBBasicTests, self).setUp()
        show = TVShow(**{'indexer': 1, 'indexer_id': 0o0001, 'lang': 'en'})
        session.add(show)
        session.safe_commit()

        ep = TVEpisode(
            **{
                'showid': show.indexer_id,
                'indexer': 1,
                'season': 1,
                'episode': 1,
                'location': ''
            })
        session.add(ep)
        ep.indexer_id = 1
        ep.name = "test episode 1"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        session.safe_commit()

        ep = TVEpisode(
            **{
                'showid': show.indexer_id,
                'indexer': 1,
                'season': 1,
                'episode': 2,
                'location': ''
            })
        session.add(ep)
        ep.indexer_id = 2
        ep.name = "test episode 2"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        session.safe_commit()

        ep = TVEpisode(
            **{
                'showid': show.indexer_id,
                'indexer': 1,
                'season': 1,
                'episode': 3,
                'location': ''
            })
        session.add(ep)
        ep.indexer_id = 3
        ep.name = "test episode 3"
        ep.airdate = datetime.date.fromordinal(733832)
        ep.status = UNAIRED
        session.safe_commit()
Exemple #24
0
 def _format_string(self, *args, **kwargs):
     return TVEpisode._format_string(self, *args, **kwargs)
Exemple #25
0
 def formatted_filename(self, *args, **kwargs):
     return TVEpisode.formatted_filename(self, *args, **kwargs)
    def test(self):
        show = TVShow(1, int(curData["tvdbid"]))
        show.name = name
        show.quality = ANY | Quality.UNKNOWN | Quality.RAWHDTV
        show.saveToDB()
        show.loadFromDB(skipNFO=True)

        sickrage.srCore.SHOWLIST.append(show)

        for epNumber in curData["e"]:
            episode = TVEpisode(show, curData["s"], epNumber)
            episode.status = WANTED

            # We arent updating scene numbers, so fake it here
            episode.scene_season = curData["s"]
            episode.scene_episode = epNumber

            episode.saveToDB()

            provider.show = show
            season_strings = provider._get_season_search_strings(episode)
            episode_strings = provider._get_episode_search_strings(episode)

            fail = False
            for cur_string in season_strings, episode_strings:
                if not all([isinstance(cur_string, list), isinstance(cur_string[0], dict)]):
                    print(" %s is using a wrong string format!" % provider.name)
                    print(cur_string)
                    fail = True
                    continue

            if fail:
                continue

            try:
                assert (season_strings == curData["s_strings"])
                assert (episode_strings == curData["e_strings"])
            except AssertionError:
                continue

            search_strings = episode_strings[0]
            # search_strings.update(season_strings[0])
            # search_strings.update({"RSS":['']})

            # print search_strings

            if not provider.public:
                continue

            items = provider.search(search_strings)
            if not items:
                print("No results from provider?")
                continue

            title, url = provider._get_title_and_url(items[0])
            for word in show.name.split(" "):
                if not word.lower() in title.lower():
                    print("Show name not in title: %s. URL: %s" % (title, url))
                    continue

            if not url:
                print("url is empty")
                continue

            quality = provider.getQuality(items[0])
            size = provider._get_size(items[0])
            if not show.quality & quality:
                print("Quality not in ANY, %r" % quality)
                continue
Exemple #27
0
 def test_init_empty_db(self):
     show = TVShow(0o001, 1)
     ep = TVEpisode(show, 1, 1, 1)
     ep.name = "asdasdasdajkaj"
     ep.save()
     self.assertEqual(ep.name, "asdasdasdajkaj")
Exemple #28
0
 def _format_pattern(self, *args, **kwargs):
     return TVEpisode._format_pattern(self, *args, **kwargs)