SyncTask.elapsed() - Code Metrics - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

SyncTask.elapsed() A
last analyzed 2018-03-05 01:11 UTC

↳ Parent: SyncTask

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	6
ccs	1
cts	4
cp	0.25
rs	9.4285
c	0
b	0
f	0
cc	2
crap	3.6875

from plugin.managers.exception import ExceptionManager
from plugin.models import *

from plugin.sync.core.enums import SyncData, SyncMode
from plugin.sync.core.exceptions import SyncAbort, QueueError
from plugin.sync.core.task.artifacts import SyncArtifacts
from plugin.sync.core.task.configuration import SyncConfiguration
from plugin.sync.core.task.map import SyncMap
from plugin.sync.core.task.pending import SyncPending
from plugin.sync.core.task.progress import SyncProgress
from plugin.sync.core.task.profiler import SyncProfiler
from plugin.sync.core.task.state import SyncState

from datetime import datetime
from peewee import JOIN_LEFT_OUTER
import logging
import time

log = logging.getLogger(__name__)


class SyncTask(object):
    def __init__(self, account, mode, data, media, result, status, **kwargs):
        self.account = account

        # Sync options
        self.mode = mode
        self.data = data
        self.media = media

        # Extra arguments
        self.kwargs = kwargs

        # Handlers/Modes for task
        self.handlers = None
        self.modes = None

        # State/Result management
        self.result = result
        self.status = status

        self.exceptions = []

        self.finished = False
        self.started = False
        self.success = None

        self._abort = False

        # Construct children
        self.artifacts = SyncArtifacts(self)
        self.configuration = SyncConfiguration(self)
        self.map = SyncMap(self)
        self.pending = SyncPending(self)
        self.progress = SyncProgress(self)
        self.profiler = SyncProfiler(self)

        self.state = SyncState(self)

    @property
    def id(self):
        if self.result is None:
            return None

        return self.result.id

    @property
    def elapsed(self):
        if self.result is None:
            return None

        return (datetime.utcnow() - self.result.started_at).total_seconds()

    def construct(self, handlers, modes):
        log.debug('Constructing %d handlers...', len(handlers))
        self.handlers = dict(self._construct_modules(handlers, 'data'))

        log.debug('Constructing %d modes...', len(modes))
        self.modes = dict(self._construct_modules(modes, 'mode'))

    def load(self):
        log.debug('Task Arguments: %r', self.kwargs)

        # Load task configuration
        self.configuration.load(self.account)

        # Automatically determine enabled data types
        if self.data is None:
            self.data = self.get_enabled_data(self.configuration, self.mode)

        log.debug('Task Data: %r', self.data)
        log.debug('Task Media: %r', self.media)

        if self.data is None:
            raise QueueError('No collections enabled for sync')

        # Load children
        self.profiler.load()
        self.state.load()

    def abort(self, timeout=None):
        # Set `abort` flag, thread will abort on the next `checkpoint()`
        self._abort = True

        if timeout is None:
            return

        # Wait `timeout` seconds for task to finish
        for x in xrange(timeout):

            if self.finished:
                return

            time.sleep(1)

    def checkpoint(self):
        # Check if an abort has been requested
        if not self._abort:
            return

        raise SyncAbort()

    def finish(self):
        # Update result in database
        self.result.ended_at = datetime.utcnow()
        self.result.success = self.success
        self.result.save()

        # Store exceptions in database
        for exc_info in self.exceptions:
            try:
                self.store_exception(self.result, exc_info)
            except Exception as ex:
                log.warn('Unable to store exception: %s', str(ex), exc_info=True)

        # Flush caches to archives
        self.state.flush()

        # Display profiler report
        self.profiler.log_report()

        # Mark finished
        self.finished = True

    @staticmethod
    def store_exception(result, exc_info):
        exception, error = ExceptionManager.create.from_exc_info(exc_info)

        # Link error to result
        SyncResultError.create(
            result=result,
            error=error
        )

        # Link exception to result
        SyncResultException.create(
            result=result,
            exception=exception
        )

    @classmethod
    def create(cls, account, mode, data, media, trigger, **kwargs):
        # Get account
        if type(account) is int:
            account = cls.get_account(account)
        elif type(account) is not Account:
            raise ValueError('Unexpected value provided for the "account" parameter')

        # Get/Create sync status
        status, created = SyncStatus.get_or_create(

            account=account,
            mode=mode,
            section=kwargs.get('section', None)
        )

        # Create sync result
        result = SyncResult.create(
            status=status,
            trigger=trigger,

            started_at=datetime.utcnow()
        )

        # Create sync task
        task = SyncTask(
            account, mode,
            data, media,
            result, status,
            **kwargs
        )

        # Load sync configuration/state
        task.load()

        return task

    @classmethod
    def get_account(cls, account_id):
        # TODO Move account retrieval/join to `Account` class

        return (
            Account.select(
                Account.id,

                Account.name,

                PlexAccount.id,

                PlexAccount.key,
                PlexAccount.username,
                PlexBasicCredential.token_plex,
                PlexBasicCredential.token_server,

                TraktAccount.username,
                TraktBasicCredential.token,

                TraktOAuthCredential.access_token,
                TraktOAuthCredential.refresh_token,
                TraktOAuthCredential.created_at,
                TraktOAuthCredential.expires_in
            )
            # Plex
            .join(
                PlexAccount, JOIN_LEFT_OUTER, on=(
                    PlexAccount.account == Account.id

                ).alias('plex')
            )
            .join(
                PlexBasicCredential, JOIN_LEFT_OUTER, on=(
                    PlexBasicCredential.account == PlexAccount.id

                ).alias('basic')
            )
            # Trakt
            .switch(Account)
            .join(
                TraktAccount, JOIN_LEFT_OUTER, on=(
                    TraktAccount.account == Account.id

                ).alias('trakt')
            )
            .join(
                TraktBasicCredential, JOIN_LEFT_OUTER, on=(
                    TraktBasicCredential.account == TraktAccount.id

                ).alias('basic')
            )
            .switch(TraktAccount)
            .join(
                TraktOAuthCredential, JOIN_LEFT_OUTER, on=(
                    TraktOAuthCredential.account == TraktAccount.id

                ).alias('oauth')
            )
            .where(Account.id == account_id)

            .get()
        )

    @classmethod
    def get_enabled_data(cls, config, mode):
        # Determine accepted modes
        modes = [SyncMode.Full]

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

        # Retrieve enabled data
        enabled = []

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

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

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

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

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

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

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

        # Convert to enum value
        result = None

        for data in enabled:
            if result is None:
                result = data
                continue

            result |= data

        return result

    def _construct_modules(self, modules, attribute):
        for cls in modules:
            keys = getattr(cls, attribute, None)

            if keys is None:
                log.warn('Module %r is missing a valid %r attribute', cls, attribute)
                continue

            # Convert `keys` to list
            if type(keys) is not list:
                keys = [keys]

            # Construct module
            obj = cls(self)

            # Return module with keys
            for key in keys:
                yield key, obj


