Mode.checkpoint() - Code Metrics - Inspection of "Updated libraries: oem, oem-core, oem-framework, o..." - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — beta ( 1d082f...70e2cb )

by Dean

created 2016-06-25 13:08 UTC

Mode.checkpoint() A

↳ Parent: Mode

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	3.6875

Importance

Changes

Metric	Value
dl	0
loc	5
ccs	1
cts	4
cp	0.25
rs	9.4285
c	0
b	0
f	0
cc	2
crap	3.6875

from plugin.core.constants import GUID_SERVICES
from plugin.core.filters import Filters
from plugin.core.helpers.variable import try_convert
from plugin.modules.core.manager import ModuleManager
from plugin.sync import SyncMedia, SyncData, SyncMode

from oem.media.show import EpisodeMatch
from plex import Plex
from plex_metadata import Guid
import elapsed
import itertools
import logging

log = logging.getLogger(__name__)

TRAKT_DATA_MAP = {
    SyncMedia.Movies: [
        SyncData.Collection,
        SyncData.Playback,
        SyncData.Ratings,
        SyncData.Watched,
        # SyncData.Watchlist
    ],
    SyncMedia.Shows: [
        SyncData.Ratings
    ],
    SyncMedia.Seasons: [
        SyncData.Ratings
    ],
    SyncMedia.Episodes: [
        SyncData.Collection,
        SyncData.Playback,
        SyncData.Ratings,
        SyncData.Watched,
        # SyncData.Watchlist
    ]
}

DATA_PREFERENCE_MAP = {
    SyncData.Collection:    'sync.collection.mode',
    SyncData.Playback:      'sync.playback.mode',
    SyncData.Ratings:       'sync.ratings.mode',
    SyncData.Watched:       'sync.watched.mode',

    # Lists
    SyncData.Liked:         'sync.lists.liked.mode',
    SyncData.Personal:      'sync.lists.personal.mode',
    SyncData.Watchlist:     'sync.lists.watchlist.mode',
}


