Main

Complexity

Total Complexity

40

Size/Duplication

Total Lines	288
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__init__()	0	13	1
B	run()	0	27	4
A	start()	0	3	1
B	init_plex()	0	34	3
A	process_server_state()	0	17	4
A	on_starting_plugins()	0	5	1
B	on_trakt_refresh()	0	47	6
A	init_trakt()	0	21	1
A	init()	0	11	3
A	on_trakt_refresh_rejected()	0	23	2
F	update_proxies()	0	62	13
A	on_configuration_changed()	0	7	1

from core.header import Header

The name header does not seem to exist in module core.

The import core.header could not be resolved.

from core.helpers import get_class_name, spawn

The name helpers does not seem to exist in module core.

The import core.helpers could not be resolved.

from core.logger import Logger

The name logger does not seem to exist in module core.

The import core.logger could not be resolved.

from core.update_checker import UpdateChecker

The name update_checker does not seem to exist in module core.

The import core.update_checker could not be resolved.

from plugin.core.constants import ACTIVITY_MODE, PLUGIN_VERSION

The import plugin.core.constants could not be resolved.

from plugin.core.helpers.thread import module_start

The import plugin.core.helpers.thread could not be resolved.

from plugin.core.logger import LOG_HANDLER, LoggerManager

The import plugin.core.logger could not be resolved.

from plugin.managers.account import TraktAccountManager

The import plugin.managers.account could not be resolved.

from plugin.managers.m_trakt.credential import TraktOAuthCredentialManager

The import plugin.managers.m_trakt.credential could not be resolved.

from plugin.models import TraktAccount

The import plugin.models could not be resolved.

from plugin.modules.core.manager import ModuleManager

The import plugin.modules.core.manager could not be resolved.

from plugin.preferences import Preferences

The import plugin.preferences could not be resolved.

from plugin.scrobbler.core.session_prefix import SessionPrefix

The import plugin.scrobbler.core.session_prefix could not be resolved.

from plex import Plex

The import plex could not be resolved.

from plex_activity import Activity

The import plex_activity could not be resolved.

from plex_metadata import Metadata

The import plex_metadata could not be resolved.

from six.moves.urllib.parse import quote_plus, urlsplit, urlunsplit

The import six.moves.urllib.parse could not be resolved.

from requests.packages.urllib3.util import Retry

The name packages does not seem to exist in module requests.

The import requests.packages.urllib3.util could not be resolved.

from trakt import Trakt

The import trakt could not be resolved.

import os
import uuid

log = Logger()


class Main(object):
    modules = [
        # core
        UpdateChecker()
    ]

    def __init__(self):
        Header.show(self)

        # Initial configuration update
        self.on_configuration_changed()

        # Initialize clients
        self.init_trakt()
        self.init_plex()
        self.init()

        # Initialize modules
        ModuleManager.initialize()

    def init(self):
        names = []

        # Initialize modules
        for module in self.modules:
            names.append(get_class_name(module))

            if hasattr(module, 'initialize'):
                module.initialize()

        log.info('Initialized %s modules: %s', len(names), ', '.join(names))

    @staticmethod
    def init_plex():
        # Ensure client identifier has been generated
        if not Dict['plex.client.identifier']:

Undefined variable 'Dict'

            # Generate identifier
            Dict['plex.client.identifier'] = uuid.uuid4()

Undefined variable 'Dict'

        # Retrieve current client identifier
        client_id = Dict['plex.client.identifier']

