示例#1
0
    def test_cache(self, mocked_expired, execute_task):
        persist['auth_tokens'] = {'default': None}

        task = execute_task('test_search_cache')
        entry = task.find_entry(tvdb_id=73255)

        # Force tvdb lazy eval
        assert entry['afield']

        with Session() as session:
            # Ensure search cache was added
            search_results = session.query(TVDBSearchResult).all()

            assert len(search_results) == 3

            aliases = ['house', 'house m.d.', 'house md']

            for search_result in search_results:
                assert search_result.series
                assert search_result.search in aliases

            # No requests should be sent as we restore from cache
            with mock.patch('requests.sessions.Session.request',
                            side_effect=Exception('TVDB should restore from cache')) as _:
                lookup_series('house m.d.', session=session)
示例#2
0
    def test_cache(self, mocked_expired, execute_task):
        persist['auth_tokens'] = {'default': None}

        task = execute_task('test_search_cache')
        entry = task.find_entry(tvdb_id=73255)

        # Force tvdb lazy eval
        assert entry['afield']

        with Session() as session:
            # Ensure search cache was added
            search_results = session.query(TVDBSearchResult).all()

            assert len(search_results) == 3

            aliases = ['house', 'house m.d.', 'house md']

            for search_result in search_results:
                assert search_result.series
                assert search_result.search in aliases

            # No requests should be sent as we restore from cache
            with mock.patch('requests.sessions.Session.request',
                            side_effect=Exception(
                                'TVDB should restore from cache')) as _:
                lookup_series('house m.d.', session=session)
示例#3
0
    def get(self, search, session=None):
        try:
            tvdb_id = int(search)
        except ValueError:
            tvdb_id = None

        try:
            if tvdb_id:
                result = lookup_series(tvdb_id=tvdb_id, session=session)
            else:
                result = lookup_series(name=search, session=session)
        except LookupError as e:
            return {'status': 'error', 'message': e.args[0]}, 404

        return jsonify(result.to_dict())
示例#4
0
    def lookup_myepisodes_id(self, entry, opener, session):
        """Populates myepisodes_id field for an entry, and returns the id.

        Call will also set entry field `myepisode_id` if successful.

        Return:
            myepisode id

        Raises:
            LookupError if entry does not have field series_name
        """

        # Don't need to look it up if we already have it.
        if entry.get("myepisodes_id"):
            return entry["myepisodes_id"]

        if not entry.get("series_name"):
            raise LookupError("Cannot lookup myepisodes id for entries without series_name")
        series_name = entry["series_name"]

        # First check if we already have a myepisodes id stored for this series
        myepisodes_info = (
            session.query(MyEpisodesInfo).filter(MyEpisodesInfo.series_name == series_name.lower()).first()
        )
        if myepisodes_info:
            entry["myepisodes_id"] = myepisodes_info.myepisodes_id
            return myepisodes_info.myepisodes_id

        # Get the series name from thetvdb to increase match chance on myepisodes
        if entry.get("series_name_tvdb"):
            query_name = entry["series_name_tvdb"]
        else:
            try:
                series = lookup_series(name=series_name, tvdb_id=entry.get("thetvdb_id"))
                query_name = series.seriesname
            except LookupError as e:
                log.warning("Unable to lookup series `%s` from tvdb, using raw name." % series_name)
                query_name = series_name

        baseurl = urllib2.Request("http://myepisodes.com/search.php?")
        params = urllib.urlencode({"tvshow": query_name, "action": "Search myepisodes.com"})
        try:
            con = opener.open(baseurl, params)
            txt = con.read()
        except urllib2.URLError as e:
            log.error("Error searching for myepisodes id: %s" % e)

        matchObj = re.search(r'&showid=([0-9]*)">' + query_name + "</a>", txt, re.MULTILINE | re.IGNORECASE)
        if matchObj:
            myepisodes_id = matchObj.group(1)
            db_item = session.query(MyEpisodesInfo).filter(MyEpisodesInfo.myepisodes_id == myepisodes_id).first()
            if db_item:
                log.info(
                    "Changing name to `%s` for series with myepisodes_id %s" % (series_name.lower(), myepisodes_id)
                )
                db_item.series_name = series_name.lower()
            else:
                session.add(MyEpisodesInfo(series_name.lower(), myepisodes_id))
            entry["myepisodes_id"] = myepisodes_id
            return myepisodes_id
示例#5
0
 def items(self):
     if self._items is None:
         try:
             req = TVDBRequest(username=self.config['username'], account_id=self.config['account_id']).get(
                 'user/favorites')
             series_ids = [int(f_id) for f_id in req['favorites'] if f_id != '']
         except RequestException as e:
             raise PluginError('Error retrieving favorites from thetvdb: %s' % str(e))
         self._items = []
         for series_id in series_ids:
             # Lookup the series name from the id
             try:
                 series = lookup_series(tvdb_id=series_id)
             except LookupError as e:
                 log.error('Error looking up %s from thetvdb: %s' % (series_id, e.args[0]))
             else:
                 series_name = series.name
                 if self.config.get('strip_dates'):
                     # Remove year from end of series name if present
                     series_name, _ = split_title_year(series_name)
                 entry = Entry()
                 entry['title'] = entry['series_name'] = series_name
                 entry['url'] = 'http://thetvdb.com/index.php?tab=series&id={}'.format(str(series.id))
                 entry['tvdb_id'] = str(series.id)
                 self._items.append(entry)
     return self._items