class Mode(object):
    data = None
    mode = None

    children = []

    def __init__(self, task):
        self.__task = task

        self.children = [c(task) for c in self.children]

        # Retrieve enabled data
        self.enabled_data = self.get_enabled_data()

        # Determine if mode should be enabled
        self.enabled = len(self.enabled_data) > 0

        if not self.enabled:
            log.debug('Mode %r disabled on: %r', self.mode, self)

    @property
    def current(self):
        return self.__task

    @property
    def configuration(self):
        return self.__task.configuration

    @property
    def handlers(self):
        return self.__task.handlers

    @property
    def modes(self):
        return self.__task.modes

    @property
    def plex(self):
        if not self.current or not self.current.state:
            return None

        return self.current.state.plex

    @property
    def trakt(self):
        if not self.current or not self.current.state:
            return None

        return self.current.state.trakt

    def construct(self):
        pass

    def start(self):
        pass

    def run(self):
        raise NotImplementedError

    def stop(self):
        pass

    def checkpoint(self):
        if self.current is None:
            return

        self.current.checkpoint()

    def execute_children(self, name, force=None):
        # Run method on children
        for c in self.children:
            if not force and not c.enabled:
                log.debug('Ignoring %s() call on child: %r', name, c)
                continue

            # Find method `name` in child
            log.info('Executing %s() on child: %r', name, c)

            func = getattr(c, name, None)

            if not func:
                log.warn('Unknown method: %r', name)
                continue

            # Run method on child
            func()

    @elapsed.clock
    def execute_handlers(self, media, data, *args, **kwargs):
        if type(media) is not list:
            media = [media]

        if type(data) is not list:
            data = [data]

        for m, d in itertools.product(media, data):
            if d not in self.handlers:
                log.debug('Unable to find handler for data: %r', d)
                continue

            try:
                self.handlers[d].run(m, self.mode, *args, **kwargs)
            except Exception, ex:
                log.warn('Exception raised in handlers[%r].run(%r, ...): %s', d, m, ex, exc_info=True)

    def get_enabled_data(self):
        config = self.configuration

        # Determine accepted modes
        modes = [SyncMode.Full]

        if self.mode == SyncMode.Full:
            modes.extend([
                SyncMode.FastPull,
                SyncMode.Pull,
                SyncMode.Push
            ])
        elif self.mode == SyncMode.FastPull:
            modes.extend([
                self.mode,
                SyncMode.Pull
            ])
        else:
            modes.append(self.mode)

        # Retrieve enabled data
        result = []

        if config['sync.watched.mode'] in modes:
            result.append(SyncData.Watched)

        if config['sync.ratings.mode'] in modes:
            result.append(SyncData.Ratings)

        if config['sync.playback.mode'] in modes:
            result.append(SyncData.Playback)

        if config['sync.collection.mode'] in modes:
            result.append(SyncData.Collection)

        # Lists
        if config['sync.lists.watchlist.mode'] in modes:
            result.append(SyncData.Watchlist)

        if config['sync.lists.liked.mode'] in modes:
            result.append(SyncData.Liked)

        if config['sync.lists.personal.mode'] in modes:
            result.append(SyncData.Personal)

        # Filter `result` to data provided by this mode
        if self.data is None:
            log.warn('No "data" property defined on %r', self)
            return result

        if self.data == SyncData.All:
            return result

        return [
            data for data in result
            if data in self.data
        ]

    def get_data(self, media):
        for data in TRAKT_DATA_MAP[media]:
            if not self.is_data_enabled(data):
                continue

            yield data

    @elapsed.clock
    def is_data_enabled(self, data):
        return data in self.enabled_data

    @elapsed.clock
    def process_guid(self, guid):
        if not guid:
            return False, guid

        if guid.service not in GUID_SERVICES:

            # Try map show to a supported service (via OEM)
            supported, item = ModuleManager['mapper'].match(guid.service, guid.id)

            if not supported:
                return False, guid

            if item and item.identifiers:
                # Retrieve mapped show identifier
                service = item.identifiers.keys()[0]
                key = try_convert(item.identifiers[service], int, item.identifiers[service])

                if type(key) not in [int, str]:
                    log.info('[%s/%s] - Unsupported key: %r', guid.service, guid.id, key)
                    return False, guid

                log.debug('[%s/%s] - Mapped to: %r', guid.service, guid.id, item)

                # Return mapped guid
                return True, Guid.construct(service, key)

            log.debug('Unable to find mapping for %r', guid)
            return False, guid

        return True, guid

    @elapsed.clock
    def process_guid_episode(self, guid, season_num, episode_num):
        if not guid:
            return False, guid, season_num, episode_num

        if guid.service not in GUID_SERVICES:
            # Try map episode to a supported service (via OEM)
            supported, match = ModuleManager['mapper'].map_episode(guid, season_num, episode_num)

            if not supported:
                return False, guid, season_num, episode_num

            if match and match.identifiers:

                if not isinstance(match, EpisodeMatch):
                    log.info('[%s/%s] - Episode -> Movie mappings are not supported', guid.service, guid.id)
                    return False, guid, season_num, episode_num

                if match.absolute_num is not None:
                    log.info('[%s/%s] - Episode mappings with absolute numbers are not supported yet', guid.service, guid.id)
                    return False, guid, season_num, episode_num

                # Retrieve mapped show identifier
                service = match.identifiers.keys()[0]
                key = try_convert(match.identifiers[service], int, match.identifiers[service])

                if type(key) not in [int, str]:
                    log.info('[%s/%s] - Unsupported key: %r', guid.service, guid.id, key)
                    return False, guid, season_num, episode_num

                log.debug('[%s/%s] (S%02dE%02d) - Mapped to: %r', guid.service, guid.id, season_num, episode_num, match)

                # Return mapped episode result
                return True, Guid.construct(service, key), match.season_num, match.episode_num

            log.debug('Unable to find mapping for %r S%02dE%02d', guid, season_num, episode_num)
            return False, guid, season_num, episode_num

        return True, guid, season_num, episode_num

    def sections(self, section_type=None):
        # Retrieve "section" for current task
        section_key = self.current.kwargs.get('section', None)

        # Fetch sections from server
        p_sections = Plex['library'].sections()

        if p_sections is None:
            return None

        # Filter sections, map to dictionary
        result = {}

        for section in p_sections.filter(section_type, section_key):
            # Apply section name filter
            if not Filters.is_valid_section_name(section.title):
                continue

            try:
                key = int(section.key)
            except Exception, ex:
                log.warn('Unable to cast section key %r to integer: %s', section.key, ex, exc_info=True)
                continue

            result[key] = section.uuid

        return [(key, ) for key in result.keys()], result


