Introducing AsyncIO Support & Request Timeouts

.github/workflows/publish.yml

@@ -9,11 +9,11 @@ jobs:
     runs-on: ubuntu-18.04
 
     steps:
-    - uses: actions/checkout@master
-    - name: Set up Python 3.9
-      uses: actions/setup-python@v1
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v3
       with:
-        python-version: 3.9
+        python-version: "3.11"
     - name: Install pypa/build
       run: >-
         python -m
@@ -31,4 +31,4 @@ jobs:
     - name: Publish distribution 📦 to PyPI
       uses: pypa/gh-action-pypi-publish@master
       with:
-        password: ${{ secrets.PYPI_API_TOKEN }}
+        password: ${{ secrets.PYPI_API_TOKEN }}

.github/workflows/python-app.yml

@@ -19,14 +19,14 @@ jobs:
 
     steps:
     - uses: actions/checkout@v3
-    - name: Set up Python 3.10
+    - name: Set up Python 3.11
       uses: actions/setup-python@v3
       with:
-        python-version: "3.10"
+        python-version: "3.11"
     - name: Install dependencies
       run: |
         python -m pip install --upgrade pip
-        pip install requests flake8 pytest
+        pip install requests flake8 pytest pytest-asyncio
         if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
     - name: Lint with flake8
       run: |

.gitignore

@@ -103,8 +103,12 @@ venv.bak/
 .mypy_cache/
 
 .DS_Store
+.idea
 
 # Pipenv
 Pipfile
 Pipfile.lock
 .vscode/launch.json
+
+# Unasync
+knockapi/sync_client

MANIFEST.in

@@ -0,0 +1 @@
+recursive-include knockapi/sync_client *

README.md