1	1	from plugin.managers.exception import ExceptionManager
2	1	from plugin.models import *
		0 ignored issues – show Bug Best Practice introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report This seems to re-define the built-in `Exception`. It is generally discouraged to redefine built-ins as this makes code very hard to read. Loading history... Coding Style introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The usage of wildcard imports like `plugin.models` should generally be avoided. Loading history...
3	1	from plugin.sync.core.enums import SyncData, SyncMode
4	1	from plugin.sync.core.exceptions import SyncAbort, QueueError
5	1	from plugin.sync.core.task.artifacts import SyncArtifacts
6	1	from plugin.sync.core.task.configuration import SyncConfiguration
7	1	from plugin.sync.core.task.map import SyncMap
8	1	from plugin.sync.core.task.pending import SyncPending
9	1	from plugin.sync.core.task.progress import SyncProgress
10	1	from plugin.sync.core.task.profiler import SyncProfiler
11	1	from plugin.sync.core.task.state import SyncState
12
13	1	from datetime import datetime
14	1	from peewee import JOIN_LEFT_OUTER
15	1	import logging
16	1	import time
17
18	1	log = logging.getLogger(__name__)
19
20
21	1	class SyncTask(object):
22	1	def __init__(self, account, mode, data, media, result, status, **kwargs):
23	1	self.account = account
24
25		# Sync options
26	1	self.mode = mode
27	1	self.data = data
28	1	self.media = media
29
30		# Extra arguments
31	1	self.kwargs = kwargs
32
33		# Handlers/Modes for task
34	1	self.handlers = None
35	1	self.modes = None
36
37		# State/Result management
38	1	self.result = result
39	1	self.status = status
40
41	1	self.exceptions = []
42
43	1	self.finished = False
44	1	self.started = False
45	1	self.success = None
46
47	1	self._abort = False
48
49		# Construct children
50	1	self.artifacts = SyncArtifacts(self)
51	1	self.configuration = SyncConfiguration(self)
52	1	self.map = SyncMap(self)
53	1	self.pending = SyncPending(self)
54	1	self.progress = SyncProgress(self)
55	1	self.profiler = SyncProfiler(self)
56
57	1	self.state = SyncState(self)
58
59	1	@property
60		def id(self):
61		if self.result is None:
62		return None
63
64		return self.result.id
65
66	1	@property
67		def elapsed(self):
68		if self.result is None:
69		return None
70
71		return (datetime.utcnow() - self.result.started_at).total_seconds()
72
73	1	def construct(self, handlers, modes):
74		log.debug('Constructing %d handlers...', len(handlers))
75		self.handlers = dict(self._construct_modules(handlers, 'data'))
76
77		log.debug('Constructing %d modes...', len(modes))
78		self.modes = dict(self._construct_modules(modes, 'mode'))
79
80	1	def load(self):
81		log.debug('Task Arguments: %r', self.kwargs)
82
83		# Load task configuration
84		self.configuration.load(self.account)
85
86		# Automatically determine enabled data types
87		if self.data is None:
88		self.data = self.get_enabled_data(self.configuration, self.mode)
89
90		log.debug('Task Data: %r', self.data)
91		log.debug('Task Media: %r', self.media)
92
93		if self.data is None:
94		raise QueueError('No collections enabled for sync')
95
96		# Load children
97		self.profiler.load()
98		self.state.load()
99
100	1	def abort(self, timeout=None):
101		# Set `abort` flag, thread will abort on the next `checkpoint()`
102		self._abort = True
103
104		if timeout is None:
105		return
106
107		# Wait `timeout` seconds for task to finish
108		for x in xrange(timeout):
		0 ignored issues – show Comprehensibility Best Practice introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report Undefined variable 'xrange' Loading history... Unused Code introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The variable `x` seems to be unused. Loading history...