1	1		from plugin.core.constants import GUID_SERVICES
2	1		from plugin.core.filters import Filters
3	1		from plugin.core.helpers.variable import try_convert
4	1		from plugin.modules.core.manager import ModuleManager
5	1		from plugin.sync import SyncMedia, SyncData, SyncMode
6
7	1		from oem.media.show import EpisodeMatch
8	1		from plex import Plex
9	1		from plex_metadata import Guid
10	1		import elapsed
11	1		import itertools
12	1		import logging
13
14	1		log = logging.getLogger(__name__)
15
16	1		TRAKT_DATA_MAP = {
17			SyncMedia.Movies: [
18			SyncData.Collection,
19			SyncData.Playback,
20			SyncData.Ratings,
21			SyncData.Watched,
22			# SyncData.Watchlist
23			],
24			SyncMedia.Shows: [
25			SyncData.Ratings
26			],
27			SyncMedia.Seasons: [
28			SyncData.Ratings
29			],
30			SyncMedia.Episodes: [
31			SyncData.Collection,
32			SyncData.Playback,
33			SyncData.Ratings,
34			SyncData.Watched,
35			# SyncData.Watchlist
36			]
37			}
38
39	1		DATA_PREFERENCE_MAP = {
40			SyncData.Collection: 'sync.collection.mode',
41			SyncData.Playback: 'sync.playback.mode',
42			SyncData.Ratings: 'sync.ratings.mode',
43			SyncData.Watched: 'sync.watched.mode',
44
45			# Lists
46			SyncData.Liked: 'sync.lists.liked.mode',
47			SyncData.Personal: 'sync.lists.personal.mode',
48			SyncData.Watchlist: 'sync.lists.watchlist.mode',
49			}
50
51
52	1		class Mode(object):
53	1		data = None
54	1		mode = None
55
56	1		children = []
57
58	1		def __init__(self, task):
59			self.__task = task
60
61			self.children = [c(task) for c in self.children]
62
63			# Retrieve enabled data
64			self.enabled_data = self.get_enabled_data()
65
66			# Determine if mode should be enabled
67			self.enabled = len(self.enabled_data) > 0
68
69			if not self.enabled:
70			log.debug('Mode %r disabled on: %r', self.mode, self)
71
72	1		@property
73			def current(self):
74			return self.__task
75
76	1		@property
77			def configuration(self):
78			return self.__task.configuration
79
80	1		@property
81			def handlers(self):
82			return self.__task.handlers
83
84	1		@property
85			def modes(self):
86			return self.__task.modes
87
88	1		@property
89			def plex(self):
90			if not self.current or not self.current.state:
91			return None
92
93			return self.current.state.plex
94
95	1		@property
96			def trakt(self):
97			if not self.current or not self.current.state:
98			return None
99
100			return self.current.state.trakt
101
102	1		def construct(self):
103			pass
104
105	1		def start(self):
106			pass
107
108	1		def run(self):
109			raise NotImplementedError
110
111	1		def stop(self):
112			pass
113
114	1		def checkpoint(self):
115			if self.current is None:
116			return
117
118			self.current.checkpoint()
119
120	1		def execute_children(self, name, force=None):
121			# Run method on children
122			for c in self.children:
123			if not force and not c.enabled:
124			log.debug('Ignoring %s() call on child: %r', name, c)
125			continue
126
127			# Find method `name` in child
128			log.info('Executing %s() on child: %r', name, c)
129
130			func = getattr(c, name, None)
131
132			if not func:
133			log.warn('Unknown method: %r', name)
134			continue
135
136			# Run method on child
137			func()
138
139	1		@elapsed.clock
140			def execute_handlers(self, media, data, args, *kwargs):
141			if type(media) is not list:
142			media = [media]
143
144			if type(data) is not list:
145			data = [data]
146
147			for m, d in itertools.product(media, data):
148			if d not in self.handlers:
149			log.debug('Unable to find handler for data: %r', d)
150			continue
151
152			try:
153			self.handlers[d].run(m, self.mode, args, *kwargs)
154			except Exception, ex:
155			log.warn('Exception raised in handlers[%r].run(%r, ...): %s', d, m, ex, exc_info=True)
156
157	1		def get_enabled_data(self):
158			config = self.configuration
159
160			# Determine accepted modes
161			modes = [SyncMode.Full]
162
163			if self.mode == SyncMode.Full:
164			modes.extend([
165			SyncMode.FastPull,
166			SyncMode.Pull,
167			SyncMode.Push
168			])
169			elif self.mode == SyncMode.FastPull:
170			modes.extend([
171			self.mode,
172			SyncMode.Pull
173			])
174			else:
175			modes.append(self.mode)
176
177			# Retrieve enabled data
178			result = []
179
180			if config['sync.watched.mode'] in modes:
181			result.append(SyncData.Watched)
182
183			if config['sync.ratings.mode'] in modes:
184			result.append(SyncData.Ratings)
185
186			if config['sync.playback.mode'] in modes:
187			result.append(SyncData.Playback)
188
189			if config['sync.collection.mode'] in modes:
190			result.append(SyncData.Collection)
191
192			# Lists
193			if config['sync.lists.watchlist.mode'] in modes:
194			result.append(SyncData.Watchlist)
195
196			if config['sync.lists.liked.mode'] in modes:
197			result.append(SyncData.Liked)
198
199			if config['sync.lists.personal.mode'] in modes:
200			result.append(SyncData.Personal)
201
202			# Filter `result` to data provided by this mode
203			if self.data is None:
204			log.warn('No "data" property defined on %r', self)
205			return result
206
207			if self.data == SyncData.All:
208			return result
209
210			return [
211			data for data in result
212			if data in self.data
213			]
214
215	1		def get_data(self, media):
216			for data in TRAKT_DATA_MAP[media]:
217			if not self.is_data_enabled(data):
218			continue
219
220			yield data
221
222	1		@elapsed.clock
223			def is_data_enabled(self, data):
224			return data in self.enabled_data
225
226	1		@elapsed.clock
227			def process_guid(self, guid):
228			if not guid:
229			return False, guid
230
231		View Code Duplication	if guid.service not in GUID_SERVICES:
			0 ignored issues – show Duplication introduced 2016-06-12 12:39 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
