Shows.process_matched_episodes() - Code Metrics - Inspection of "Improved unsupported service warnings and simplifi..." - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — beta ( 7d3e07...a06fd2 )

by Dean

created 2016-07-26 12:09 UTC

Shows.process_matched_episodes() D

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	97.5094

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
c	2
b	0
f	0
dl	0
loc	62
ccs	1
cts	23
cp	0.0434
rs	4.6753
cc	10
crap	97.5094

How to fix Long Method Complexity

from plugin.core.constants import GUID_SERVICES

from plugin.sync.core.enums import SyncMedia, SyncData
from plugin.sync.modes.core.base import log_unsupported, mark_unsupported
from plugin.sync.modes.push.base import Base
# .scrutinizer.yml
before_commands:
    - sudo pip install abc # Python2
    - sudo pip3 install abc # Python3

from plex_database.models import MetadataItem, MediaItem, Episode
from plex_metadata import Guid
import copy
import elapsed
import logging

log = logging.getLogger(__name__)


class Shows(Base):
    data = [
        SyncData.Collection,
        SyncData.Playback,
        SyncData.Ratings,
        SyncData.Watched
    ]

    def __init__(self, task):
        super(Shows, self).__init__(task)

        # Sections
        self.p_sections = None
        self.p_sections_map = None

        # Shows
        self.p_shows = None
        self.p_shows_count = None
        self.p_shows_pending = None
        self.p_shows_unsupported = None

        # Seasons
        self.p_seasons = None

        # Episodes
        self.p_episodes = None
        self.p_episodes_count = None
        self.p_episodes_pending = None

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


        # Determine number of shows that will be processed
        self.p_shows_count = self.plex.library.shows.count(

            self.p_sections
        )

        # Determine number of shows that will be processed
        self.p_episodes_count = self.plex.library.episodes.count_items(

            self.p_sections
        )

        # Increment progress steps total
        self.current.progress.group(Shows, 'matched:shows').add(self.p_shows_count)

        self.current.progress.group(Shows, 'matched:episodes').add(self.p_episodes_count)

        self.current.progress.group(Shows, 'missing:shows')

        self.current.progress.group(Shows, 'missing:episodes')


    @elapsed.clock
    def start(self):
        # Fetch movies with account settings
        self.p_shows, self.p_seasons, self.p_episodes = self.plex.library.episodes.mapped(

            self.p_sections, ([
                MetadataItem.title,
                MetadataItem.year
            ], [], [
                MediaItem.audio_channels,
                MediaItem.audio_codec,
                MediaItem.height,
                MediaItem.interlaced,

                Episode.added_at
            ]),
            account=self.current.account.plex.key,

            parse_guid=True
        )

        # Reset state
        self.p_shows_pending = self.trakt.table.show_keys.copy()

        self.p_shows_unsupported = {}

        self.p_episodes_pending = copy.deepcopy(self.trakt.table.episode_keys)


    @elapsed.clock
    def run(self):
        # Process matched items
        self.process_matched_shows()
        self.process_matched_episodes()

        # Report unsupported shows
        log_unsupported(log, 'Found %d unsupported show(s)', self.p_shows_unsupported)

        # Process missing items
        self.process_missing_shows()
        self.process_missing_episodes()

    #
    # Shows
    #

    @elapsed.clock

    def process_matched_shows(self):
        # Iterate over plex shows
        for sh_id, p_guid, p_show in self.p_shows:
            # Increment one step
            self.current.progress.group(Shows, 'matched:shows').step()


            # Process `p_guid` (map + validate)
            supported, matched, p_guid = self.process_guid(p_guid)


            if not supported:
                mark_unsupported(self.p_shows_unsupported, sh_id, p_guid)
                continue

            if not matched:
                log.info('Unable to find identifier for: %s/%s (rating_key: %r)', p_guid.service, p_guid.id, sh_id)
                continue

            key = (p_guid.service, p_guid.id)

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


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

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


                # Execute show handlers
                self.execute_handlers(

                    SyncMedia.Shows, data,
                    key=sh_id,
                    guid=p_guid,

                    p_item=p_show,

                    t_item=t_show
                )

            # Remove show from `pending_shows`
            if pk and pk in self.p_shows_pending:
                self.p_shows_pending.remove(pk)

            # Task checkpoint
            self.checkpoint()


        # Stop progress group
        self.current.progress.group(Shows, 'matched:shows').stop()


    @elapsed.clock
    def process_missing_shows(self):
        if self.current.kwargs.get('section'):

            # Collection cleaning disabled for individual syncs
            return

        # Increment progress steps
        self.current.progress.group(Shows, 'missing:shows').add(len(self.p_shows_pending))


        # Iterate over trakt shows (that aren't in plex)
        for pk in list(self.p_shows_pending):
            # Increment one step
            self.current.progress.group(Shows, 'missing:shows').step()


            # Iterate over data handlers
            triggered = False

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

                if data not in [SyncData.Collection]:
                    continue

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


                if not t_show:
                    continue

                log.debug('Found show missing from plex: %r [data: %r]', pk, SyncData.title(data))

                # Trigger handler
                self.execute_handlers(

                    SyncMedia.Shows, data,

                    key=None,

                    guid=Guid.construct(*pk),
                    p_item=None,

                    t_item=t_show
                )

                # Mark triggered
                triggered = True

            # Check if action was triggered
            if not triggered:
                continue

            # Remove movie from `pending` set
            self.p_shows_pending.remove(pk)

        # Stop progress group
        self.current.progress.group(Shows, 'missing:shows').stop()


        self.log_pending(

            log, 'Unable to find %d show(s) in Plex, list has been saved to: %s',
            self.current.account, 'shows', self.p_shows_pending

        )

    #
    # Episodes
    #

    @elapsed.clock
    def process_matched_episodes(self):
        # Iterate over plex episodes
        for ids, p_guid, (season_num, episode_num), p_show, p_season, p_episode in self.p_episodes:

            # Increment one step
            self.current.progress.group(Shows, 'matched:episodes').step()


            # Process `p_guid` (map + validate)
            supported, matched, p_guid, episodes = self.process_guid_episode(p_guid, season_num, episode_num)


            if not supported:
                mark_unsupported(self.p_shows_unsupported, ids['show'], p_guid)
                continue

            if not matched:
                log.info('Unable to find identifier for: %s/%s (rating_key: %r)', p_guid.service, p_guid.id, ids['show'])

                continue

            if not episodes:
                log.warn('No episodes returned for: %s/%s', p_guid.service, p_guid.id)
                continue

            key = (p_guid.service, p_guid.id)
            season_num, episode_num = episodes[0]

            identifier = (season_num, episode_num)

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


            with elapsed.clock(Shows, 'run:plex_episodes:execute_handlers'):
                for data in self.get_data(SyncMedia.Episodes):

                    with elapsed.clock(Shows, 'run:plex_episodes:t_objects'):
                        t_show, t_season, t_episode = self.t_objects(

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

                            season_num, episode_num
                        )

                    # Execute episode handlers
                    self.execute_handlers(

                        SyncMedia.Episodes, data,

                        key=ids['episode'],
                        identifier=identifier,

                        guid=p_guid,
                        p_show=p_show,
                        p_item=p_episode,

                        t_show=t_show,
                        t_item=t_episode
                    )

            # Remove episode from `pending_episodes`
            if pk in self.p_episodes_pending and identifier in self.p_episodes_pending[pk]:
                self.p_episodes_pending[pk].remove(identifier)

            # Task checkpoint
            self.checkpoint()


        # Stop progress group
        self.current.progress.group(Shows, 'matched:episodes').stop()


    @elapsed.clock
    def process_missing_episodes(self):
        if self.current.kwargs.get('section'):

            # Collection cleaning disabled for individual syncs
            return

        # Increment progress steps
        self.current.progress.group(Shows, 'missing:episodes').add(len(self.p_episodes_pending))


        # Iterate over trakt episodes (that aren't in plex)
        for pk, episodes in [(p, list(e)) for (p, e) in self.p_episodes_pending.items()]:
            # Increment one step
            self.current.progress.group(Shows, 'missing:episodes').step()


            # Iterate over trakt episodes (that aren't in plex)
            for identifier in episodes:
                # Iterate over data handlers
                season_num, episode_num = identifier
                triggered = False

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

                    if data not in [SyncData.Collection]:
                        continue

                    # Retrieve episode
                    t_show, t_season, t_episode = self.t_objects(

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

                        season_num, episode_num
                    )

                    if not t_episode:
                        continue

                    log.debug('Found episode missing from plex: %r - %r [data: %r]', pk, identifier, SyncData.title(data))


                    # Trigger handler
                    self.execute_handlers(

                        SyncMedia.Episodes, data,
                        key=None,
                        identifier=identifier,
                        guid=Guid.construct(*pk),

                        p_show=None,
                        p_item=None,

                        t_show=t_show,
                        t_item=t_episode
                    )

                    # Mark triggered
                    triggered = True

                # Check if action was triggered
                if not triggered:
                    continue

                # Remove movie from `pending` set
                self.p_episodes_pending[pk].remove(identifier)

        # Stop progress group
        self.current.progress.group(Shows, 'missing:episodes').stop()


        self.log_pending(

            log, 'Unable to find %d episode(s) in Plex, list has been saved to: %s',
            self.current.account, 'episodes', self.p_episodes_pending

        )

    @staticmethod
    def t_objects(collection, pk, season_num, episode_num):
        # Try find trakt `Show` from `collection`
        t_show = collection.get(pk)

        if t_show is None:
            return t_show, None, None

        # Try find trakt `Season`
        t_season = t_show.seasons.get(season_num)

        if t_season is None:
            return t_show, t_season, None

        # Try find trakt `Episode`
        t_episode = t_season.episodes.get(episode_num)

        return t_show, t_season, t_episode


