Shows

Complexity

Total Complexity

21

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Test Coverage

Coverage

6%

1 Method

Rating	Name	Duplication	Size	Complexity
F	run()	0	122	21

from plugin.core.constants import GUID_SERVICES
from plugin.sync.core.enums import SyncData, SyncMedia
from plugin.sync.modes.core.base import log_unsupported, mark_unsupported
from plugin.sync.modes.pull.base import Base

from plex_database.models import MetadataItem
import elapsed
import logging

log = logging.getLogger(__name__)


class Shows(Base):

This class has no __init__ method.

    data = [
        SyncData.Collection,
        SyncData.Playback,
        SyncData.Ratings,
        SyncData.Watched
    ]

    @elapsed.clock
    def run(self):
        # Retrieve show sections
        p_sections, p_sections_map = self.sections('show')

The Instance of Shows does not seem to have a member named sections.

The variable p_sections_map seems to be unused.

        # Fetch episodes with account settings
        p_shows, p_seasons, p_episodes = self.plex.library.episodes.mapped(

The Instance of Shows does not seem to have a member named plex.

The variable p_seasons seems to be unused.

            p_sections, ([
                MetadataItem.library_section
            ], [], []),
            account=self.current.account.plex.key,

The Instance of Shows does not seem to have a member named current.

            parse_guid=True
        )

        # TODO process seasons

TODO and FIXME comments should generally be avoided.

        # Calculate total number of episodes
        pending = {}

        for data in self.get_data(SyncMedia.Episodes):

The Instance of Shows does not seem to have a member named get_data.

            t_episodes = [
                (key, se, ep)
                for key, t_show in self.trakt[(SyncMedia.Episodes, data)].items()

The Instance of Shows does not seem to have a member named trakt.

                for se, t_season in t_show.seasons.items()
                for ep in t_season.episodes.iterkeys()
            ]

            if data not in pending:
                pending[data] = {}

            for key in t_episodes:
                pending[data][key] = False

        # Task started
        unsupported_shows = {}

        # Process shows
        for sh_id, guid, p_show in p_shows:
            if not guid or guid.service not in GUID_SERVICES:
                mark_unsupported(unsupported_shows, sh_id, guid)
                continue

            key = (guid.service, guid.id)

            # Try retrieve `pk` for `key`
            pk = self.trakt.table('shows').get(key)

The Instance of Shows does not seem to have a member named trakt.

            # Store in item map
            self.current.map.add(p_show.get('library_section'), sh_id, [key, pk])

The Instance of Shows does not seem to have a member named current.

            if pk is None:
                # No `pk` found
                continue

            # Execute data handlers
            for data in self.get_data(SyncMedia.Shows):

The Instance of Shows does not seem to have a member named get_data.

                t_show = self.trakt[(SyncMedia.Shows, data)].get(pk)

The Instance of Shows does not seem to have a member named trakt.

                # Execute show handlers
                self.execute_handlers(

The Instance of Shows does not seem to have a member named execute_handlers.

                    SyncMedia.Shows, data,
                    key=sh_id,

                    p_item=p_show,
                    t_item=t_show
                )

        # Process episodes
        for ids, guid, (season_num, episode_num), p_show, p_season, p_episode in p_episodes:

The variable p_season seems to be unused.

            if not guid or guid.service not in GUID_SERVICES:
                mark_unsupported(unsupported_shows, ids['show'], guid)
                continue

            key = (guid.service, guid.id)

            # Try retrieve `pk` for `key`
            pk = self.trakt.table('shows').get(key)

The Instance of Shows does not seem to have a member named trakt.

            if pk is None:
                # No `pk` found
                continue

            if not ids.get('episode'):
                # Missing `episode` rating key
                continue

            for data in self.get_data(SyncMedia.Episodes):

The Instance of Shows does not seem to have a member named get_data.

                t_show = self.trakt[(SyncMedia.Episodes, data)].get(pk)

The Instance of Shows does not seem to have a member named trakt.

                if t_show is None:
                    # Unable to find matching show in trakt data
                    continue

                t_season = t_show.seasons.get(season_num)

                if t_season is None:
                    # Unable to find matching season in `t_show`
                    continue

                t_episode = t_season.episodes.get(episode_num)

                if t_episode is None:
                    # Unable to find matching episode in `t_season`
                    continue

                self.execute_handlers(

The Instance of Shows does not seem to have a member named execute_handlers.

                    SyncMedia.Episodes, data,
                    key=ids['episode'],

                    p_item=p_episode,
                    t_item=t_episode
                )

                # Increment one step
                self.step(pending, data, (pk, season_num, episode_num))

            # Task checkpoint
            self.checkpoint()

The Instance of Shows does not seem to have a member named checkpoint.

        # Log details
        log_unsupported(log, 'Found %d unsupported show(s)\n%s', unsupported_shows)
        log.debug('Pending: %r', pending)