示例#6
0
 def items(self):
     if self._items is None:
         try:
             req = TVDBRequest(
                 username=self.config['username'],
                 account_id=self.config['account_id']).get('user/favorites')
             series_ids = [
                 int(f_id) for f_id in req['favorites'] if f_id != ''
             ]
         except RequestException as e:
             raise PluginError(
                 'Error retrieving favorites from thetvdb: %s' % str(e))
         self._items = []
         for series_id in series_ids:
             # Lookup the series name from the id
             try:
                 series = lookup_series(tvdb_id=series_id)
             except LookupError as e:
                 log.error('Error looking up %s from thetvdb: %s' %
                           (series_id, e.args[0]))
             else:
                 series_name = series.name
                 if self.config.get('strip_dates'):
                     # Remove year from end of series name if present
                     series_name, _ = split_title_year(series_name)
                 entry = Entry()
                 entry['title'] = entry['series_name'] = series_name
                 entry[
                     'url'] = 'http://thetvdb.com/index.php?tab=series&id={}'.format(
                         str(series.id))
                 entry['tvdb_id'] = str(series.id)
                 self._items.append(entry)
     return self._items
示例#7
0
    def get(self, search, session=None):
        try:
            tvdb_id = int(search)
        except ValueError:
            tvdb_id = None

        try:
            if tvdb_id:
                result = lookup_series(tvdb_id=tvdb_id, session=session)
            else:
                result = lookup_series(name=search, session=session)
        except LookupError as e:
            return {'status': 'error',
                    'message': e.args[0]
                    }, 404

        return jsonify(result.to_dict())
示例#8
0
    def lookup_myepisodes_id(self, entry, opener, session):
        """Populates myepisodes_id field for an entry, and returns the id.

        Call will also set entry field `myepisode_id` if successful.

        Return:
            myepisode id

        Raises:
            LookupError if entry does not have field series_name
        """

        # Don't need to look it up if we already have it.
        if entry.get('myepisodes_id'):
            return entry['myepisodes_id']

        if not entry.get('series_name'):
            raise LookupError('Cannot lookup myepisodes id for entries without series_name')
        series_name = entry['series_name']

        # First check if we already have a myepisodes id stored for this series
        myepisodes_info = session.query(MyEpisodesInfo).\
            filter(MyEpisodesInfo.series_name == series_name.lower()).first()
        if myepisodes_info:
            entry['myepisodes_id'] = myepisodes_info.myepisodes_id
            return myepisodes_info.myepisodes_id

        # Get the series name from thetvdb to increase match chance on myepisodes
        if entry.get('tvdb_series_name'):
            query_name = entry['tvdb_series_name']
        else:
            try:
                series = lookup_series(name=series_name, tvdb_id=entry.get('tvdb_id'))
                query_name = series.seriesname
            except LookupError as e:
                log.warning('Unable to lookup series `%s` from tvdb, using raw name.' % series_name)
                query_name = series_name

        baseurl = request.Request('http://www.myepisodes.com/search.php?')
        params = parse.urlencode({'tvshow': query_name, 'action': 'Search myepisodes.com'})
        try:
            con = opener.open(baseurl, params)
            txt = con.read()
        except URLError as e:
            log.error('Error searching for myepisodes id: %s' % e)

        matchObj = re.search(r'&showid=([0-9]*)">' + query_name + '</a>', txt, re.MULTILINE | re.IGNORECASE)
        if matchObj:
            myepisodes_id = matchObj.group(1)
            db_item = session.query(MyEpisodesInfo).filter(MyEpisodesInfo.myepisodes_id == myepisodes_id).first()
            if db_item:
                log.info('Changing name to `%s` for series with myepisodes_id %s' %
                    (series_name.lower(), myepisodes_id))
                db_item.series_name = series_name.lower()
            else:
                session.add(MyEpisodesInfo(series_name.lower(), myepisodes_id))
            entry['myepisodes_id'] = myepisodes_id
            return myepisodes_id
示例#9
0
    def lookup_myepisodes_id(self, entry, opener, session):
        """Populates myepisodes_id field for an entry, and returns the id.

        Call will also set entry field `myepisode_id` if successful.

        Return:
            myepisode id

        Raises:
            LookupError if entry does not have field series_name
        """

        # Don't need to look it up if we already have it.
        if entry.get('myepisodes_id'):
            return entry['myepisodes_id']

        if not entry.get('series_name'):
            raise LookupError('Cannot lookup myepisodes id for entries without series_name')
        series_name = entry['series_name']

        # First check if we already have a myepisodes id stored for this series
        myepisodes_info = session.query(MyEpisodesInfo).\
            filter(MyEpisodesInfo.series_name == series_name.lower()).first()
        if myepisodes_info:
            entry['myepisodes_id'] = myepisodes_info.myepisodes_id
            return myepisodes_info.myepisodes_id

        # Get the series name from thetvdb to increase match chance on myepisodes
        if entry.get('tvdb_series_name'):
            query_name = entry['tvdb_series_name']
        else:
            try:
                series = lookup_series(name=series_name, tvdb_id=entry.get('tvdb_id'))
                query_name = series.seriesname
            except LookupError as e:
                log.warning('Unable to lookup series `%s` from tvdb, using raw name.' % series_name)
                query_name = series_name

        baseurl = request.Request('http://www.myepisodes.com/search.php?')
        params = parse.urlencode({'tvshow': query_name, 'action': 'Search myepisodes.com'})
        try:
            con = opener.open(baseurl, params)
            txt = con.read()
        except URLError as e:
            log.error('Error searching for myepisodes id: %s' % e)

        matchObj = re.search(r'&showid=([0-9]*)">' + query_name + '</a>', txt, re.MULTILINE | re.IGNORECASE)
        if matchObj:
            myepisodes_id = matchObj.group(1)
            db_item = session.query(MyEpisodesInfo).filter(MyEpisodesInfo.myepisodes_id == myepisodes_id).first()
            if db_item:
                log.info('Changing name to `%s` for series with myepisodes_id %s' %
                    (series_name.lower(), myepisodes_id))
                db_item.series_name = series_name.lower()
            else:
                session.add(MyEpisodesInfo(series_name.lower(), myepisodes_id))
            entry['myepisodes_id'] = myepisodes_id
            return myepisodes_id