Push — beta ( 7d3e07...a06fd2 )

Shows.process_matched_episodes() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Complexity

1. Missing Dependencies

2. Missing init.py files

1	1	from plugin.core.constants import GUID_SERVICES
		0 ignored issues – show Unused Code introduced 2016-05-26 03:43 UTC by Report Bug Copy Issue Report Unused GUID_SERVICES imported from plugin.core.constants Loading history...
2	1	from plugin.sync.core.enums import SyncMedia, SyncData
3	1	from plugin.sync.modes.core.base import log_unsupported, mark_unsupported
4	1	from plugin.sync.modes.push.base import Base
		0 ignored issues – show Bug introduced 2016-07-01 11:50 UTC by Report Bug Copy Issue Report The name `base` does not seem to exist in module `plugin.sync.modes.push`. Loading history... Configuration introduced 2016-07-01 11:50 UTC by Report Bug Copy Issue Report Unable to import 'plugin.sync.modes.push.base' (invalid syntax (<string>, line 37)) This can be caused by one of the following: 1. Missing Dependencies This error could indicate a configuration issue of Pylint. Make sure that your libraries are available by adding the necessary commands. # .scrutinizer.yml before_commands: - sudo pip install abc # Python2 - sudo pip3 install abc # Python3 Tip: We are currently not using virtualenv to run pylint, when installing your modules make sure to use the command for the correct version. 2. Missing __init__.py files This error could also result from missing `__init__.py` files in your module folders. Make sure that you place one file in each sub-folder. Loading history...
5
6	1	from plex_database.models import MetadataItem, MediaItem, Episode
7	1	from plex_metadata import Guid
8	1	import copy
9	1	import elapsed
10	1	import logging
11
12	1	log = logging.getLogger(__name__)
13
14
15	1	class Shows(Base):
16	1	data = [
17		SyncData.Collection,
18		SyncData.Playback,
19		SyncData.Ratings,
20		SyncData.Watched
21		]
22
23	1	def __init__(self, task):
24		super(Shows, self).__init__(task)
25
26		# Sections
27		self.p_sections = None
28		self.p_sections_map = None
29
30		# Shows
31		self.p_shows = None
32		self.p_shows_count = None
33		self.p_shows_pending = None
34		self.p_shows_unsupported = None
35
36		# Seasons
37		self.p_seasons = None
38

fuzeman / Plex-Trakt-Scrobbler

Push — beta ( 7d3e07...a06fd2 )

Shows.process_matched_episodes() D

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Complexity

1. Missing Dependencies

2. Missing __init__.py files

Duplication Side-by-Side

Filter issues like

2. Missing init.py files