[4.0.0]: PoC: Refactor api client

tests/conftest.py

@@ -2,8 +2,12 @@
 import json
 import os
 from copy import deepcopy
+from functools import lru_cache
+
+from requests import Session
 
 import trakt
+from trakt.api import HttpClient
 
 TESTS_DIR = os.path.dirname(__file__)
 MOCK_DATA_DIR = os.path.join(TESTS_DIR, "mock_data")
@@ -25,31 +29,29 @@
 ]
 
 
-class MockCore(trakt.core.Core):
-    def __init__(self, *args, **kwargs):
-        super(MockCore, self).__init__(*args, **kwargs)
+class MockCore():
+    def __init__(self):
         self.mock_data = {}
         for mock_file in MOCK_DATA_FILES:
             with open(mock_file, encoding='utf-8') as f:
                 self.mock_data.update(json.load(f))
 
-    def _handle_request(self, method, url, data=None):
-        uri = url[len(trakt.core.BASE_URL):]
+    def request(self, method, uri, data=None):
         if uri.startswith('/'):
             uri = uri[1:]
         # use a deepcopy of the mocked data to ensure clean responses on every
         # request. this prevents rewrites to JSON responses from persisting
-        method_responses = deepcopy(self.mock_data).get(uri, {})
-        return method_responses.get(method.upper())
+        method_responses = self.mock_data.get(uri, {})
+        response = method_responses.get(method.upper())
+        if response is None:
+            print(f"No mock for {uri}")
+        return deepcopy(response)
 
 
-"""Override utility functions from trakt.core to use an underlying MockCore
-instance
+"""Override request function with MockCore instance
 """
-trakt.core.CORE = MockCore()
-trakt.core.get = trakt.core.CORE.get
-trakt.core.post = trakt.core.CORE.post
-trakt.core.delete = trakt.core.CORE.delete
-trakt.core.put = trakt.core.CORE.put
+
+trakt.core.api().request = MockCore().request
+
 trakt.core.CLIENT_ID = 'FOO'
 trakt.core.CLIENT_SECRET = 'BAR'

tests/test_api.py

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+"""trakt.tv functional tests"""
+from trakt.api import HttpClient
+from trakt.core import api, Alias
+from trakt.tv import TVShow
+
+
+def test_api():
+    api1 = api()
+    api2 = api()
+    assert isinstance(api1, HttpClient)
+    assert api1 == api2
+
+    show = TVShow('Game of Thrones')
+    assert show.title == 'Game of Thrones'
+    assert show.certification == 'TV-MA'

trakt/api.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""Interfaces to all of the People objects offered by the Trakt.tv API"""
+import json
+import logging
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache
+from json import JSONDecodeError
+
+from requests import Session
+from requests.auth import AuthBase
+
+from trakt import errors
+from trakt.config import AuthConfig
+from trakt.errors import BadResponseException, OAuthException
+
+__author__ = 'Jon Nappi, Elan Ruusamäe'
+
+
+class HttpClient:
+    """Class for abstracting HTTP requests
+    """
+
+    #: Default request HEADERS
+    headers = {'Content-Type': 'application/json', 'trakt-api-version': '2'}
+
+    def __init__(self, base_url: str, session: Session):
+        self.base_url = base_url
+        self.session = session
+        self.logger = logging.getLogger('trakt.http_client')
+        self.auth = None
+
+    def get(self, url: str):
+        return self.request('get', url)
+
+    def delete(self, url: str):
+        self.request('delete', url)
+
+    def post(self, url: str, data):
+        return self.request('post', url, data=data)
+
+    def put(self, url: str, data):
+        return self.request('put', url, data=data)
+
+    def set_auth(self, auth):
+        self.auth = auth
+
+    def request(self, method, url, data=None):
+        """Handle actually talking out to the trakt API, logging out debug
+        information, raising any relevant `TraktException` Exception types,
+        and extracting and returning JSON data
+
+        :param method: The HTTP method we're executing on. Will be one of
+            post, put, delete, get
+        :param url: The fully qualified url to send our request to
+        :param data: Optional data payload to send to the API
+        :return: The decoded JSON response from the Trakt API
+        :raises TraktException: If any non-200 return code is encountered
+        """
+
+        url = self.base_url + url
+        self.logger.debug('REQUEST [%s] (%s)', method, url)
+        if method == 'get':  # GETs need to pass data as params, not body
+            response = self.session.request(method, url, headers=self.headers, auth=self.auth, params=data)
+        else:
+            response = self.session.request(method, url, headers=self.headers, auth=self.auth, data=json.dumps(data))
+        self.logger.debug('RESPONSE [%s] (%s): %s', method, url, str(response))
+
+        if response.status_code == 204:  # HTTP no content
+            return None
+        self.raise_if_needed(response)
+
+        return self.decode_response(response)
+
+    @staticmethod
+    def decode_response(response):
+        try:
+            return json.loads(response.content.decode('UTF-8', 'ignore'))
+        except JSONDecodeError as e:
+            raise BadResponseException(f"Unable to parse JSON: {e}")
+
+    def raise_if_needed(self, response):
+        if response.status_code in self.error_map:
+            raise self.error_map[response.status_code](response)
+
+    @property
+    @lru_cache(maxsize=None)
+    def error_map(self):
+        """Map HTTP response codes to exception types
+        """
+
+        # Get all of our exceptions except the base exception
+        errs = [getattr(errors, att) for att in errors.__all__
+                if att != 'TraktException']
+
+        return {err.http_code: err for err in errs}
+
+
+class TokenAuth(AuthBase):
+    """Attaches Trakt.tv token Authentication to the given Request object."""
+
+    # OAuth token validity checked
+    OAUTH_TOKEN_VALID = None
+
+    #: The OAuth2 Redirect URI for your OAuth Application
+    REDIRECT_URI: str = 'urn:ietf:wg:oauth:2.0:oob'
+
+    def __init__(self, client: HttpClient, config: AuthConfig):
+        super().__init__()
+        self.config = config
+        self.client = client
+        self.logger = logging.getLogger('trakt.api.token_auth')
+
+    def __call__(self, r):
+        # Skip oauth requests
+        if r.path_url.startswith('/oauth/'):
+            return r
+
+        [client_id, client_token] = self.get_token()
+
+        r.headers.update({
+            'trakt-api-key': client_id,
+            'Authorization': f'Bearer {client_token}',
+        })
+        return r
+
+    def get_token(self):
+        """Return client_id, client_token pair needed for Trakt.tv authentication
+        """
+
+        self.config.load()
+        # Check token validity and refresh token if needed
+        if not self.OAUTH_TOKEN_VALID and self.config.have_refresh_token():
+            self.validate_token()
+
+        return [
+            self.config.CLIENT_ID,
+            self.config.OAUTH_TOKEN,
+        ]
+
+    def validate_token(self):
+        """Check if current OAuth token has not expired"""
+
+        current = datetime.now(tz=timezone.utc)
+        expires_at = datetime.fromtimestamp(self.config.OAUTH_EXPIRES_AT, tz=timezone.utc)
+        if expires_at - current > timedelta(days=2):
+            self.OAUTH_TOKEN_VALID = True
+        else:
+            self.refresh_token()
+
+    def refresh_token(self):
+        """Request Trakt API for a new valid OAuth token using refresh_token"""
+
+        self.logger.info("OAuth token has expired, refreshing now...")
+        data = {
+            'client_id': self.config.CLIENT_ID,
+            'client_secret': self.config.CLIENT_SECRET,
+            'refresh_token': self.config.OAUTH_REFRESH,
+            'redirect_uri': self.REDIRECT_URI,
+            'grant_type': 'refresh_token'
+        }
+
+        try:
+            response = self.client.post('/oauth/token', data)
+        except OAuthException:
+            self.logger.debug(
+                "Rejected - Unable to refresh expired OAuth token, "
+                "refresh_token is invalid"
+            )
+            return
+
+        self.config.update(
+            OAUTH_TOKEN=response.get("access_token"),
+            OAUTH_REFRESH=response.get("refresh_token"),
+            OAUTH_EXPIRES_AT=response.get("created_at") + response.get("expires_in"),
+        )
+        self.OAUTH_TOKEN_VALID = True
+
+        self.logger.info(
+            "OAuth token successfully refreshed, valid until {}".format(
+                datetime.fromtimestamp(self.config.OAUTH_EXPIRES_AT, tz=timezone.utc)
+            )
+        )
+        self.config.store()