示例#10
0
    def get(self, title, session=None):
        args = series_parser.parse_args()
        try:
            tvdb_id = int(title)
        except ValueError:
            tvdb_id = None

        try:
            if tvdb_id:
                series = lookup_series(tvdb_id=tvdb_id, session=session)
            else:
                series = lookup_series(name=title, session=session)
        except LookupError as e:
            return {'status': 'error', 'message': e.args[0]}, 404
        result = series.to_dict()
        if args.get('include_actors'):
            result['actors'] = series.actors
        return jsonify(result)
示例#11
0
 def lazy_series_lookup(self, entry):
     """Does the lookup for this entry and populates the entry fields."""
     try:
         with Session(expire_on_commit=False) as session:
             series = lookup_series(entry.get('series_name', eval_lazy=False),
                                    tvdb_id=entry.get('tvdb_id', eval_lazy=False), session=session)
             entry.update_using_map(self.series_map, series)
     except LookupError as e:
         log.debug('Error looking up tvdb series information for %s: %s' % (entry['title'], e.args[0]))
示例#12
0
 def lazy_series_lookup(self, entry, field):
     """Does the lookup for this entry and populates the entry fields."""
     try:
         series = lookup_series(entry.get('series_name', eval_lazy=False), tvdb_id=entry.get('thetvdb_id', eval_lazy=False))
         entry.update_using_map(self.series_map, series)
     except LookupError, e:
         log.debug('Error looking up tvdb series information for %s: %s' % (entry['title'], e.message))
         entry.unregister_lazy_fields(self.series_map, self.lazy_series_lookup)
         # Also clear episode fields, since episode lookup cannot succeed without series lookup
         entry.unregister_lazy_fields(self.episode_map, self.lazy_episode_lookup)
示例#13
0
    def get(self, title, session=None):
        args = series_parser.parse_args()
        try:
            tvdb_id = int(title)
        except ValueError:
            tvdb_id = None

        try:
            if tvdb_id:
                series = lookup_series(tvdb_id=tvdb_id, session=session)
            else:
                series = lookup_series(name=title, session=session)
        except LookupError as e:
            return {'status': 'error',
                    'message': e.args[0]
                    }, 404
        result = series.to_dict()
        if args.get('include_actors'):
            result['actors'] = series.actors
        return jsonify(result)
示例#14
0
 def series_lookup(self, entry, field_map, session=None):
     try:
         series = lookup_series(entry.get('series_name', eval_lazy=False),
                                tvdb_id=entry.get('tvdb_id',
                                                  eval_lazy=False),
                                session=session)
         entry.update_using_map(field_map, series)
     except LookupError as e:
         log.debug('Error looking up tvdb series information for %s: %s' %
                   (entry['title'], e.args[0]))
     return entry
示例#15
0
 def series_lookup(self, entry, field_map, session=None):
     try:
         series = lookup_series(
             entry.get('series_name', eval_lazy=False),
             tvdb_id=entry.get('tvdb_id', eval_lazy=False),
             session=session
         )
         entry.update_using_map(field_map, series)
     except LookupError as e:
         log.debug('Error looking up tvdb series information for %s: %s' % (entry['title'], e.args[0]))
     return entry
示例#16
0
    def on_task_input(self, task, config, session=None):
        account_id = str(config['account_id'])
        # Get the cache for this user
        user_favorites = session.query(ThetvdbFavorites).filter(
            ThetvdbFavorites.account_id == account_id).first()
        if user_favorites and user_favorites.updated > datetime.now(
        ) - timedelta(minutes=10):
            log.debug(
                'Using cached thetvdb favorite series information for account ID %s'
                % account_id)
        else:
            try:
                url = 'http://thetvdb.com/api/User_Favorites.php?accountid=%s' % account_id
                log.debug('requesting %s' % url)
                data = ElementTree.fromstring(urlopener(url, log).read())
                favorite_ids = []
                for i in data.findall('Series'):
                    if i.text:
                        favorite_ids.append(i.text)
            except (urllib2.URLError, IOError, AttributeError):
                import traceback
                # If there are errors getting the favorites or parsing the xml, fall back on cache
                log.error(
                    'Error retrieving favorites from thetvdb, using cache.')
                log.debug(traceback.format_exc())
            else:
                # Successfully updated from tvdb, update the database
                log.debug('Successfully updated favorites from thetvdb.com')
                if not user_favorites:
                    user_favorites = ThetvdbFavorites(account_id, favorite_ids)
                else:
                    user_favorites.series_ids = favorite_ids
                    user_favorites.updated = datetime.now()
                session.merge(user_favorites)
        if not user_favorites.series_ids:
            log.warning('Didn\'t find any thetvdb.com favorites.')
            return

        # Construct list of entries with our series names
        entries = []
        for series_id in user_favorites.series_ids:
            # Lookup the series name from the id
            try:
                series = lookup_series(tvdb_id=series_id)
            except LookupError as e:
                log.error('Error looking up %s from thetvdb: %s' %
                          (series_id, e.message))
            else:
                series_name = series.seriesname
                if config.get('strip_dates'):
                    # Remove year from end of series name if present
                    series_name = re.sub(r'\s+\(\d{4}\)$', '', series_name)
                entries.append(Entry(series_name, '', tvdb_id=series.id))
        return entries
