Merge pull request #4 from fortmatic/ajen_issue_3994_implement_user_class

Implement User resource

Author: Arthur Jen

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v2.4.0
+    rev: v2.5.0
     hooks:
     -   id: flake8
         language_version: python3.6
@@ -29,21 +29,21 @@ repos:
     -   id: check-json
         files: \.(jshintrc|json)$
 -   repo: https://github.com/pre-commit/mirrors-autopep8
-    rev: v1.4.4
+    rev: v1.5.1
     hooks:
     -   id: autopep8
         language_version: python3.6
 -   repo: https://github.com/asottile/add-trailing-comma
-    rev: v1.5.0
+    rev: v2.0.1
     hooks:
     -   id: add-trailing-comma
 -   repo: https://github.com/asottile/reorder_python_imports
-    rev: v1.9.0
+    rev: v2.2.0
     hooks:
     -   id: reorder-python-imports
         language_version: python3.6
 -   repo: https://github.com/asottile/pyupgrade
-    rev: v1.25.2
+    rev: v2.1.1
     hooks:
     -   id: pyupgrade
         args:

magic_admin/__init__.py

@@ -1,5 +1,8 @@
-from magic_admin.error import *
 from magic_admin.magic import Magic
 
 
+# Magic API secret key.
+api_secret_key = None
+
+# A grace period time in second applied to the nbf field for token validation.
 did_token_nbf_grace_period_s = 300

magic_admin/config.py

@@ -0,0 +1,7 @@
+base_url = 'https://api.stagef.magic.link'
+
+api_secret_api_key_missing_message = 'API secret key is missing. Please specify ' \
+    'an API secret key when you instantiate the `Magic(api_secret_key=<KEY>)` ' \
+    'object or use the environment variable, `MAGIC_API_SECRET_KEY`. You can ' \
+    'get your API secret key from https://dashboard.magic.link. If you are having ' \
+    'trouble, please don\'t hesitate to reach out to us at support@magic.link'

magic_admin/error.py

@@ -13,6 +13,76 @@ def __repr__(self):
             message=self._message,
         )
 
+    def to_dict(self):
+        return {'message': str(self)}
+
 
 class DIDTokenError(MagicError):
     pass
+
+
+class APIConnectionError(MagicError):
+    pass
+
+
+class RequestError(MagicError):
+
+    def __init__(
+        self,
+        message=None,
+        http_status=None,
+        http_code=None,
+        http_resp_data=None,
+        http_message=None,
+        http_error_code=None,
+        http_request_params=None,
+        http_request_data=None,
+        http_method=None,
+    ):
+        super().__init__(message)
+        self.http_status = http_status
+        self.http_code = http_code
+        self.http_resp_data = http_resp_data
+        self.http_message = http_message
+        self.http_error_code = http_error_code
+        self.http_request_params = http_request_params
+        self.http_request_data = http_request_data
+        self.http_method = http_method
+
+    def __repr__(self):
+        return '{error_class}(message={message!r}, ' \
+            'http_error_code={http_error_code}, ' \
+            'http_code={http_code}).'.format(
+                error_class=self.__class__.__name__,
+                message=self._message or None,
+                http_error_code=self.http_error_code or None,
+                http_code=self.http_code or None,
+            )
+
+    def to_dict(self):
+        _dict = super().to_dict()
+        for attr in self.__dict__:
+            if attr.startswith('http_'):
+                _dict[attr] = self.__dict__[attr]
+
+        return _dict
+
+
+class RateLimitingError(RequestError):
+    pass
+
+
+class BadRequestError(RequestError):
+    pass
+
+
+class AuthenticationError(RequestError):
+    pass
+
+
+class ForbiddenError(RequestError):
+    pass
+
+
+class APIError(RequestError):
+    pass

magic_admin/http_client.py

