ActionManager.queue() - Code Metrics - Inspection of "Merge branch 'release/1.0.2.1' into beta" - fuzeman/Plex-Trakt-Scrobbler - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — beta ( 67e420...91a9ed )

by Dean

created 2016-05-20 03:24 UTC

ActionManager.queue() D

↳ Parent: ActionManager

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	110

Metric	Value
dl	0
loc	52
ccs	0
cts	28
cp	0
rs	4.5
cc	10
crap	110

How to fix Long Method Complexity

from plugin.core.helpers.thread import module
from plugin.managers.core.base import Manager
from plugin.models import ActionHistory, ActionQueue
from plugin.preferences import Preferences

from datetime import datetime, timedelta
from threading import Thread
from trakt import Trakt
import apsw
import json
import logging
import peewee
import time

log = logging.getLogger(__name__)


@module(start=True, blocking=True)
class ActionManager(Manager):
    _process_enabled = True
    _process_thread = None

    #
    # Queue
    #

    @classmethod
    def queue(cls, event, request, session=None, account=None):
        if event is None:
            return None

        obj = None

        if request is not None:
            request = json.dumps(request)

        # Retrieve `account_id` for action
        account_id = None

        if session:
            try:
                account_id = session.account_id
            except KeyError:
                account_id = None

        if account_id is None and account:
            account_id = account.id

        if account_id is None:
            log.debug('Unable to find valid account for event %r, session %r', event, session)
            return None

        if not Preferences.get('scrobble.enabled', account_id):
            log.debug('Scrobbler not enabled for account %r', account_id)
            return None

        # Try queue the event
        try:
            obj = ActionQueue.create(
                account=account_id,
                session=session,

                progress=session.progress,
                rating_key=session.rating_key,

                event=event,
                request=request,

                queued_at=datetime.utcnow()
            )
            log.debug('Queued %r event for %r', event, session)
        except (apsw.ConstraintError, peewee.IntegrityError), ex:
            log.warn('Unable to queue event %r for %r: %s', event, session, ex, exc_info=True)

        # Ensure process thread is started
        cls.start()

        return obj

    @classmethod
    def delete(cls, session_id, event):
        ActionQueue.delete().where(
            ActionQueue.session == session_id,
            ActionQueue.event == event
        ).execute()

    #
    # Process
    #
    @classmethod
    def start(cls):
        if cls._process_thread is not None:
            return

        cls._process_thread = Thread(target=cls.run)
        cls._process_thread.daemon = True

        cls._process_thread.start()

    @classmethod
    def run(cls):
        while cls._process_enabled:
            # Retrieve one action from the queue
            try:
                action = ActionQueue.get()
            except ActionQueue.DoesNotExist:
                time.sleep(5)
                continue
            except Exception, ex:
                log.warn('Unable to retrieve action from queue - %s', ex, exc_info=True)
                time.sleep(5)
                continue

            log.debug('Retrieved %r action from queue', action.event)

            try:
                performed = cls.process(action)

                cls.resolve(action, performed)

                log.debug('Action %r sent, moved action to history', action.event)
            except Exception, ex:
                log.warn('Unable to process action %r - %s', action.event, ex, exc_info=True)
            finally:
                time.sleep(5)

    @classmethod
    def process(cls, action):
        if not action.request:
            return None

        if cls.is_duplicate(action):
            return None

        interface, method = action.event.split('/')
        request = str(action.request)

        log.debug('Sending action %r (account: %r, interface: %r, method: %r)', action.event, action.account, interface, method)

        try:
            result = cls.send(action, Trakt[interface][method], request)
        except Exception, ex:
            log.error('Unable to send action %r: %r', action.event, ex, exc_info=True)
            return None

        if not result:
            # Invalid response
            return None

        if interface == 'scrobble':
            return result.get('action')

        log.warn('result: %r', result)
        return None

    @classmethod
    def is_duplicate(cls, action):
        if action.event != 'scrobble/stop':
            return False

        # Retrieve scrobble duplication period
        duplication_period = Preferences.get('scrobble.duplication_period')

        if duplication_period is None:
            return False

        # Check for duplicate scrobbles in `duplication_period`
        scrobbled = ActionHistory.has_scrobbled(
            action.account, action.rating_key,
            after=action.queued_at - timedelta(minutes=duplication_period)
        )

        if scrobbled:
            log.info(
                'Ignoring duplicate %r action, scrobble already performed in the last %d minutes',
                action.event, duplication_period
            )
            return True

        return False

    @classmethod
    def send(cls, action, func, request):
        # Retrieve `Account` for action
        account = action.account

        if not account:
            log.info('Missing `account` for action, unable to send')
            return None

        # Retrieve request data
        request = json.loads(request)
        log.debug('request: %r', request)

        # Send request with account authorization
        trakt_account = account.trakt

        if trakt_account is None:
            log.info('Missing trakt account for %r', account)
            return None
        
        with trakt_account.authorization():
            return func(**request)

    @classmethod
    def resolve(cls, action, performed):
        # Store action in history
        ActionHistory.create(
            account=action.account_id,
            session=action.session_id,

            rating_key=action.rating_key,

            event=action.event,
            performed=performed,

            queued_at=action.queued_at,
            sent_at=datetime.utcnow()
        )

        # Delete queued action
        cls.delete(action.session_id, action.event)