232			# Try map show to a supported service (via OEM)
233			supported, item = ModuleManager['mapper'].match(guid.service, guid.id)
234
235			if not supported:
236			return False, guid
237
238			if item and item.identifiers:
239			# Retrieve mapped show identifier
240			service = item.identifiers.keys()[0]
241			key = try_convert(item.identifiers[service], int, item.identifiers[service])
242
243			if type(key) not in [int, str]:
244			log.info('[%s/%s] - Unsupported key: %r', guid.service, guid.id, key)
245			return False, guid
246
247			log.debug('[%s/%s] - Mapped to: %r', guid.service, guid.id, item)
248
249			# Return mapped guid
250			return True, Guid.construct(service, key)
251
252			log.debug('Unable to find mapping for %r', guid)
253			return False, guid
254
255			return True, guid
256
257	1		@elapsed.clock
258			def process_guid_episode(self, guid, season_num, episode_num):
259			if not guid:
260			return False, guid, season_num, episode_num
261
262			if guid.service not in GUID_SERVICES:
263			# Try map episode to a supported service (via OEM)
264			supported, match = ModuleManager['mapper'].map_episode(guid, season_num, episode_num)
265
266			if not supported:
267			return False, guid, season_num, episode_num
268
269		View Code Duplication	if match and match.identifiers:
			0 ignored issues – show Duplication introduced 2016-06-12 12:39 UTC by Report Bug Copy Issue Report This code seems to be duplicated in your project. Loading history...
270			if not isinstance(match, EpisodeMatch):
271			log.info('[%s/%s] - Episode -> Movie mappings are not supported', guid.service, guid.id)
272			return False, guid, season_num, episode_num
273
274			if match.absolute_num is not None:
275			log.info('[%s/%s] - Episode mappings with absolute numbers are not supported yet', guid.service, guid.id)
276			return False, guid, season_num, episode_num
277
278			# Retrieve mapped show identifier
279			service = match.identifiers.keys()[0]
280			key = try_convert(match.identifiers[service], int, match.identifiers[service])
281
282			if type(key) not in [int, str]:
283			log.info('[%s/%s] - Unsupported key: %r', guid.service, guid.id, key)
284			return False, guid, season_num, episode_num
285
286			log.debug('[%s/%s] (S%02dE%02d) - Mapped to: %r', guid.service, guid.id, season_num, episode_num, match)
287
288			# Return mapped episode result
289			return True, Guid.construct(service, key), match.season_num, match.episode_num
290
291			log.debug('Unable to find mapping for %r S%02dE%02d', guid, season_num, episode_num)
292			return False, guid, season_num, episode_num
293
294			return True, guid, season_num, episode_num
295
296	1		def sections(self, section_type=None):
297			# Retrieve "section" for current task
298			section_key = self.current.kwargs.get('section', None)
299
300			# Fetch sections from server
301			p_sections = Plex['library'].sections()
302
303			if p_sections is None:
304			return None
305
306			# Filter sections, map to dictionary
307			result = {}
308
309			for section in p_sections.filter(section_type, section_key):
310			# Apply section name filter
311			if not Filters.is_valid_section_name(section.title):
312			continue
313
314			try:
315			key = int(section.key)
316			except Exception, ex:
317			log.warn('Unable to cast section key %r to integer: %s', section.key, ex, exc_info=True)
318			continue
319
320			result[key] = section.uuid
321
322			return [(key, ) for key in result.keys()], result
323

fuzeman / Plex-Trakt-Scrobbler

Push — beta ( 1d082f...70e2cb )

Mode.checkpoint() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like