示例#17
0
    def on_task_input(self, task, config):
        account_id = str(config['account_id'])
        favorite_ids = []
        # Get the cache for this user
        with Session() as session:
            user_favorites = session.query(ThetvdbFavorites).filter(ThetvdbFavorites.account_id == account_id).first()
            if user_favorites:
                favorite_ids = user_favorites.series_ids
            if user_favorites and user_favorites.updated > datetime.now() - timedelta(minutes=10):
                log.debug('Using cached thetvdb favorite series information for account ID %s' % account_id)
            else:
                try:
                    url = 'http://thetvdb.com/api/User_Favorites.php?accountid=%s' % account_id
                    log.debug('requesting %s' % url)
                    data = ElementTree.fromstring(urlopener(url, log).read())
                    favorite_ids = []
                    for i in data.findall('Series'):
                        if i.text:
                            favorite_ids.append(i.text)
                except (urllib2.URLError, IOError, AttributeError):
                    import traceback
                    # If there are errors getting the favorites or parsing the xml, fall back on cache
                    log.error('Error retrieving favorites from thetvdb, using cache.')
                    log.debug(traceback.format_exc())
                else:
                    # Successfully updated from tvdb, update the database
                    log.debug('Successfully updated favorites from thetvdb.com')
                    if not user_favorites:
                        user_favorites = ThetvdbFavorites(account_id, favorite_ids)
                    else:
                        user_favorites.series_ids = favorite_ids
                        user_favorites.updated = datetime.now()
                    session.merge(user_favorites)
        if not favorite_ids:
            log.warning('Didn\'t find any thetvdb.com favorites.')
            return

        # Construct list of entries with our series names
        entries = []
        for series_id in favorite_ids:
            # Lookup the series name from the id
            try:
                series = lookup_series(tvdb_id=series_id)
            except LookupError as e:
                log.error('Error looking up %s from thetvdb: %s' % (series_id, e.args[0]))
            else:
                series_name = series.seriesname
                if config.get('strip_dates'):
                    # Remove year from end of series name if present
                    series_name = re.sub(r'\s+\(\d{4}\)$', '', series_name)
                entries.append(Entry(series_name, '', tvdb_id=series.id))
        return entries
示例#18
0
    def lazy_series_lookup(self, entry, field):
        """Does the lookup for this entry and populates the entry fields."""
        try:
            with Session(expire_on_commit=False) as session:
                series = lookup_series(entry.get('series_name', eval_lazy=False),
                                       tvdb_id=entry.get('tvdb_id', eval_lazy=False), session=session)
                entry.update_using_map(self.series_map, series)
        except LookupError as e:
            log.debug('Error looking up tvdb series information for %s: %s' % (entry['title'], e.args[0]))
            entry.unregister_lazy_fields(self.series_map, self.lazy_series_lookup)
            # Also clear episode fields, since episode lookup cannot succeed without series lookup
            entry.unregister_lazy_fields(self.episode_map, self.lazy_episode_lookup)

        return entry[field]
示例#19
0
    def on_task_input(self, task, config, session=None):
        account_id = str(config["account_id"])
        # Get the cache for this user
        user_favorites = session.query(ThetvdbFavorites).filter(ThetvdbFavorites.account_id == account_id).first()
        if user_favorites and user_favorites.updated > datetime.now() - timedelta(minutes=10):
            log.debug("Using cached thetvdb favorite series information for account ID %s" % account_id)
        else:
            try:
                url = "http://thetvdb.com/api/User_Favorites.php?accountid=%s" % account_id
                log.debug("requesting %s" % url)
                data = BeautifulStoneSoup(urlopener(url, log))
                favorite_ids = []
                for i in data.favorites.findAll("series", recursive=False):
                    if i.string:
                        favorite_ids.append(i.string)
            except (urllib2.URLError, IOError, AttributeError):
                import traceback

                # If there are errors getting the favorites or parsing the xml, fall back on cache
                log.error("Error retrieving favorites from thetvdb, using cache.")
                log.debug(traceback.format_exc())
            else:
                # Successfully updated from tvdb, update the database
                log.debug("Successfully updated favorites from thetvdb.com")
                if not user_favorites:
                    user_favorites = ThetvdbFavorites(account_id, favorite_ids)
                else:
                    user_favorites.series_ids = favorite_ids
                    user_favorites.updated = datetime.now()
                session.merge(user_favorites)
        if not user_favorites.series_ids:
            log.warning("Didn't find any thetvdb.com favorites.")
            return

        # Construct list of entries with our series names
        entries = []
        for series_id in user_favorites.series_ids:
            # Lookup the series name from the id
            try:
                series = lookup_series(tvdb_id=series_id)
            except LookupError as e:
                log.error("Error looking up %s from thetvdb: %s" % (series_id, e.message))
            else:
                series_name = series.seriesname
                if config.get("strip_dates"):
                    # Remove year from end of series name if present
                    series_name = re.sub(r"\s+\(\d{4}\)$", "", series_name)
                entries.append(Entry(series_name, "", tvdb_id=series.id))
        return entries
