Merge pull request #115 from eadwinCode/ruff_linting

Ruff linting and mypy upgrade

Author: eadwinCode

.github/workflows/test_full.yml

@@ -23,7 +23,7 @@ jobs:
       - name: Install Dependencies
         run: flit install --symlink
       - name: Test
-        run: pytest tests
+        run: pytest
 
   codestyle:
     runs-on: ubuntu-latest
@@ -38,10 +38,8 @@ jobs:
       - name: Install Dependencies
         run: flit install --symlink
       - name: Black
-        run: black --check ellar tests
-      - name: isort
-        run: isort --check ellar tests
-      - name: Flake8
-        run: flake8 ellar tests
+        run: black --check ellar tests examples
+      - name: Ruff Linting Check
+        run: ruff check ellar tests examples
       - name: mypy
         run: mypy ellar

.gitignore

@@ -126,4 +126,4 @@ dist
 test.py
 
 docs/site
-site/
+site/

Makefile

@@ -18,21 +18,19 @@ install-full: ## Install dependencies
 	pre-commit install -f
 
 lint: ## Run code linters
-	black --check ellar tests
-	isort --check ellar tests
-	autoflake --remove-unused-variables --remove-unused-variables -r ellar tests
-	flake8 ellar tests
+	black --check ellar tests examples
+	ruff check ellar tests examples
 	mypy ellar
 
 fmt format: ## Run code formatters
-	black ellar tests
-	isort ellar tests
+	black ellar tests examples
+	ruff check --fix ellar tests examples
 
 test: ## Run tests
-	pytest tests
+	pytest
 
 test-cov: ## Run tests with coverage
-	pytest --cov=ellar --cov-report term-missing tests
+	pytest --cov=ellar --cov-report term-missing
 
 doc-deploy: ## Run Deploy Documentation
 	make clean

ellar/auth/guard.py

@@ -1,10 +1,9 @@
 import typing as t
 from functools import partial
 
-from starlette import status
-
 from ellar.common import APIException, GuardCanActivate, IExecutionContext
 from ellar.di import injectable
+from starlette import status
 
 from .constants import POLICY_KEYS
 from .policy import BasePolicyHandler, PolicyType

ellar/auth/handlers/schemes/base.py

@@ -1,15 +1,14 @@
 import typing as t
 from abc import ABC, abstractmethod
 
-from starlette.exceptions import HTTPException
-from starlette.status import HTTP_401_UNAUTHORIZED
-
 from ellar.common.exceptions import APIException
 from ellar.common.interfaces import IHostContext
 from ellar.common.serializer.guard import (
     HTTPAuthorizationCredentials,
     HTTPBasicCredentials,
 )
+from starlette.exceptions import HTTPException
+from starlette.status import HTTP_401_UNAUTHORIZED
 
 if t.TYPE_CHECKING:  # pragma: no cover
     from ellar.core.connection import HTTPConnection

ellar/auth/handlers/schemes/http.py

@@ -91,7 +91,7 @@ def _get_credentials(self, connection: "HTTPConnection") -> HTTPBasicCredentials
 
         if not separator:
             self._not_unauthorized_exception("Invalid authentication credentials")
-        return HTTPBasicCredentials(username=username, password=password)
+        return HTTPBasicCredentials(username=username, password=password)  # type: ignore[arg-type]
 
 
 class HttpDigestAuth(HttpBearerAuth, ABC):

ellar/auth/services/auth_schemes.py

@@ -20,10 +20,10 @@ def add_authentication(
     def find_authentication_scheme(self, scheme: str) -> AuthenticationHandlerType:
         try:
             return self._authentication_schemes[scheme]
-        except KeyError:
+        except KeyError as ex:
             raise RuntimeError(
                 f'No Authentication Scheme found with the name:"{scheme}"'
-            )
+            ) from ex
 
     def get_authentication_schemes(
         self,

ellar/auth/session/strategy.py

@@ -1,19 +1,17 @@
 try:
     import itsdangerous
-except Exception:  # pragma: no cover
+except Exception as ex:  # pragma: no cover
     raise RuntimeError(
         "SessionClientStrategy requires itsdangerous package installed. Run `pip install itsdangerous`"
-    )
+    ) from ex
 
 import json
 import typing as t
 from base64 import b64decode, b64encode
 
-import itsdangerous
-from itsdangerous import BadSignature
-
 from ellar.core import Config
 from ellar.di import injectable
+from itsdangerous import BadSignature
 
 from .cookie_dict import SessionCookieObject
 from .interface import ISessionStrategy