1			from plugin.core.helpers.thread import module
2			from plugin.managers.core.base import Manager
3			from plugin.models import ActionHistory, ActionQueue
4			from plugin.preferences import Preferences
5
6			from datetime import datetime, timedelta
7			from threading import Thread
8			from trakt import Trakt
9			import apsw
10			import json
11			import logging
12			import peewee
13			import time
14
15			log = logging.getLogger(__name__)
16
17
18			@module(start=True, blocking=True)
19			class ActionManager(Manager):
20			_process_enabled = True
21			_process_thread = None
22
23			#
24			# Queue
25			#
26
27			@classmethod
28			def queue(cls, event, request, session=None, account=None):
29			if event is None:
30			return None
31
32			obj = None
33
34			if request is not None:
35			request = json.dumps(request)
36
37			# Retrieve `account_id` for action
38			account_id = None
39
40			if session:
41			try:
42			account_id = session.account_id
43			except KeyError:
44			account_id = None
45
46			if account_id is None and account:
47			account_id = account.id
48
49			if account_id is None:
50			log.debug('Unable to find valid account for event %r, session %r', event, session)
51			return None
52
53			if not Preferences.get('scrobble.enabled', account_id):
54			log.debug('Scrobbler not enabled for account %r', account_id)
55			return None
56
57			# Try queue the event
58			try:
59			obj = ActionQueue.create(
60			account=account_id,
61			session=session,
62
63			progress=session.progress,
64			rating_key=session.rating_key,
65
66			event=event,
67			request=request,
68
69			queued_at=datetime.utcnow()
70			)
71			log.debug('Queued %r event for %r', event, session)
72			except (apsw.ConstraintError, peewee.IntegrityError), ex:
73			log.warn('Unable to queue event %r for %r: %s', event, session, ex, exc_info=True)
74
75			# Ensure process thread is started
76			cls.start()
77
78			return obj
79
80			@classmethod
81			def delete(cls, session_id, event):
82			ActionQueue.delete().where(
83			ActionQueue.session == session_id,
84			ActionQueue.event == event
85			).execute()
86
87			#
88			# Process
89			#
90			@classmethod
91			def start(cls):
92			if cls._process_thread is not None:
93			return
94
95			cls._process_thread = Thread(target=cls.run)
96			cls._process_thread.daemon = True
97
98			cls._process_thread.start()
99
100			@classmethod
101			def run(cls):
102			while cls._process_enabled:
103			# Retrieve one action from the queue
104			try:
105			action = ActionQueue.get()
106			except ActionQueue.DoesNotExist:
107			time.sleep(5)
108			continue
109			except Exception, ex:
110			log.warn('Unable to retrieve action from queue - %s', ex, exc_info=True)
111			time.sleep(5)
112			continue
113
114			log.debug('Retrieved %r action from queue', action.event)
115
116			try:
117			performed = cls.process(action)
118
119			cls.resolve(action, performed)
120
121			log.debug('Action %r sent, moved action to history', action.event)
122			except Exception, ex:
123			log.warn('Unable to process action %r - %s', action.event, ex, exc_info=True)
124			finally:
125			time.sleep(5)
126
127			@classmethod
128			def process(cls, action):
129			if not action.request:
130			return None
131
132			if cls.is_duplicate(action):
133			return None
134
135			interface, method = action.event.split('/')
136			request = str(action.request)
137
138			log.debug('Sending action %r (account: %r, interface: %r, method: %r)', action.event, action.account, interface, method)
139
140			try:
141			result = cls.send(action, Trakt[interface][method], request)
142			except Exception, ex:
143			log.error('Unable to send action %r: %r', action.event, ex, exc_info=True)
144			return None
145
146			if not result:
147			# Invalid response
148			return None
149
150			if interface == 'scrobble':
151			return result.get('action')
152
153			log.warn('result: %r', result)
154			return None
155
156			@classmethod
157			def is_duplicate(cls, action):
158			if action.event != 'scrobble/stop':
159			return False
160
161			# Retrieve scrobble duplication period
162			duplication_period = Preferences.get('scrobble.duplication_period')
163
164			if duplication_period is None:
165			return False
166
167			# Check for duplicate scrobbles in `duplication_period`
168			scrobbled = ActionHistory.has_scrobbled(
169			action.account, action.rating_key,
170			after=action.queued_at - timedelta(minutes=duplication_period)
171			)
172
173			if scrobbled:
174			log.info(
175			'Ignoring duplicate %r action, scrobble already performed in the last %d minutes',
176			action.event, duplication_period
177			)
178			return True
179
180			return False
181
182			@classmethod
183			def send(cls, action, func, request):
184			# Retrieve `Account` for action
185			account = action.account
186
187			if not account:
188			log.info('Missing `account` for action, unable to send')
189			return None
190
191			# Retrieve request data
192			request = json.loads(request)
193			log.debug('request: %r', request)
194
195			# Send request with account authorization
196			trakt_account = account.trakt
197
198			if trakt_account is None:
199			log.info('Missing trakt account for %r', account)
200			return None
201
202			with trakt_account.authorization():
203			return func(**request)
204
205			@classmethod
206			def resolve(cls, action, performed):
207			# Store action in history
208			ActionHistory.create(
209			account=action.account_id,
210			session=action.session_id,
211
212			rating_key=action.rating_key,
213
214			event=action.event,
215			performed=performed,
216
217			queued_at=action.queued_at,
218			sent_at=datetime.utcnow()
219			)
220
221			# Delete queued action
222			cls.delete(action.session_id, action.event)
223

fuzeman / Plex-Trakt-Scrobbler

Push — beta ( 67e420...91a9ed )

ActionManager.queue() D

Complexity

Size

Duplication

Code Coverage

How to fix Long Method Complexity

Long Method

Complexity

Duplication Side-by-Side

Filter issues like