示例#20
0
    def on_task_input(self, task, config, session=None):

        # Get the cache for this user
        user_favorites = session.query(TVDBUserFavorite).filter(
            TVDBUserFavorite.username == config['username']).first()

        if not user_favorites:
            user_favorites = TVDBUserFavorite(username=config['username'])
            session.add(user_favorites)

        if user_favorites.updated and user_favorites.updated > datetime.now(
        ) - timedelta(minutes=10):
            log.debug(
                'Using cached thetvdb favorite series information for account %s'
                % config['username'])
        else:
            try:
                req = TVDBRequest(
                    username=config['username'],
                    account_id=config['account_id']).get('user/favorites')
                user_favorites.series_ids = [
                    int(f_id) for f_id in req['favorites']
                ]
            except RequestException as e:
                log.error('Error retrieving favorites from thetvdb: %s' %
                          str(e))

            # Successfully updated from tvdb, update the database
            user_favorites.updated = datetime.now()

        # Construct list of entries with our series names
        entries = []
        for series_id in user_favorites.series_ids:
            # Lookup the series name from the id
            try:
                series = lookup_series(tvdb_id=series_id)
            except LookupError as e:
                log.error('Error looking up %s from thetvdb: %s' %
                          (series_id, e.args[0]))
            else:
                series_name = series.name
                if config.get('strip_dates'):
                    # Remove year from end of series name if present
                    series_name = re.sub(r'\s+\(\d{4}\)$', '', series_name)
                entries.append(Entry(series_name, '', tvdb_id=series.id))
        return entries
示例#21
0
    def lookup_myepisodes_id(self, entry, opener, session):
        """Populates myepisodes_id field for an entry, and returns the id.

        Call will also set entry field `myepisode_id` if successful.

        Return:
            myepisode id

        Raises:
            LookupError if entry does not have field series_name
        """

        # Don't need to look it up if we already have it.
        if entry.get('myepisodes_id'):
            return entry['myepisodes_id']

        if not entry.get('series_name'):
            raise LookupError(
                'Cannot lookup myepisodes id for entries without series_name')
        series_name = entry['series_name']

        # First check if we already have a myepisodes id stored for this series
        myepisodes_info = session.query(MyEpisodesInfo).filter(
            MyEpisodesInfo.series_name == series_name.lower()).first()
        if myepisodes_info:
            entry['myepisodes_id'] = myepisodes_info.myepisodes_id
            return myepisodes_info.myepisodes_id

        # Get the series name from thetvdb to increase match chance on myepisodes
        if entry.get('series_name_tvdb'):
            query_name = entry['series_name_tvdb']
        else:
            try:
                series = lookup_series(name=series_name,
                                       tvdb_id=entry.get('thetvdb_id'))
                query_name = series.seriesname
            except LookupError, e:
                log.warning(
                    'Unable to lookup series `%s` from tvdb, using raw name.' %
                    series_name)
                query_name = series_name
示例#22
0
    def lookup_myepisodes_id(self, entry, opener, session):
        """Populates myepisodes_id field for an entry, and returns the id.

        Call will also set entry field `myepisode_id` if successful.

        Return:
            myepisode id

        Raises:
            LookupError if entry does not have field series_name
        """

        # Don't need to look it up if we already have it.
        if entry.get('myepisodes_id'):
            return entry['myepisodes_id']

        if not entry.get('series_name'):
            raise LookupError('Cannot lookup myepisodes id for entries without series_name')
        series_name = entry['series_name']

        # First check if we already have a myepisodes id stored for this series
        myepisodes_info = session.query(MyEpisodesInfo).filter(MyEpisodesInfo.series_name == series_name.lower()).first()
        if myepisodes_info:
            entry['myepisodes_id'] = myepisodes_info.myepisodes_id
            return myepisodes_info.myepisodes_id

        # Get the series name from thetvdb to increase match chance on myepisodes
        if entry.get('series_name_tvdb'):
            query_name = entry['series_name_tvdb']
        else:
            try:
                series = lookup_series(name=series_name, tvdb_id=entry.get('thetvdb_id'))
                query_name = series.seriesname
            except LookupError, e:
                log.warning('Unable to lookup series `%s` from tvdb, using raw name.' % series_name)
                query_name = series_name
示例#23
0
    def on_task_input(self, task, config, session=None):

        # Get the cache for this user
        user_favorites = session.query(TVDBUserFavorite).filter(TVDBUserFavorite.username == config['username']).first()

        if not user_favorites:
            user_favorites = TVDBUserFavorite(username=config['username'])
            session.add(user_favorites)

        if user_favorites.updated and user_favorites.updated > datetime.now() - timedelta(minutes=10):
            log.debug('Using cached thetvdb favorite series information for account %s' % config['username'])
        else:
            try:
                req = TVDBRequest(username=config['username'], account_id=config['account_id']).get('user/favorites')
                user_favorites.series_ids = [int(f_id) for f_id in req['favorites']]
            except RequestException as e:
                log.error('Error retrieving favorites from thetvdb: %s' % str(e))

            # Successfully updated from tvdb, update the database
            user_favorites.updated = datetime.now()

        # Construct list of entries with our series names
        entries = []
        for series_id in user_favorites.series_ids:
            # Lookup the series name from the id
            try:
                series = lookup_series(tvdb_id=series_id)
            except LookupError as e:
                log.error('Error looking up %s from thetvdb: %s' % (series_id, e.args[0]))
            else:
                series_name = series.name
                if config.get('strip_dates'):
                    # Remove year from end of series name if present
                    series_name = re.sub(r'\s+\(\d{4}\)$', '', series_name)
                entries.append(Entry(series_name, '', tvdb_id=series.id))
        return entries