109		if self.finished:
110		return
111
112		time.sleep(1)
113
114	1	def checkpoint(self):
115		# Check if an abort has been requested
116		if not self._abort:
117		return
118
119		raise SyncAbort()
120
121	1	def finish(self):
122		# Update result in database
123		self.result.ended_at = datetime.utcnow()
124		self.result.success = self.success
125		self.result.save()
126
127		# Store exceptions in database
128		for exc_info in self.exceptions:
129		try:
130		self.store_exception(self.result, exc_info)
131		except Exception as ex:
132		log.warn('Unable to store exception: %s', str(ex), exc_info=True)
133
134		# Flush caches to archives
135		self.state.flush()
136
137		# Display profiler report
138		self.profiler.log_report()
139
140		# Mark finished
141		self.finished = True
142
143	1	@staticmethod
144		def store_exception(result, exc_info):
145		exception, error = ExceptionManager.create.from_exc_info(exc_info)
146
147		# Link error to result
148		SyncResultError.create(
149		result=result,
150		error=error
151		)
152
153		# Link exception to result
154		SyncResultException.create(
155		result=result,
156		exception=exception
157		)
158
159	1	@classmethod
160		def create(cls, account, mode, data, media, trigger, **kwargs):
161		# Get account
162		if type(account) is int:
163		account = cls.get_account(account)
164		elif type(account) is not Account:
165		raise ValueError('Unexpected value provided for the "account" parameter')
166
167		# Get/Create sync status
168		status, created = SyncStatus.get_or_create(
		0 ignored issues – show Unused Code introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The variable `created` seems to be unused. Loading history...
169		account=account,
170		mode=mode,
171		section=kwargs.get('section', None)
172		)
173
174		# Create sync result
175		result = SyncResult.create(
176		status=status,
177		trigger=trigger,
178
179		started_at=datetime.utcnow()
180		)
181
182		# Create sync task
183		task = SyncTask(
184		account, mode,
185		data, media,
186		result, status,
187		**kwargs
188		)
189
190		# Load sync configuration/state
191		task.load()
192
193		return task
194
195	1	@classmethod
196		def get_account(cls, account_id):
197		# TODO Move account retrieval/join to `Account` class
		0 ignored issues – show Coding Style introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report `TODO` and `FIXME` comments should generally be avoided. Loading history...
