Mode.get_enabled_data() - Code Metrics - Inspection of "Merge branch 'release/1.0.2.0'" - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( aeb165...d9ae97 )

by Dean

created 2016-04-15 10:51 UTC

Mode.get_enabled_data() F

↳ Parent: Mode

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	190.4058

Metric	Value
cc	14
dl	0
loc	56
ccs	1
cts	29
cp	0.0345
crap	190.4058
rs	3.3695

How to fix Long Method Complexity

from plugin.core.filters import Filters
from plugin.sync import SyncMedia, SyncData, SyncMode

from plex import Plex
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

    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.filters import Filters
2	1	from plugin.sync import SyncMedia, SyncData, SyncMode
3
4	1	from plex import Plex
5	1	import elapsed
6	1	import itertools
7	1	import logging
8
9	1	log = logging.getLogger(__name__)
10
11	1	TRAKT_DATA_MAP = {
12		SyncMedia.Movies: [
13		SyncData.Collection,
14		SyncData.Playback,
15		SyncData.Ratings,
16		SyncData.Watched,
17		# SyncData.Watchlist
18		],
19		SyncMedia.Shows: [
20		SyncData.Ratings
21		],
22		SyncMedia.Seasons: [
23		SyncData.Ratings
24		],
25		SyncMedia.Episodes: [
26		SyncData.Collection,
27		SyncData.Playback,
28		SyncData.Ratings,
29		SyncData.Watched,
30		# SyncData.Watchlist
31		]
32		}
33
34	1	DATA_PREFERENCE_MAP = {
35		SyncData.Collection: 'sync.collection.mode',
36		SyncData.Playback: 'sync.playback.mode',
37		SyncData.Ratings: 'sync.ratings.mode',
38		SyncData.Watched: 'sync.watched.mode',
39
40		# Lists
41		SyncData.Liked: 'sync.lists.liked.mode',
42		SyncData.Personal: 'sync.lists.personal.mode',
43		SyncData.Watchlist: 'sync.lists.watchlist.mode',
44		}
45
46
47	1	class Mode(object):
48	1	data = None
49	1	mode = None
50
51	1	children = []
52
53	1	def __init__(self, task):
54		self.__task = task
55
56		self.children = [c(task) for c in self.children]
57
58		# Retrieve enabled data
59		self.enabled_data = self.get_enabled_data()
60
61		# Determine if mode should be enabled
62		self.enabled = len(self.enabled_data) > 0
63
64		if not self.enabled:
65		log.debug('Mode %r disabled on: %r', self.mode, self)
66
67	1	@property
68		def current(self):
69		return self.__task
70
71	1	@property
72		def configuration(self):
73		return self.__task.configuration
74
75	1	@property
76		def handlers(self):
77		return self.__task.handlers
78
79	1	@property
80		def modes(self):
81		return self.__task.modes
82
83	1	@property
84		def plex(self):
85		if not self.current or not self.current.state:
86		return None
87
88		return self.current.state.plex
89
90	1	@property
91		def trakt(self):
92		if not self.current or not self.current.state:
93		return None
94
95		return self.current.state.trakt
96
97	1	def construct(self):
98		pass
99
100	1	def start(self):
101		pass
102
103	1	def run(self):
104		raise NotImplementedError
105
106	1	def stop(self):
107		pass
108
109	1	def checkpoint(self):
110		if self.current is None:
111		return
112
113		self.current.checkpoint()
114
115	1	def execute_children(self, name, force=None):
116		# Run method on children
117		for c in self.children:
118		if not force and not c.enabled:
119		log.debug('Ignoring %s() call on child: %r', name, c)
120		continue
121
122		# Find method `name` in child
123		log.info('Executing %s() on child: %r', name, c)
124
125		func = getattr(c, name, None)
126
127		if not func:
128		log.warn('Unknown method: %r', name)
129		continue
130
131		# Run method on child
132		func()
133
134	1	@elapsed.clock
135		def execute_handlers(self, media, data, args, *kwargs):
136		if type(media) is not list:
137		media = [media]
138
139		if type(data) is not list:
140		data = [data]
141
142		for m, d in itertools.product(media, data):
143		if d not in self.handlers:
144		log.debug('Unable to find handler for data: %r', d)
145		continue
146
147		try:
148		self.handlers[d].run(m, self.mode, args, *kwargs)
149		except Exception, ex:
150		log.warn('Exception raised in handlers[%r].run(%r, ...): %s', d, m, ex, exc_info=True)
151
152	1	def get_enabled_data(self):
153		config = self.configuration
154
155		# Determine accepted modes
156		modes = [SyncMode.Full]
157
158		if self.mode == SyncMode.Full:
159		modes.extend([
160		SyncMode.FastPull,
161		SyncMode.Pull,
162		SyncMode.Push
163		])
164		elif self.mode == SyncMode.FastPull:
165		modes.extend([
166		self.mode,
167		SyncMode.Pull
168		])
169		else:
170		modes.append(self.mode)
171
172		# Retrieve enabled data
173		result = []
174
175		if config['sync.watched.mode'] in modes:
176		result.append(SyncData.Watched)
177
178		if config['sync.ratings.mode'] in modes:
179		result.append(SyncData.Ratings)
180
181		if config['sync.playback.mode'] in modes:
182		result.append(SyncData.Playback)
183
184		if config['sync.collection.mode'] in modes:
185		result.append(SyncData.Collection)
186
187		# Lists
188		if config['sync.lists.watchlist.mode'] in modes:
189		result.append(SyncData.Watchlist)
190
191		if config['sync.lists.liked.mode'] in modes:
192		result.append(SyncData.Liked)
193
194		if config['sync.lists.personal.mode'] in modes:
195		result.append(SyncData.Personal)
196
197		# Filter `result` to data provided by this mode
198		if self.data is None:
199		log.warn('No "data" property defined on %r', self)
200		return result
201
202		if self.data == SyncData.All:
203		return result
204
205		return [
206		data for data in result
207		if data in self.data
208		]
209
210	1	def get_data(self, media):
211		for data in TRAKT_DATA_MAP[media]:
212		if not self.is_data_enabled(data):
213		continue
214
215		yield data
216
217	1	@elapsed.clock
218		def is_data_enabled(self, data):
219		return data in self.enabled_data
220
221	1	def sections(self, section_type=None):
222		# Retrieve "section" for current task
223		section_key = self.current.kwargs.get('section', None)
224
225		# Fetch sections from server
226		p_sections = Plex['library'].sections()
227
228		if p_sections is None:
229		return None
230
231		# Filter sections, map to dictionary
232		result = {}
233
234		for section in p_sections.filter(section_type, section_key):
235		# Apply section name filter
236		if not Filters.is_valid_section_name(section.title):
237		continue
238
239		try:
240		key = int(section.key)
241		except Exception, ex:
242		log.warn('Unable to cast section key %r to integer: %s', section.key, ex, exc_info=True)
243		continue
244
245		result[key] = section.uuid
246
247		return [(key, ) for key in result.keys()], result
248

fuzeman / Plex-Trakt-Scrobbler

Push — master ( aeb165...d9ae97 )

Mode.get_enabled_data() F

Complexity

Size

Duplication

Code Coverage

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like