示例#24
0
 def on_task_input(self, task, config):
     """Creates an entry for each item in your uoccin watchlist.
     
     Example::
         
         from_uoccin:
           path: /path/to/gdrive/uoccin
           type: series
           tags: [ 'favorite', 'hires' ]
           check_tags: all
     
     Options path and type are required while the others are for filtering:
     - 'any' will include all the items marked with one or more tags in the list
     - 'all' will only include the items marked with all the listed tags
     - 'none' will only include the items not marked with any of the listed tags.
     
     The entries created will have a valid imdb/tvdb url and id.
     """
     imdb_lookup = plugin.get_plugin_by_name('imdb_lookup').instance
     udata = load_uoccin_data(config['path'])
     section = udata['movies'] if config['type'] == 'movies' else udata['series']
     entries = []
     for eid, itm in list(section.items()):
         if not itm['watchlist']:
             continue
         if 'tags' in config:
             n = len(set(config['tags']) & set(itm.get('tags', [])))
             if config['check_tags'] == 'any' and n <= 0:
                 continue
             if config['check_tags'] == 'all' and n != len(config['tags']):
                 continue
             if config['check_tags'] == 'none' and n > 0:
                 continue
         if config['type'] == 'movies':
             entry = Entry()
             entry['url'] = 'http://www.imdb.com/title/' + eid
             entry['imdb_id'] = eid
             if itm['name'] != 'N/A':
                 entry['title'] = itm['name']
             else:
                 try:
                     imdb_lookup.lookup(entry)
                 except plugin.PluginError as e:
                     self.log.trace('entry %s imdb failed (%s)' % (entry['imdb_id'], e.value))
                     continue
                 entry['title'] = entry.get('imdb_name')
             if 'tags' in itm:
                 entry['uoccin_tags'] = itm['tags']
             if entry.isvalid():
                 entries.append(entry)
             else:
                 self.log.debug('Invalid entry created? %s' % entry)
         else:
             sname = itm['name']
             try:
                 sname = lookup_series(tvdb_id=eid).seriesname
             except LookupError:
                 self.log.warning('Unable to lookup series %s from tvdb, using raw name.' % eid)
             surl = 'http://thetvdb.com/?tab=series&id=' + eid
             if config['type'] == 'series':
                 entry = Entry()
                 entry['url'] = surl
                 entry['title'] = sname
                 entry['tvdb_id'] = eid
                 if 'tags' in itm:
                     entry['uoccin_tags'] = itm['tags']
                 if entry.isvalid():
                     entries.append(entry)
                 else:
                     self.log.debug('Invalid entry created? %s' % entry)
             elif config['ep_flags'] == 'collected':
                 slist = itm.get('collected', {})
                 for sno in list(slist.keys()):
                     for eno in slist[sno]:
                         entry = Entry()
                         entry['url'] = surl
                         entry['title'] = '%s S%02dE%02d' % (sname, int(sno), int(eno))
                         entry['tvdb_id'] = eid
                         if entry.isvalid():
                             entries.append(entry)
                         else:
                             self.log.debug('Invalid entry created? %s' % entry)
             else:
                 slist = itm.get('watched', {})
                 for sno in list(slist.keys()):
                     for eno in slist[sno]:
                         entry = Entry()
                         entry['url'] = surl
                         entry['title'] = '%s S%02dE%02d' % (sname, int(sno), eno)
                         entry['tvdb_id'] = eid
                         if entry.isvalid():
                             entries.append(entry)
                         else:
                             self.log.debug('Invalid entry created? %s' % entry)
     entries.sort(key=lambda x: x['title'])
     return entries