198		return (
199		Account.select(
200		Account.id,
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `Account` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
201		Account.name,
202
203		PlexAccount.id,
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `PlexAccount` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
204		PlexAccount.key,
205		PlexAccount.username,
206		PlexBasicCredential.token_plex,
207		PlexBasicCredential.token_server,
208
209		TraktAccount.username,
210		TraktBasicCredential.token,
211
212		TraktOAuthCredential.access_token,
213		TraktOAuthCredential.refresh_token,
214		TraktOAuthCredential.created_at,
215		TraktOAuthCredential.expires_in
216		)
217		# Plex
218		.join(
219		PlexAccount, JOIN_LEFT_OUTER, on=(
220		PlexAccount.account == Account.id
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `Account` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
221		).alias('plex')
222		)
223		.join(
224		PlexBasicCredential, JOIN_LEFT_OUTER, on=(
225		PlexBasicCredential.account == PlexAccount.id
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `PlexAccount` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
226		).alias('basic')
227		)
228		# Trakt
229		.switch(Account)
230		.join(
231		TraktAccount, JOIN_LEFT_OUTER, on=(
232		TraktAccount.account == Account.id
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `Account` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
233		).alias('trakt')
234		)
235		.join(
236		TraktBasicCredential, JOIN_LEFT_OUTER, on=(
237		TraktBasicCredential.account == TraktAccount.id
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `TraktAccount` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
238		).alias('basic')
239		)
240		.switch(TraktAccount)
241		.join(
242		TraktOAuthCredential, JOIN_LEFT_OUTER, on=(
243		TraktOAuthCredential.account == TraktAccount.id
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `TraktAccount` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
244		).alias('oauth')
245		)
246		.where(Account.id == account_id)
		0 ignored issues – show Bug introduced 2016-11-18 22:00 UTC by Report Bug Copy Issue Report The Class `Account` does not seem to have a member named `id`. This check looks for calls to members that are non-existent. These calls will fail. The member could have been renamed or removed. Loading history...
247		.get()
248		)
249
250	1	@classmethod
251		def get_enabled_data(cls, config, mode):
252		# Determine accepted modes
253		modes = [SyncMode.Full]
254
255		if mode == SyncMode.Full:
256		modes.extend([
257		SyncMode.FastPull,
258		SyncMode.Pull,
259		SyncMode.Push
260		])
261		elif mode == SyncMode.FastPull:
262		modes.extend([
263		mode,
264		SyncMode.Pull
265		])
266		else:
267		modes.append(mode)
268
269		# Retrieve enabled data
270		enabled = []
271
272		if config['sync.watched.mode'] in modes:
273		enabled.append(SyncData.Watched)
274
275		if config['sync.ratings.mode'] in modes:
276		enabled.append(SyncData.Ratings)
277
278		if config['sync.playback.mode'] in modes:
279		enabled.append(SyncData.Playback)
280
281		if config['sync.collection.mode'] in modes:
282		enabled.append(SyncData.Collection)
283
284		# Lists
285		if config['sync.lists.watchlist.mode'] in modes:
286		enabled.append(SyncData.Watchlist)
287
288		if config['sync.lists.liked.mode'] in modes:
289		enabled.append(SyncData.Liked)
290
291		if config['sync.lists.personal.mode'] in modes:
292		enabled.append(SyncData.Personal)
293
294		# Convert to enum value
295		result = None
296
297		for data in enabled:
298		if result is None:
299		result = data
300		continue
301
302		result \|= data
303
304		return result
305
306	1	def _construct_modules(self, modules, attribute):
307		for cls in modules:
308		keys = getattr(cls, attribute, None)
309
310		if keys is None:
311		log.warn('Module %r is missing a valid %r attribute', cls, attribute)
312		continue
313
314		# Convert `keys` to list
315		if type(keys) is not list:
316		keys = [keys]
317
318		# Construct module
319		obj = cls(self)
320
321		# Return module with keys
322		for key in keys:
323		yield key, obj
324

fuzeman / Plex-Trakt-Scrobbler

SyncTask.elapsed() A last analyzed 2018-03-05 01:11 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

SyncTask.elapsed() A
last analyzed 2018-03-05 01:11 UTC