trakt/auth/__init__.py

@@ -0,0 +1,74 @@
+# -*- coding: utf-8 -*-
+"""Authentication methods"""
+
+__author__ = 'Jon Nappi, Elan Ruusamäe'
+
+from trakt import PIN_AUTH, OAUTH_AUTH, DEVICE_AUTH, api, config as config_factory
+from trakt.config import AuthConfig
+
+
+def pin_auth(*args, config, **kwargs):
+    from trakt.auth.pin import PinAuthAdapter
+
+    return PinAuthAdapter(*args, client=api(), config=config, **kwargs).authenticate()
+
+
+def oauth_auth(*args, config, **kwargs):
+    from trakt.auth.oauth import OAuthAdapter
+
+    return OAuthAdapter(*args, client=api(), config=config, **kwargs).authenticate()
+
+
+def device_auth(config):
+    from trakt.auth.device import DeviceAuthAdapter
+
+    return DeviceAuthAdapter(client=api(), config=config).authenticate()
+
+
+def get_client_info(app_id: bool, config: AuthConfig):
+    """Helper function to poll the user for Client ID and Client Secret
+    strings
+
+    :return: A 2-tuple of client_id, client_secret
+    """
+    print('If you do not have a client ID and secret. Please visit the '
+          'following url to create them.')
+    print('http://trakt.tv/oauth/applications')
+    client_id = input('Please enter your client id: ')
+    client_secret = input('Please enter your client secret: ')
+    if app_id:
+        msg = f'Please enter your application ID ({config.APPLICATION_ID}): '
+        user_input = input(msg)
+        if user_input:
+            config.APPLICATION_ID = user_input
+    return client_id, client_secret
+
+
+def init_auth(method: str, *args, client_id=None, client_secret=None, store=False, **kwargs):
+    """Run the auth function specified by *AUTH_METHOD*
+
+    :param store: Boolean flag used to determine if your trakt api auth data
+    should be stored locally on the system. Default is :const:`False` for
+    the security conscious
+    """
+
+    methods = {
+        PIN_AUTH: pin_auth,
+        OAUTH_AUTH: oauth_auth,
+        DEVICE_AUTH: device_auth,
+    }
+
+    config = config_factory()
+    adapter = methods.get(method, PIN_AUTH)
+
+    """
+    Update client_id, client_secret from input or ask them interactively
+    """
+    if client_id is None and client_secret is None:
+        client_id, client_secret = get_client_info(adapter.NEEDS_APPLICATION_ID, config)
+    config.CLIENT_ID, config.CLIENT_SECRET = client_id, client_secret
+
+    adapter(*args, config=config, **kwargs)
+
+    if store:
+        config.store()

trakt/auth/base.py

@@ -0,0 +1,6 @@
+class BaseAdapter:
+    #: The OAuth2 Redirect URI for your OAuth Application
+    REDIRECT_URI: str = 'urn:ietf:wg:oauth:2.0:oob'
+
+    #: True if the Adapter needs APPLICATION_ID
+    NEEDS_APPLICATION_ID = False