示例#25
0
 def process(self):
     imdb_lookup = plugin.get_plugin_by_name('imdb_lookup').instance
     self.changes.sort()
     udata = load_uoccin_data(self.folder)
     for line in self.changes:
         tmp = line.split('|')
         typ = tmp[1]
         tid = tmp[2]
         fld = tmp[3]
         val = tmp[4]
         self.log.verbose(
             'processing: type=%s, target=%s, field=%s, value=%s' %
             (typ, tid, fld, val))
         if typ == 'movie':
             # default
             mov = udata['movies'].setdefault(
                 tid, {
                     'name': 'N/A',
                     'watchlist': False,
                     'collected': False,
                     'watched': False
                 })
             # movie title is unknown at this time
             fake = Entry()
             fake['url'] = 'http://www.imdb.com/title/' + tid
             fake['imdb_id'] = tid
             try:
                 imdb_lookup.lookup(fake)
                 mov['name'] = fake.get('imdb_name')
             except plugin.PluginError:
                 self.log.warning(
                     'Unable to lookup movie %s from imdb, using raw name.'
                     % tid)
             # setting
             if fld == 'watchlist':
                 mov['watchlist'] = val == 'true'
             elif fld == 'collected':
                 mov['collected'] = val == 'true'
             elif fld == 'watched':
                 mov['watched'] = val == 'true'
             elif fld == 'tags':
                 mov['tags'] = re.split(',\s*', val)
             elif fld == 'subtitles':
                 mov['subtitles'] = re.split(',\s*', val)
             elif fld == 'rating':
                 mov['rating'] = int(val)
             # cleaning
             if not (mov['watchlist'] or mov['collected']
                     or mov['watched']):
                 self.log.verbose('deleting unused section: movies\%s' %
                                  tid)
                 udata['movies'].pop(tid)
         elif typ == 'series':
             tmp = tid.split('.')
             sid = tmp[0]
             sno = tmp[1] if len(tmp) > 2 else None
             eno = tmp[2] if len(tmp) > 2 else None
             # default
             ser = udata['series'].setdefault(
                 sid, {
                     'name': 'N/A',
                     'watchlist': False,
                     'collected': {},
                     'watched': {}
                 })
             # series name is unknown at this time
             try:
                 series = lookup_series(tvdb_id=sid)
                 ser['name'] = series.name
             except LookupError:
                 self.log.warning(
                     'Unable to lookup series %s from tvdb, using raw name.'
                     % sid)
             # setting
             if fld == 'watchlist':
                 ser['watchlist'] = val == 'true'
             elif fld == 'tags':
                 ser['tags'] = re.split(',\s*', val)
             elif fld == 'rating':
                 ser['rating'] = int(val)
             elif sno is None or eno is None:
                 self.log.warning(
                     'invalid line "%s": season and episode numbers are required'
                     % line)
             elif fld == 'collected':
                 season = ser['collected'].setdefault(sno, {})
                 if val == 'true':
                     season.setdefault(eno, [])
                 else:
                     if eno in season:
                         season.pop(eno)
                     if not season:
                         self.log.verbose(
                             'deleting unused section: series\%s\collected\%s'
                             % (sid, sno))
                         ser['collected'].pop(sno)
             elif fld == 'subtitles':
                 ser['collected'].setdefault(sno, {})[eno] = re.split(
                     ',\s*', val)
             elif fld == 'watched':
                 season = ser['watched'].setdefault(sno, [])
                 if val == 'true':
                     season = ser['watched'][sno] = list(
                         set(season) | set([int(eno)]))
                 elif int(eno) in season:
                     season.remove(int(eno))
                 season.sort()
                 if not season:
                     self.log.debug(
                         'deleting unused section: series\%s\watched\%s' %
                         (sid, sno))
                     ser['watched'].pop(sno)
             # cleaning
             if not (ser['watchlist'] or ser['collected']
                     or ser['watched']):
                 self.log.debug('deleting unused section: series\%s' % sid)
                 udata['series'].pop(sid)
         else:
             self.log.warning('invalid element type "%s"' % typ)
     # save the updated uoccin.json
     ufile = os.path.join(self.folder, 'uoccin.json')
     try:
         text = json.dumps(udata,
                           sort_keys=True,
                           indent=4,
                           separators=(',', ': '))
         with open(ufile, 'w') as f:
             f.write(text)
     except Exception as err:
         self.log.debug('error writing %s: %s' % (ufile, err))
         raise plugin.PluginError('error writing %s: %s' % (ufile, err))
示例#26
0
 def on_task_input(self, task, config):
     """Creates an entry for each item in your uoccin watchlist.
     
     Example::
         
         from_uoccin:
           path: /path/to/gdrive/uoccin
           type: series
           tags: [ 'favorite', 'hires' ]
           check_tags: all
     
     Options path and type are required while the others are for filtering:
     - 'any' will include all the items marked with one or more tags in the list
     - 'all' will only include the items marked with all the listed tags
     - 'none' will only include the items not marked with any of the listed tags.
     
     The entries created will have a valid imdb/tvdb url and id.
     """
     imdb_lookup = plugin.get_plugin_by_name('imdb_lookup').instance
     udata = load_uoccin_data(config['path'])
     section = udata['movies'] if config['type'] == 'movies' else udata[
         'series']
     entries = []
     for eid, itm in list(section.items()):
         if not itm['watchlist']:
             continue
         if 'tags' in config:
             n = len(set(config['tags']) & set(itm.get('tags', [])))
             if config['check_tags'] == 'any' and n <= 0:
                 continue
             if config['check_tags'] == 'all' and n != len(config['tags']):
                 continue
             if config['check_tags'] == 'none' and n > 0:
                 continue
         if config['type'] == 'movies':
             entry = Entry()
             entry['url'] = 'http://www.imdb.com/title/' + eid
             entry['imdb_id'] = eid
             if itm['name'] != 'N/A':
                 entry['title'] = itm['name']
             else:
                 try:
                     imdb_lookup.lookup(entry)
                 except plugin.PluginError as e:
                     self.log.trace('entry %s imdb failed (%s)' %
                                    (entry['imdb_id'], e.value))
                     continue
                 entry['title'] = entry.get('imdb_name')
             if 'tags' in itm:
                 entry['uoccin_tags'] = itm['tags']
             if entry.isvalid():
                 entries.append(entry)
             else:
                 self.log.debug('Invalid entry created? %s' % entry)
         else:
             sname = itm['name']
             try:
                 sname = lookup_series(tvdb_id=eid).seriesname
             except LookupError:
                 self.log.warning(
                     'Unable to lookup series %s from tvdb, using raw name.'
                     % eid)
             surl = 'http://thetvdb.com/?tab=series&id=' + eid
             if config['type'] == 'series':
                 entry = Entry()
                 entry['url'] = surl
                 entry['title'] = sname
                 entry['tvdb_id'] = eid
                 if 'tags' in itm:
                     entry['uoccin_tags'] = itm['tags']
                 if entry.isvalid():
                     entries.append(entry)
                 else:
                     self.log.debug('Invalid entry created? %s' % entry)
             elif config['ep_flags'] == 'collected':
                 slist = itm.get('collected', {})
                 for sno in list(slist.keys()):
                     for eno in slist[sno]:
                         entry = Entry()
                         entry['url'] = surl
                         entry['title'] = '%s S%02dE%02d' % (
                             sname, int(sno), int(eno))
                         entry['tvdb_id'] = eid
                         if entry.isvalid():
                             entries.append(entry)
                         else:
                             self.log.debug('Invalid entry created? %s' %
                                            entry)
             else:
                 slist = itm.get('watched', {})
                 for sno in list(slist.keys()):
                     for eno in slist[sno]:
                         entry = Entry()
                         entry['url'] = surl
                         entry['title'] = '%s S%02dE%02d' % (sname,
                                                             int(sno), eno)
                         entry['tvdb_id'] = eid
                         if entry.isvalid():
                             entries.append(entry)
                         else:
                             self.log.debug('Invalid entry created? %s' %
                                            entry)
     entries.sort(key=lambda x: x['title'])
     return entries