@@ -0,0 +1,139 @@
+import platform
+
+import simplejson
+from requests import Session
+from requests.adapters import HTTPAdapter
+from requests.packages.urllib3.util.retry import Retry
+
+import magic_admin
+from magic_admin import version
+from magic_admin.config import api_secret_api_key_missing_message
+from magic_admin.config import base_url
+from magic_admin.error import APIConnectionError
+from magic_admin.error import APIError
+from magic_admin.error import AuthenticationError
+from magic_admin.error import BadRequestError
+from magic_admin.error import ForbiddenError
+from magic_admin.error import RateLimitingError
+from magic_admin.response import MagicResponse
+
+
+class RequestsClient:
+
+    def __init__(self, retries, timeout, backoff_factor):
+        self._retries = retries
+        self._timeout = timeout
+        self._backoff_factor = backoff_factor
+
+        self._setup_request_session()
+
+    @staticmethod
+    def _get_platform_info():
+        platform_info = {}
+
+        for attr, func in [
+            ['platform', platform.platform],
+            ['language_version', platform.python_version],
+            ['uname', platform.uname],
+        ]:
+            try:
+                val = str(func())
+            except Exception as e:
+                val = '<{}>'.format(str(e))
+
+            platform_info[attr] = val
+
+        return platform_info
+
+    def _setup_request_session(self):
+        """Take advantage of the ``requets.Session``. If client is making several
+        requests to the same host, the underlying TCP connection will be reused,
+        which can result in a significant performance increase.
+        """
+        self.http = Session()
+        self.http.mount(
+            base_url,
+            HTTPAdapter(
+                max_retries=Retry(
+                    total=self._retries,
+                    backoff_factor=self._backoff_factor,
+                ),
+            ),
+        )
+
+    def _get_request_headers(self):
+        user_agent = {
+            'language': 'python',
+            'sdk_version': version.VERSION,
+            'publisher': 'magic',
+            'http_lib': self.__class__.__name__,
+            **self._get_platform_info(),
+        }
+
+        if magic_admin.api_secret_key is None:
+            raise AuthenticationError(api_secret_api_key_missing_message)
+
+        return {
+            'X-Magic-Secret-Key': magic_admin.api_secret_key,
+            'User-Agent': simplejson.dumps(user_agent),
+        }
+
+    def request(self, method, url, params=None, data=None):
+        try:
+            api_resp = self.http.request(
+                method,
+                url,
+                params=params,
+                # Requests auto-converts this to JSON and add content-type
+                # `application/json`.
+                json=data,
+                headers=self._get_request_headers(),
+                timeout=self._timeout,
+            )
+        except Exception as e:
+            return self._handle_request_error(e)
+
+        return self._parse_and_convert_to_api_response(
+            api_resp,
+            params,
+            data,
+        )
+
+    def _parse_and_convert_to_api_response(self, resp, request_params, request_data):
+        status_code = resp.status_code
+
+        if 200 <= status_code < 300:
+            return MagicResponse(resp.content, resp.json(), status_code)
+
+        if status_code == 429:
+            error_class = RateLimitingError
+        elif status_code == 400:
+            error_class = BadRequestError
+        elif status_code == 401:
+            error_class = AuthenticationError
+        elif status_code == 403:
+            error_class = ForbiddenError
+        else:
+            error_class = APIError
+
+        resp_data = resp.json()
+        raise error_class(
+            http_status=resp_data.get('status'),
+            http_code=status_code,
+            http_resp_data=resp_data.get('data'),
+            http_message=resp_data.get('message'),
+            http_error_code=resp_data.get('error_code'),
+            http_request_params=request_params,
+            http_request_data=request_data,
+            http_method=resp.request.method,
+        )
+
+    def _handle_request_error(self, e):
+        message = 'Unexpected error thrown while communicating to Magic. ' \
+            'Please reach out to support@magic.link if the problem continues. ' \
+            'Error message: {error_class} was raised - {error_message}'.format(
+                error_class=e.__class__.__name__,
+                error_message=str(e) or 'no error message.',
+            )
+
+        raise APIConnectionError(message)