@@ -118,7 +118,22 @@ client.users.set_preferences(
 client.users.get_preferences(user_id="jhammond")
 ```
 
-### Signing JWTs
+## AsyncIO Usage
+The library utilises the [unasync](https://github.com/python-trio/unasync) library to provide full AsyncIO support, you just need to import the AsyncKnock client.
+```python
+import asyncio
+from knockapi import AsyncKnock
+
+client = AsyncKnock(api_key="sk_12345")
+
+async def example_coroutine():
+    messages = await client.messages.list()
+    print(messages)
+
+asyncio.run(example_coroutine())
+```
+
+## Signing JWTs
 
 You can use the `pyjwt` package to [sign JWTs easily](https://pyjwt.readthedocs.io/en/stable/usage.html#encoding-decoding-tokens-with-rs256-rsa).
 You will need to generate an environment specific signing key, which you can find in the Knock dashboard.

knockapi/__init__.py

@@ -1,2 +1,14 @@
-from knockapi.client import Knock
-from knockapi.resources import *
+__version__ = '0.6.0'
+
+from knockapi.async_client import Knock as AsyncKnock
+
+try:
+    from knockapi.sync_client import Knock
+except ImportError:
+    Knock = None
+
+__all__ = [
+    "AsyncKnock",
+    "Knock",
+    "__version__"
+]

knockapi/client.py → knockapi/async_client/Knock.py

@@ -1,94 +1,62 @@
-import requests
-from json.decoder import JSONDecodeError
-
-__version__ = '0.5.2'
-
-
-class Connection(object):
-    def __init__(self, api_key, host='https://api.knock.app'):
-        self.api_key = api_key
-        self.host = host
-        self.client_version = __version__
-        self.headers = {
-            'Authorization': 'Bearer {}'.format(self.api_key),
-            'User-Agent': 'Knock Python - {}'.format(self.client_version)
-        }
-
-    def request(self, method, endpoint, payload=None):
-        url = '{}/v1{}'.format(self.host, endpoint)
-
-        r = requests.request(
-            method,
-            url,
-            params=payload if method == 'get' else None,
-            json=payload if method != 'get' else None,
-            headers=self.headers,
-        )
-
-        # If we got a successful response, then attempt to deserialize as JSON
-        if r.ok:
-            try:
-                return r.json()
-            except JSONDecodeError:
-                return None
+from knockapi import __version__
+from knockapi.core import AsyncConnection
+from knockapi.async_client.services import User, Workflows, Preferences, Objects, Tenants, BulkOperations, Messages
 
-        return r.raise_for_status()
 
-
-class Knock(Connection):
+class Knock(object):
     """Client to access the Knock features."""
-    @property
-    def _auth(self):
-        return self.api_key
 
-    @property
-    def _version(self):
-        return __version__
+    def __init__(
+        self,
+        api_key: str,
+        api_host: str = 'https://api.knock.app',
+        read_timeout: int = 300
+    ):
+        self.connection = AsyncConnection(
+            api_key,
+            api_host,
+            __version__,
+            read_timeout
+        )
 
     @property
     def users(self):
-        from .resources import User
         return User(self)
 
     @property
     def workflows(self):
-        from .resources import Workflows
         return Workflows(self)
 
     @property
     def preferences(self):
-        from .resources import Preferences
         return Preferences(self)
 
     @property
     def objects(self):
-        from .resources import Objects
         return Objects(self)
 
     @property
     def tenants(self):
-        from .resources import Tenants
         return Tenants(self)
 
     @property
     def bulk_operations(self):
-        from .resources import BulkOperations
         return BulkOperations(self)
 
     @property
     def messages(self):
-        from .resources import Messages
         return Messages(self)
 
     # Defined at the top level here for convenience
-    def notify(
-            self,
-            key,
-            recipients,
-            data={},
-            actor=None,
-            cancellation_key=None,
-            tenant=None):
+    async def notify(
+        self,
+        key,
+        recipients,
+        data={},
+        actor=None,
+        cancellation_key=None,
+        tenant=None
+    ):
         """
         Triggers a workflow.
 
@@ -112,10 +80,11 @@ def notify(
             dict: Response from Knock.
         """
         # Note: this is essentially a delegated method
-        return self.workflows.trigger(
+        return await self.workflows.trigger(
             key=key,
             recipients=recipients,
             data=data,
             actor=actor,
             cancellation_key=cancellation_key,
-            tenant=tenant)
+            tenant=tenant
+        )

knockapi/async_client/__init__.py

@@ -0,0 +1 @@
+from .Knock import Knock

knockapi/async_client/services/bulk_operations.py

@@ -0,0 +1,19 @@
+from knockapi.core.Service import Service
+
+default_set_id = "default"
+
+
+class BulkOperations(Service):
+
+    async def get(self, bulk_operation_id):
+        """
+        Returns a bulk operation.
+
+        Args:
+            bulk_operation_id (str): The id of the bulk operation
+
+        Returns:
+            dict: A Knock BulkOperation
+        """
+        endpoint = f'/bulk_operations/{bulk_operation_id}'
+        return await self.client.connection.request('get', endpoint)

knockapi/resources/messages.py → knockapi/async_client/services/messages.py

@@ -1,8 +1,11 @@
 import json
-from .service import Service
+
+from knockapi.core.Service import Service
+
 
 class Messages(Service):
-    def list(self, options=None):
+
+    async def list(self, options=None):
         """
         Gets a paginated list of Message records
 
@@ -17,60 +20,60 @@ def list(self, options=None):
         if options and options['trigger_data']:
             options['trigger_data'] = json.dumps(options['trigger_data'])
 
-        return self.client.request('get', endpoint, payload=options)
+        return await self.client.connection.request('get', endpoint, payload=options)
 
-    def get(self, id):
+    async def get(self, message_id):
         """
         Get a message by its id
 
         Args:
-            id: The message ID
+            message_id: The message ID
 
         Returns:
             dict: Message response from Knock.
         """
-        endpoint = '/messages/{}'.format(id)
-        return self.client.request('get', endpoint)
+        endpoint = f'/messages/{message_id}'
+        return await self.client.connection.request('get', endpoint)
 
-    def get_content(self, id):
+    async def get_content(self, message_id):
         """
         Get a message's content by its id
 
         Args:
-            id: The message ID
+            message_id: The message ID
 
         Returns:
             dict: MessageContent response from Knock.
         """
-        endpoint = '/messages/{}/content'.format(id)
-        return self.client.request('get', endpoint)
+        endpoint = f'/messages/{message_id}/content'
+        return await self.client.connection.request('get', endpoint)
 
-    def get_activities(self, id, options=None):
+    async def get_activities(self, message_id, options=None):
         """
         Get a message's activities by its id
 
         Args:
-            id: The message ID
+            message_id: The message ID
 
         Returns:
             dict: paginated Activity response from Knock.
         """
-        endpoint = '/messages/{}/activities'.format(id)
+        endpoint = f'/messages/{message_id}/activities'
 
         if options and options['trigger_data']:
             options['trigger_data'] = json.dumps(options['trigger_data'])
 
-        return self.client.request('get', endpoint, options)
+        return await self.client.connection.request('get', endpoint, options)
 
-    def get_events(self, id, options=None):
+    async def get_events(self, message_id, options=None):
         """
         Get a message's events by its id
 
         Args:
-            id: The message ID
+            message_id: The message ID
 
         Returns:
             dict: paginated Event response from Knock.
         """
-        endpoint = '/messages/{}/events'.format(id)
-        return self.client.request('get', endpoint, options)
+        endpoint = f'/messages/{message_id}/events'
+        return await self.client.connection.request('get', endpoint, options)