qena-shared-lib 0.1.17__py3-none-any.whl → 0.1.19__py3-none-any.whl

qena_shared_lib/security.py

@@ -173,44 +173,51 @@ class EndpointAclValidator:
             permission_match_strategy or PermissionMatch.SOME
         )
 
+        if self._permissions is not None:
+            self._permissions = sorted(self._permissions)
+
     def __call__(
         self, user_info: Annotated[UserInfo, Depends(extract_user_info)]
     ) -> UserInfo:
-        if (
-            self._user_type is not None
-            and (
-                user_info.user_type is None
-                or user_info.user_type != self._user_type
-            )
-        ) or (
-            self._permissions is not None
-            and (
-                user_info.user_permissions is None
-                or not self._permissions_match(user_info.user_permissions)
-            )
+        if self._user_type_match(user_info) and self._permissions_match(
+            user_info
         ):
-            raise Unauthorized(
-                message=MESSAGE,
-                response_code=RESPONSE_CODE,
-                tags=[user_info.user_id],
-                extra={
-                    "userId": user_info.user_id,
-                    "userType": user_info.user_type,
-                    "userPermissions": str(user_info.user_permissions or []),
-                    "requiredUserType": self._user_type or "None",
-                    "requiredPermissions": str(self._permissions or []),
-                    "permissionMatchStrategy": self._permission_match_strategy.name,
-                },
-            )
-
-        return user_info
-
-    def _permissions_match(self, user_permissions: list[str]) -> bool:
-        assert self._permissions is not None
+            return user_info
+
+        raise Unauthorized(
+            message=MESSAGE,
+            response_code=RESPONSE_CODE,
+            tags=[user_info.user_id],
+            extra={
+                "userId": user_info.user_id,
+                "userType": user_info.user_type,
+                "userPermissions": str(user_info.user_permissions or []),
+                "requiredUserType": self._user_type or "None",
+                "requiredPermissions": str(self._permissions or []),
+                "permissionMatchStrategy": self._permission_match_strategy.name,
+            },
+        )
+
+    def _user_type_match(self, user_info: UserInfo) -> bool:
+        if self._user_type is None:
+            return True
+
+        if user_info.user_type is None:
+            return False
+
+        return user_info.user_type == self._user_type
+
+    def _permissions_match(self, user_info: UserInfo) -> bool:
+        if self._permissions is None:
+            return True
+
+        if user_info.user_permissions is None:
+            return False
 
         if self._permission_match_strategy == PermissionMatch.ALL:
-            return sorted(self._permissions) == sorted(user_permissions)
+            return self._permissions == sorted(user_info.user_permissions)
 
         return any(
-            permission in self._permissions for permission in user_permissions
+            permission in self._permissions
+            for permission in user_info.user_permissions
         )

qena_shared_lib/sync.py

@@ -0,0 +1,91 @@
+from inspect import Traceback
+from typing import cast
+
+from redis.asyncio import Redis
+from redis.asyncio.lock import Lock
+from typing_extensions import Self
+
+from .redis import RedisDependent
+
+__all__ = [
+    "DistributedLockGuard",
+    "DistributedLockManager",
+]
+
+
+class DistributedLockGuard:
+    def __init__(
+        self,
+        distributed_lock_manager: "DistributedLockManager",
+        key: str,
+        blocking: bool = True,
+    ):
+        self._distributed_lock_manager = distributed_lock_manager
+        self._key = key
+        self._blocking = blocking
+        self._is_acquired = False
+
+    @property
+    def is_aquired(self) -> bool:
+        return self._is_acquired
+
+    async def __aenter__(self) -> Self:
+        if self._blocking:
+            await self._distributed_lock_manager.acquire(self._key)
+        else:
+            self._is_acquired = (
+                await self._distributed_lock_manager.try_acquire(self._key)
+            )
+
+        return self
+
+    async def __aexit__(
+        self,
+        exception_type: type[Exception],
+        exception: Exception,
+        traceback: Traceback,
+    ) -> None:
+        del exception_type, exception, traceback
+
+        await self._distributed_lock_manager.release(self._key)
+
+        self._is_acquired = False
+
+
+class DistributedLockManager(RedisDependent):
+    def __init__(self, lock_timeout: int = 30):
+        self._lock_timeout = lock_timeout
+        self._lockes: dict[str, Lock] = {}
+
+    def attach(self, redis_client: Redis) -> None:
+        self._redis_client = redis_client
+
+    async def acquire(self, key: str) -> None:
+        lock = self._register_lock(key)
+
+        await lock.acquire()
+
+    async def try_acquire(self, key: str) -> bool:
+        lock = self._register_lock(key=key, blocking=False)
+        is_acquired = await lock.acquire()
+
+        return cast(bool, is_acquired)
+
+    def _register_lock(self, key: str, blocking: bool = True) -> Lock:
+        if key not in self._lockes:
+            self._lockes[key] = self._redis_client.lock(
+                name=key, blocking=blocking, timeout=self._lock_timeout
+            )
+
+        return self._lockes[key]
+
+    async def release(self, key: str) -> None:
+        if key not in self._lockes or not await self._lockes[key].owned():
+            return
+
+        await self._lockes[key].release()
+
+    def __call__(self, key: str, blocking: bool = True) -> DistributedLockGuard:
+        return DistributedLockGuard(
+            distributed_lock_manager=self, key=key, blocking=blocking
+        )

qena_shared_lib/utils.py

@@ -1,4 +1,5 @@
 from asyncio import AbstractEventLoop, get_running_loop
+from types import UnionType
 from typing import Generator
 
 from pydantic import TypeAdapter
@@ -11,28 +12,29 @@ class AsyncEventLoopMixin:
 
     @property
     def loop(self) -> AbstractEventLoop:
-        if self._LOOP is None:
-            self._LOOP = get_running_loop()
+        if AsyncEventLoopMixin._LOOP is None:
+            AsyncEventLoopMixin._LOOP = get_running_loop()
 
-        return self._LOOP
+        return AsyncEventLoopMixin._LOOP
 
-    def init(self) -> None:
-        self._LOOP = get_running_loop()
+    @staticmethod
+    def reset_running_loop() -> None:
+        AsyncEventLoopMixin._LOOP = get_running_loop()
 
 
 class TypeAdapterCache:
-    _cache: dict[type, TypeAdapter] = {}
+    _CACHE: dict[type | UnionType, TypeAdapter] = {}
 
     @classmethod
-    def cache_annotation(cls, annotation: type) -> None:
-        if annotation not in cls._cache:
-            cls._cache[annotation] = TypeAdapter(annotation)
+    def cache_annotation(cls, annotation: type | UnionType) -> None:
+        if annotation not in cls._CACHE:
+            cls._CACHE[annotation] = TypeAdapter(annotation)
 
     @classmethod
-    def get_type_adapter(cls, annotation: type) -> TypeAdapter:
+    def get_type_adapter(cls, annotation: type | UnionType) -> TypeAdapter:
         cls.cache_annotation(annotation)
 
-        return cls._cache[annotation]
+        return cls._CACHE[annotation]
 
 
 class YieldOnce: