Add initial redis-py asyncio client (#5)

* Add initial redis-py asyncio client
* Add additional compressors from django-redis
* Use GitHub Actions instead of Travis
* Upgrade dependencies
* Update tox dependencies
* Set publishing pipeline using GitHub Actions
* Bump version to 0.2.0

Author: Andrew-Chen-Wang

.github/workflows/ci.yml

@@ -0,0 +1,57 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.7', '3.8', '3.9', '3.10', '3.11']
+        django-version: ['3.2', '4.1']
+        exclude:
+          - python-version: '3.10'
+            django-version: '3.2'
+          - python-version: '3.11'
+            django-version: '3.2'
+          - python-version: '3.7'
+            django-version: '4.1'
+    services:
+      redis:
+        image: redis:6
+        ports:
+          - 6379:6379
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Get pip cache dir
+      id: pip-cache
+      run: |
+        echo "::set-output name=dir::$(pip cache dir)"
+    - name: Cache
+      uses: actions/cache@v2
+      with:
+        path: ${{ steps.pip-cache.outputs.dir }}
+        key:
+          ${{ matrix.python-version }}-v1-${{ hashFiles('**/setup.py') }}
+        restore-keys: |
+          ${{ matrix.python-version }}-v1-
+    - name: Install dependencies
+      run: |
+        sudo apt-get install -y zlib1g-dev
+        python -m pip install --upgrade pip wheel
+        python -m pip install tox tox-gh-actions coveralls
+    - name: Tox Test
+      run: tox
+      env:
+        PYTHON_VER: ${{ matrix.python-version }}
+        DJANGO: ${{ matrix.django-version }}

.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+# This workflows will upload a Python Package using Twine when a release is created
+# For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries
+
+name: Upload Python Package
+
+on:
+  release:
+    types: [created]
+
+jobs:
+  deploy:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools wheel twine
+    - name: Build and publish
+      env:
+        TWINE_USERNAME: __token__
+        TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
+      run: |
+        python setup.py sdist bdist_wheel
+        twine upload dist/*

.pre-commit-config.yaml

@@ -10,12 +10,12 @@ repos:
       - id: check-yaml
 
   - repo: https://github.com/psf/black
-    rev: 19.10b0
+    rev: 22.12.0
     hooks:
       - id: black
 
   - repo: https://github.com/timothycrosley/isort
-    rev: 4.3.21
+    rev: 5.11.4
     hooks:
       - id: isort
-        args: ['--settings-path=setup.cfg', '-rc']
+        args: ['--settings-path=setup.cfg']

.travis.yml

@@ -2,4 +2,24 @@
 
 __author__ = """Andrew Chen Wang"""
 __email__ = "[email protected]"
-__version__ = "0.1.0"
+
+VERSION = (0, 2, 0)
+__version__ = ".".join(map(str, VERSION))
+
+
+def get_redis_connection(alias="default", write=True):
+    """
+    Helper used for obtaining a raw redis client.
+    """
+
+    from django.core.cache import caches
+
+    cache = caches[alias]
+
+    if not hasattr(cache, "client"):
+        raise NotImplementedError("This backend does not support this feature")
+
+    if not hasattr(cache.client, "get_client"):
+        raise NotImplementedError("This backend does not support this feature")
+
+    return cache.client.get_client(write)

django_async_redis/__init__.py

@@ -1,9 +1,8 @@
 import functools
 import logging
 from collections import OrderedDict
-from typing import Any, AsyncGenerator, Optional, Union
+from typing import Any, AsyncIterator, Callable, Optional, Union
 
-from asgiref.sync import async_to_sync
 from django.conf import settings
 from django.core.cache.backends.base import BaseCache
 from django.utils.module_loading import import_string
@@ -19,7 +18,9 @@
 CONNECTION_INTERRUPTED = object()
 
 
-def omit_exception(method=None, return_value=None):
+def omit_exception(
+    method: Optional[Callable] = None, return_value: Optional[Any] = None
+):
     """
     Simple decorator that intercepts connection
     errors and ignores these if settings specify this.
@@ -35,7 +36,7 @@ def _decorator(self, *args, **kwargs):
         except ConnectionInterrupted as e:
             if self._ignore_exceptions:
                 if self._log_ignored_exceptions:
-                    self.logger.error(str(e))
+                    self.logger.exception("Exception ignored")
 
                 return return_value
             raise e.__cause__
@@ -70,10 +71,6 @@ def __init__(self, server, params):
             else None
         )
 
-    def close(self, **kwargs):
-        # TODO Remove this once Django's close_caches implement cache.close_async
-        async_to_sync(self.close_async)()
-
     @property
     def client(self) -> Union[DefaultClient]:
         """
@@ -84,103 +81,94 @@ def client(self) -> Union[DefaultClient]:
         return self._client
 
     @omit_exception
-    async def set_async(self, *args, **kwargs):
-        """
-        :param key: the cache key.
-        :param value: the cache's value.
-        :param timeout: the timeout in seconds. Will be sent as pexpire.
-        :param version: cache version.
-        :param client: the client to use.
-        :param nx: sets the nx flag. Not set if xx is True.
-        :param xx: sets the xx flag. Takes precedence over nx if True.
-        """
+    async def aset(self, *args, **kwargs):
         return await self.client.set(*args, **kwargs)
 
     @omit_exception
-    async def incr_version_async(self, *args, **kwargs):
+    async def aincr_version(self, *args, **kwargs):
         return await self.client.incr_version(*args, **kwargs)
 
     @omit_exception
-    async def add_async(self, *args, **kwargs):
+    async def aadd(self, *args, **kwargs):
         return await self.client.add(*args, **kwargs)
 
-    async def get_async(self, key, default=None, version=None, client=None):
-        value = await self._get_async(key, default, version, client)
+    async def aget(self, key, default=None, version=None, client=None):
+        value = await self._aget(key, default, version, client)
         if value is CONNECTION_INTERRUPTED:
             value = default
         return value
 
     @omit_exception(return_value=CONNECTION_INTERRUPTED)
-    async def _get_async(self, key, default, version, client):
+    async def _aget(self, key, default, version, client):
         return await self.client.get(
             key, default=default, version=version, client=client
         )
 
     @omit_exception
-    async def delete_async(self, *args, **kwargs):
+    async def adelete(self, *args, **kwargs):
         return await self.client.delete(*args, **kwargs)
 
     @omit_exception
-    async def delete_pattern_async(self, *args, **kwargs):
+    async def adelete_pattern(self, *args, **kwargs):
         kwargs["itersize"] = kwargs.get("itersize", DJANGO_ASYNC_REDIS_SCAN_ITERSIZE)
         return await self.client.delete_pattern(*args, **kwargs)
 
     @omit_exception
-    async def delete_many_async(self, *args, **kwargs):
+    async def adelete_many(self, *args, **kwargs):
         return await self.client.delete_many(*args, **kwargs)
 
     @omit_exception
-    async def clear_async(self) -> None:
+    async def aclear(self) -> None:
         await self.client.clear()
 
     @omit_exception(return_value={})
-    async def get_many_async(self, *args, **kwargs) -> OrderedDict:
+    async def aget_many(self, *args, **kwargs) -> OrderedDict:
         return await self.client.get_many(*args, **kwargs)
 
     @omit_exception
-    async def set_many_async(self, *args, **kwargs):
+    async def aset_many(self, *args, **kwargs):
         return await self.client.set_many(*args, **kwargs)
 
     @omit_exception
-    async def incr_async(self, *args, **kwargs):
+    async def aincr(self, *args, **kwargs):
         return await self.client.incr(*args, **kwargs)
 
     @omit_exception
-    async def decr_async(self, *args, **kwargs):
+    async def adecr(self, *args, **kwargs):
         return await self.client.decr(*args, **kwargs)
 
     @omit_exception
-    async def has_key_async(self, *args, **kwargs):
+    async def ahas_key(self, *args, **kwargs):
         return await self.client.has_key(*args, **kwargs)
 
     @omit_exception
-    async def keys_async(self, *args, **kwargs):
+    async def akeys(self, *args, **kwargs):
         return await self.client.keys(*args, **kwargs)
 
     @omit_exception
-    async def iter_keys_async(self, *args, **kwargs) -> AsyncGenerator[str, Any]:
+    async def aiter_keys(self, *args, **kwargs) -> AsyncIterator[str]:
         """
         Returns a coroutine that the dev will
         await since an async generator is returned.
         """
         return self.client.iter_keys(*args, **kwargs)
 
     @omit_exception
-    async def ttl_async(self, *args, **kwargs) -> Optional[int]:
+    async def attl(self, *args, **kwargs) -> Optional[int]:
         return await self.client.ttl(*args, **kwargs)
 
     @omit_exception
-    async def persist_async(self, *args, **kwargs):
+    async def apersist(self, *args, **kwargs):
         return await self.client.persist(*args, **kwargs)
 
     @omit_exception
-    async def expire_async(self, *args, **kwargs):
+    async def aexpire(self, *args, **kwargs):
         return await self.client.expire(*args, **kwargs)
 
     @omit_exception
-    async def close_async(self, **kwargs) -> None:
+    async def aclose(self, **kwargs) -> None:
         await self.client.close(**kwargs)
 
     @omit_exception
-    async def touch_async(self, *args, **kwargs):
+    async def atouch(self, *args, **kwargs):
         return await self.client.touch(*args, **kwargs)