magic_admin/magic.py

@@ -1,15 +1,42 @@
+import os
+
+import magic_admin
+from magic_admin.config import api_secret_api_key_missing_message
+from magic_admin.error import AuthenticationError
 from magic_admin.resources.base import ResourceComponent
 
 
+RETRIES = 3
+TIMEOUT = 10
+BACKOFF_FACTOR = 0.02
+
+
 class Magic:
 
     def __getattr__(self, attribute_name):
         try:
-            return getattr(self.resource, attribute_name)
+            return getattr(self._resource, attribute_name)
         except AttributeError:
             pass
 
         return super().__getattribute__(attribute_name)
 
-    def __init__(self):
-        self.resource = ResourceComponent()
+    def __init__(
+        self,
+        api_secret_key=None,
+        retries=RETRIES,
+        timeout=TIMEOUT,
+        backoff_factor=BACKOFF_FACTOR,
+    ):
+        self._resource = ResourceComponent()
+
+        self._resource.setup_request_client(retries, timeout, backoff_factor)
+        self._set_api_secret_key(api_secret_key)
+
+    def _set_api_secret_key(self, api_secret_key):
+        magic_admin.api_secret_key = api_secret_key or os.environ.get(
+            'MAGIC_API_SECRET_KEY',
+        )
+
+        if magic_admin.api_secret_key is None:
+            raise AuthenticationError(api_secret_api_key_missing_message)

magic_admin/resources/base.py

@@ -1,3 +1,7 @@
+from magic_admin.config import base_url
+from magic_admin.http_client import RequestsClient
+
+
 class ResourceMeta(type):
 
     def __init__(cls, name, bases, cls_dict):
@@ -11,6 +15,8 @@ def __init__(cls, name, bases, cls_dict):
 
 class ResourceComponent(metaclass=ResourceMeta):
 
+    _base_url = base_url
+
     def __getattr__(self, resource_name):
         if resource_name in self._registry:
             return self._registry[resource_name]
@@ -21,3 +27,23 @@ def __getattr__(self, resource_name):
                     resource_name=resource_name,
                 ),
             )
+
+    def setup_request_client(self, retries, timeout, backoff_factor):
+        _request_client = RequestsClient(retries, timeout, backoff_factor)
+
+        for resource in self._registry.values():
+            setattr(resource, '_request_client', _request_client)
+
+    def _construct_url(self, url_path):
+        return '{base_url}{url_path}'.format(
+            base_url=self._base_url,
+            url_path=url_path,
+        )
+
+    def request(self, method, url_path, params=None, data=None):
+        return self._request_client.request(
+            method.lower(),
+            self._construct_url(url_path),
+            params=params,
+            data=data,
+        )

magic_admin/resources/token.py

@@ -6,6 +6,7 @@
 
 from magic_admin.error import DIDTokenError
 from magic_admin.resources.base import ResourceComponent
+from magic_admin.utils.did_token import parse_public_address_from_issuer
 from magic_admin.utils.time import apply_did_token_nbf_grace_period
 from magic_admin.utils.time import epoch_time_now
 
@@ -25,19 +26,6 @@ class Token(ResourceComponent):
         'tid',
     ])
 
-    @staticmethod
-    def _parse_public_address(issuer):
-        """
-        Args:
-            issuer (str): Issuer (the signer, the "user"). This field is represented
-                as a Decentralized Identifier populated with the user's Ethereum
-                public key.
-
-        Returns:
-            public_address (str): An Ethereum public key.
-        """
-        return issuer.split(':')[-1]
-
     @classmethod
     def _check_required_fields(cls, claim):
         """
@@ -133,7 +121,7 @@ def get_public_address(cls, did_token):
         Returns:
             public_address (str): An Ethereum public key.
         """
-        return cls._parse_public_address(cls.get_issuer(did_token))
+        return parse_public_address_from_issuer(cls.get_issuer(did_token))
 
     @classmethod
     def validate(cls, did_token):