示例#27
0
 def process(self):
     imdb_lookup = plugin.get_plugin_by_name('imdb_lookup').instance
     self.changes.sort()
     udata = load_uoccin_data(self.folder)
     for line in self.changes:
         tmp = line.split('|')
         typ = tmp[1]
         tid = tmp[2]
         fld = tmp[3]
         val = tmp[4]
         self.log.verbose('processing: type=%s, target=%s, field=%s, value=%s' % (typ, tid, fld, val))
         if typ == 'movie':
             # default
             mov = udata['movies'].setdefault(tid, 
                 {'name':'N/A', 'watchlist':False, 'collected':False, 'watched':False})
             # movie title is unknown at this time
             fake = Entry()
             fake['url'] = 'http://www.imdb.com/title/' + tid
             fake['imdb_id'] = tid
             try:
                 imdb_lookup.lookup(fake)
                 mov['name'] = fake.get('imdb_name')
             except plugin.PluginError:
                 self.log.warning('Unable to lookup movie %s from imdb, using raw name.' % tid)
             # setting
             if fld == 'watchlist':
                 mov['watchlist'] = val == 'true'
             elif fld == 'collected':
                 mov['collected'] = val == 'true'
             elif fld == 'watched':
                 mov['watched'] = val == 'true'
             elif fld == 'tags':
                 mov['tags'] = re.split(',\s*', val)
             elif fld == 'subtitles':
                 mov['subtitles'] = re.split(',\s*', val)
             elif fld == 'rating':
                 mov['rating'] = int(val)
             # cleaning
             if not (mov['watchlist'] or mov['collected'] or mov['watched']):
                 self.log.verbose('deleting unused section: movies\%s' % tid)
                 udata['movies'].pop(tid)
         elif typ == 'series':
             tmp = tid.split('.')
             sid = tmp[0]
             sno = tmp[1] if len(tmp) > 2 else None
             eno = tmp[2] if len(tmp) > 2 else None
             # default
             ser = udata['series'].setdefault(sid, {'name':'N/A', 'watchlist':False, 'collected':{}, 'watched':{}})
             # series name is unknown at this time
             try:
                 series = lookup_series(tvdb_id=sid)
                 ser['name'] = series.seriesname
             except LookupError:
                 self.log.warning('Unable to lookup series %s from tvdb, using raw name.' % sid)
             # setting
             if fld == 'watchlist':
                 ser['watchlist'] = val == 'true'
             elif fld == 'tags':
                 ser['tags'] = re.split(',\s*', val)
             elif fld == 'rating':
                 ser['rating'] = int(val)
             elif sno is None or eno is None:
                 self.log.warning('invalid line "%s": season and episode numbers are required' % line)
             elif fld == 'collected':
                 season = ser['collected'].setdefault(sno, {})
                 if val == 'true':
                     season.setdefault(eno, [])
                 else:
                     if eno in season:
                         season.pop(eno)
                     if not season:
                         self.log.verbose('deleting unused section: series\%s\collected\%s' % (sid, sno))
                         ser['collected'].pop(sno)
             elif fld == 'subtitles':
                 ser['collected'].setdefault(sno, {})[eno] = re.split(',\s*', val)
             elif fld == 'watched':
                 season = ser['watched'].setdefault(sno, [])
                 if val == 'true':
                     season = ser['watched'][sno] = list(set(season) | set([int(eno)]))
                 elif int(eno) in season:
                     season.remove(int(eno))
                 season.sort()
                 if not season:
                     self.log.debug('deleting unused section: series\%s\watched\%s' % (sid, sno))
                     ser['watched'].pop(sno)
             # cleaning
             if not (ser['watchlist'] or ser['collected'] or ser['watched']):
                 self.log.debug('deleting unused section: series\%s' % sid)
                 udata['series'].pop(sid)
         else:
             self.log.warning('invalid element type "%s"' % typ)
     # save the updated uoccin.json
     ufile = os.path.join(self.folder, 'uoccin.json')
     try:
         text = json.dumps(udata, sort_keys=True, indent=4, separators=(',', ': '))
         with open(ufile, 'w') as f:
             f.write(text)
     except Exception as err:
         self.log.debug('error writing %s: %s' % (ufile, err))
         raise plugin.PluginError('error writing %s: %s' % (ufile, err))