@@ -26,12 +24,12 @@ def __init__(self, config: Config) -> None:
         self._signer = itsdangerous.TimestampSigner(str(config.SECRET_KEY))
         self.config = config
         self._session_config = SessionCookieOption(
-            NAME=config.SESSION_COOKIE_NAME,
+            NAME=config.SESSION_COOKIE_NAME or "",
             DOMAIN=config.SESSION_COOKIE_DOMAIN,
             PATH=config.SESSION_COOKIE_PATH or "/",
-            HTTPONLY=config.SESSION_COOKIE_HTTPONLY,
-            SECURE=config.SESSION_COOKIE_SECURE,
-            SAME_SITE=config.SESSION_COOKIE_SAME_SITE,
+            HTTPONLY=config.SESSION_COOKIE_HTTPONLY or False,
+            SECURE=config.SESSION_COOKIE_SECURE or False,
+            SAME_SITE=config.SESSION_COOKIE_SAME_SITE or "none",
             MAX_AGE=config.SESSION_COOKIE_MAX_AGE,
         )
 

ellar/cache/backends/base.py

@@ -11,16 +11,16 @@ class _BasePylibMemcachedCacheSync(BaseCacheBackend, ABC):
     _cache_client: t.Any
 
     @make_key_decorator
-    def get(self, key: str, version: str = None) -> t.Any:
+    def get(self, key: str, version: t.Optional[str] = None) -> t.Any:
         return self._cache_client.get(key)
 
     @make_key_decorator_and_validate
     def set(
         self,
         key: str,
         value: t.Any,
-        ttl: t.Union[float, int] = None,
-        version: str = None,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         result = self._cache_client.set(key, value, int(self.get_backend_ttl(ttl)))
         if not result:
@@ -31,24 +31,27 @@ def set(
         return bool(result)
 
     @make_key_decorator
-    def delete(self, key: str, version: str = None) -> bool:
+    def delete(self, key: str, version: t.Optional[str] = None) -> bool:
         result = self._cache_client.delete(key)
         return bool(result)
 
     @make_key_decorator
     def touch(
-        self, key: str, ttl: t.Union[float, int] = None, version: str = None
+        self,
+        key: str,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         result = self._cache_client.touch(key, self.get_backend_ttl(ttl))
         return bool(result)
 
     @make_key_decorator
-    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+    def incr(self, key: str, delta: int = 1, version: t.Optional[str] = None) -> int:
         result = self._cache_client.incr(key, abs(delta))
         return t.cast(int, result)
 
     @make_key_decorator
-    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+    def decr(self, key: str, delta: int = 1, version: t.Optional[str] = None) -> int:
         result = self._cache_client.decr(key, abs(delta))
         return t.cast(int, result)
 
@@ -62,7 +65,9 @@ def clear(self) -> None:
 class BasePylibMemcachedCache(_BasePylibMemcachedCacheSync):
     MEMCACHE_CLIENT: t.Type
 
-    def __init__(self, servers: t.List[str], options: t.Dict = None, **kwargs: t.Any):
+    def __init__(
+        self, servers: t.List[str], options: t.Optional[t.Dict] = None, **kwargs: t.Any
+    ):
         super().__init__(**kwargs)
         self._servers = servers
 
@@ -83,25 +88,28 @@ def _cache_client(self) -> t.Any:
     async def executor(self, func: t.Callable, *args: t.Any, **kwargs: t.Any) -> t.Any:
         return await run_in_threadpool(func, *args, **kwargs)
 
-    async def get_async(self, key: str, version: str = None) -> t.Any:
+    async def get_async(self, key: str, version: t.Optional[str] = None) -> t.Any:
         return await self.executor(self.get, key, version=version)
 
     async def set_async(
         self,
         key: str,
         value: t.Any,
-        ttl: t.Union[float, int] = None,
-        version: str = None,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         result = await self.executor(self.set, key, value, ttl=ttl, version=version)
         return bool(result)
 
-    async def delete_async(self, key: str, version: str = None) -> bool:
+    async def delete_async(self, key: str, version: t.Optional[str] = None) -> bool:
         result = await self.executor(self.delete, key, version=version)
         return bool(result)
 
     async def touch_async(
-        self, key: str, ttl: t.Union[float, int] = None, version: str = None
+        self,
+        key: str,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         result = await self.executor(self.touch, key, ttl=ttl, version=version)
         return bool(result)
@@ -117,10 +125,14 @@ def validate_key(self, key: str) -> None:
         super().validate_key(key)
         self._memcache_key_warnings(key)
 
-    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+    async def incr_async(
+        self, key: str, delta: int = 1, version: t.Optional[str] = None
+    ) -> int:
         res = await self.executor(self.incr, key, delta=delta, version=version)
         return t.cast(int, res)
 
-    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+    async def decr_async(
+        self, key: str, delta: int = 1, version: t.Optional[str] = None
+    ) -> int:
         res = await self.executor(self.decr, key, delta=delta, version=version)
         return t.cast(int, res)

ellar/cache/backends/local_cache.py

@@ -5,7 +5,6 @@
 from collections import OrderedDict
 
 from anyio import Lock
-
 from ellar.common.helper.event_loop import get_or_create_eventloop
 
 from ..interface import IBaseCacheBackendAsync
@@ -17,34 +16,37 @@ class _LocalMemCacheBackendSync(IBaseCacheBackendAsync, ABC):
     def _async_executor(self, func: t.Awaitable) -> t.Any:
         return get_or_create_eventloop().run_until_complete(func)
 
-    def get(self, key: str, version: str = None) -> t.Any:
+    def get(self, key: str, version: t.Optional[str] = None) -> t.Any:
         return self._async_executor(self.get_async(key, version=version))
 
-    def delete(self, key: str, version: str = None) -> bool:
+    def delete(self, key: str, version: t.Optional[str] = None) -> bool:
         res = self._async_executor(self.delete_async(key, version=version))
         return bool(res)
 
     def set(
         self,
         key: str,
         value: t.Any,
-        ttl: t.Union[float, int] = None,
-        version: str = None,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         res = self._async_executor(self.set_async(key, value, ttl=ttl, version=version))
         return bool(res)
 
     def touch(
-        self, key: str, ttl: t.Union[float, int] = None, version: str = None
+        self,
+        key: str,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         res = self._async_executor(self.touch_async(key, ttl=ttl, version=version))
         return bool(res)
 
-    def incr(self, key: str, delta: int = 1, version: str = None) -> int:
+    def incr(self, key: str, delta: int = 1, version: t.Optional[str] = None) -> int:
         res = self._async_executor(self.incr_async(key, delta=delta, version=version))
         return t.cast(int, res)
 
-    def decr(self, key: str, delta: int = 1, version: str = None) -> int:
+    def decr(self, key: str, delta: int = 1, version: t.Optional[str] = None) -> int:
         res = self._async_executor(self.decr_async(key, delta=delta, version=version))
         return t.cast(int, res)
 
@@ -59,7 +61,7 @@ def __init__(self, **kwargs: t.Any) -> None:
         self._lock = Lock()
 
     @make_key_decorator
-    async def get_async(self, key: str, version: str = None) -> t.Any:
+    async def get_async(self, key: str, version: t.Optional[str] = None) -> t.Any:
         async with self._lock:
             if self._has_expired(key):
                 await self._delete(key)
@@ -77,7 +79,7 @@ async def _delete(self, key: str) -> bool:
         return True
 
     @make_key_decorator
-    async def delete_async(self, key: str, version: str = None) -> bool:
+    async def delete_async(self, key: str, version: t.Optional[str] = None) -> bool:
         async with self._lock:
             return await self._delete(key)
 
@@ -86,8 +88,8 @@ async def set_async(
         self,
         key: str,
         value: t.Any,
-        ttl: t.Union[float, int] = None,
-        version: str = None,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         async with self._lock:
             self._cache[key] = pickle.dumps(value, self.pickle_protocol)
@@ -99,7 +101,7 @@ def _has_expired(self, key: str) -> bool:
         return exp is not None and exp <= time.time()
 
     @make_key_decorator
-    async def has_key_async(self, key: str, version: str = None) -> bool:
+    async def has_key_async(self, key: str, version: t.Optional[str] = None) -> bool:
         async with self._lock:
             if self._has_expired(key):
                 await self._delete(key)
@@ -108,7 +110,10 @@ async def has_key_async(self, key: str, version: str = None) -> bool:
 
     @make_key_decorator
     async def touch_async(
-        self, key: str, ttl: t.Union[float, int] = None, version: str = None
+        self,
+        key: str,
+        ttl: t.Union[float, int, None] = None,
+        version: t.Optional[str] = None,
     ) -> bool:
         async with self._lock:
             if self._has_expired(key):
@@ -117,7 +122,7 @@ async def touch_async(
             self._expire_track[key] = self.get_backend_ttl(ttl)
             return True
 
-    def has_key(self, key: str, version: str = None) -> bool:
+    def has_key(self, key: str, version: t.Optional[str] = None) -> bool:
         res = self._async_executor(self.has_key_async(key, version=version))
         return bool(res)
 
@@ -130,15 +135,19 @@ def _incr_decr_action(self, key: str, delta: int) -> int:
         return new_value
 
     @make_key_decorator
-    async def incr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+    async def incr_async(
+        self, key: str, delta: int = 1, version: t.Optional[str] = None
+    ) -> int:
         async with self._lock:
             if self._has_expired(key):
                 await self._delete(key)
                 raise ValueError("Key '%s' not found" % key)
             return self._incr_decr_action(key, delta)
 
     @make_key_decorator
-    async def decr_async(self, key: str, delta: int = 1, version: str = None) -> int:
+    async def decr_async(
+        self, key: str, delta: int = 1, version: t.Optional[str] = None
+    ) -> int:
         async with self._lock:
             if self._has_expired(key):
                 await self._delete(key)