Undefined variable 'Dict'

        if isinstance(client_id, uuid.UUID):
            client_id = str(client_id)

        # plex.py
        Plex.configuration.defaults.authentication(
            os.environ.get('PLEXTOKEN')
        )

        Plex.configuration.defaults.client(
            identifier=client_id,

            product='trakt (for Plex)',
            version=PLUGIN_VERSION
        )

        # plex.activity.py
        path = os.path.join(LOG_HANDLER.baseFilename, '..', '..', 'Plex Media Server.log')
        path = os.path.abspath(path)

        Activity['logging'].add_hint(path)

        # plex.metadata.py
        Metadata.configure(
            client=Plex.client
        )

    @classmethod
    def init_trakt(cls):
        # Client
        Trakt.configuration.defaults.client(
            id='c9ccd3684988a7862a8542ae0000535e0fbd2d1c0ca35583af7ea4e784650a61',
            secret='bf00575b1ad252b514f14b2c6171fe650d474091daad5eb6fa890ef24d581f65'
        )

        # Application
        Trakt.configuration.defaults.app(
            name='trakt (for Plex)',
            version=PLUGIN_VERSION
        )

        # Setup request retrying
        Trakt.http.adapter_kwargs = {'max_retries': Retry(total=3, read=0)}
        Trakt.http.rebuild()

        # Bind to events
        Trakt.on('oauth.refresh', cls.on_trakt_refresh)
        Trakt.on('oauth.refresh.rejected', cls.on_trakt_refresh_rejected)

    @classmethod
    def on_trakt_refresh(cls, username, authorization):
        log.debug('[Trakt.tv] Token has been refreshed for %r', username)

        # Retrieve trakt account matching this `authorization`
        with Trakt.configuration.http(retry=True).oauth(token=authorization.get('access_token')):
            settings = Trakt['users/settings'].get(validate_token=False)

        if not settings:
            log.warn('[Trakt.tv] Unable to retrieve account details for token')
            return False

        # Retrieve trakt account username from `settings`
        s_username = settings.get('user', {}).get('username')

        if not s_username:
            log.warn('[Trakt.tv] Unable to retrieve username for token')
            return False

        if s_username != username:
            log.warn('[Trakt.tv] Token mismatch (%r != %r)', s_username, username)
            return False

        # Find matching trakt account
        trakt_account = (TraktAccount
            .select()
            .where(
                TraktAccount.username == username
            )
        ).first()

        if not trakt_account:
            log.warn('[Trakt.tv] Unable to find account with the username: %r', username)
            return False

        # Update OAuth credential
        TraktAccountManager.update.from_dict(
            trakt_account, {
                'authorization': {
                    'oauth': authorization
                }
            },
            settings=settings
        )

        log.info('[Trakt.tv] Token updated for %r', trakt_account)
        return True

    @classmethod
    def on_trakt_refresh_rejected(cls, username):
        log.debug('[Trakt.tv] Token refresh for %r has been rejected', username)

        # Find matching trakt account
        account = (TraktAccount
            .select()
            .where(
                TraktAccount.username == username
            )
        ).first()

        if not account:
            log.warn('[Trakt.tv] Unable to find account with the username: %r', username)
            return False

        # Delete OAuth credential
        TraktOAuthCredentialManager.delete(
            account=account.id
        )

        log.info('[Trakt.tv] Token cleared for %r', account)
        return True

    def start(self):
        # Construct main thread
        spawn(self.run, daemon=True, thread_name='main')

    def run(self):
        # Check for authentication token
        log.info('X-Plex-Token: %s', 'available' if os.environ.get('PLEXTOKEN') else 'unavailable')

        # Process server startup state
        self.process_server_state()

        # Start new-style modules
        module_start()

        # Start modules
        names = []

        for module in self.modules:
            if not hasattr(module, 'start'):
                continue

            names.append(get_class_name(module))

            module.start()

        log.info('Started %s modules: %s', len(names), ', '.join(names))

        ModuleManager.start()

        # Start plex.activity.py
        Activity.start(ACTIVITY_MODE.get(Preferences.get('activity.mode')))

    @classmethod
    def process_server_state(cls):
        # Check startup state
        server = Plex.detail()

        if server is None:
            log.info('Unable to check startup state, detail request failed')
            return

        # Check server startup state
        if server.start_state is None:
            return

        if server.start_state == 'startingPlugins':
            return cls.on_starting_plugins()

        log.error('Unhandled server start state %r', server.start_state)

    @staticmethod
    def on_starting_plugins():
        log.debug('on_starting_plugins')

        SessionPrefix.increment()

    @classmethod
    def on_configuration_changed(cls):
        # Update proxies (for requests)
        cls.update_proxies()

        # Refresh loggers
        LoggerManager.refresh()

    @staticmethod
    def update_proxies():
        # Retrieve proxy host
        host = Prefs['proxy_host']

Undefined variable 'Prefs'

        if not host:
            if not Trakt.http.proxies and not os.environ.get('HTTP_PROXY') and not os.environ.get('HTTPS_PROXY'):
                return

            # Update trakt client
            Trakt.http.proxies = {}

            # Update environment variables
            if 'HTTP_PROXY' in os.environ:
                del os.environ['HTTP_PROXY']

            if 'HTTPS_PROXY' in os.environ:
                del os.environ['HTTPS_PROXY']

            log.info('HTTP Proxy has been disabled')
            return

        # Parse URL
        host_parsed = urlsplit(host)

        # Expand components
        scheme, netloc, path, query, fragment = host_parsed

        if not scheme:
            scheme = 'http'

        # Retrieve proxy credentials
        username = Prefs['proxy_username']

Undefined variable 'Prefs'

        password = Prefs['proxy_password']

Undefined variable 'Prefs'

        # Build URL
        if username and password and '@' not in netloc:
            netloc = '%s:%s@%s' % (
                quote_plus(username),
                quote_plus(password),
                netloc
            )

        url = urlunsplit((scheme, netloc, path, query, fragment))

        # Update trakt client
        Trakt.http.proxies = {
            'http': url,
            'https': url
        }

        # Update environment variables
        os.environ.update({
            'HTTP_PROXY': url,
            'HTTPS_PROXY': url
        })

        # Display message in log file
        if not host_parsed.username and not host_parsed.password:
            log.info('HTTP Proxy has been enabled (host: %r)', host)
        else:
            log.info('HTTP Proxy has been enabled (host: <sensitive>)')