nlbone 0.9.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

nlbone/adapters/cache/async_redis.py

@@ -1,10 +1,16 @@
-import asyncio
+from __future__ import annotations
+
+import inspect
 import json
 import os
-from typing import Any, Iterable, Mapping, Optional, Sequence
+from typing import Any, Awaitable, Callable, Iterable, Mapping, Optional, Sequence, Union
 
-from redis.asyncio import Redis
+from redis.asyncio import ConnectionPool, Redis
+from redis.asyncio.retry import Retry
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import LockError, RedisError
 
+from nlbone.config.settings import get_settings
 from nlbone.core.ports.cache import AsyncCachePort
 
 
@@ -17,23 +23,41 @@ def _tag_key(tag: str) -> str:
 
 
 class AsyncRedisCache(AsyncCachePort):
-    def __init__(self, url: str, *, invalidate_channel: str | None = None):
-        self._r = Redis.from_url(url, decode_responses=False)
+    def __init__(self, url: str, *, invalidate_channel: Optional[str] = None):
+        self._pool = ConnectionPool.from_url(
+            url,
+            decode_responses=False,
+            max_connections=get_settings().REDIS_MAX_CONNECTIONS,
+            socket_timeout=get_settings().REDIS_TIMEOUT,
+            socket_connect_timeout=get_settings().REDIS_TIMEOUT,
+            health_check_interval=get_settings().REDIS_CHECK_INTERVAL,
+            retry_on_timeout=True,
+            retry=Retry(ExponentialBackoff(), 3),
+        )
+        self._r = Redis(connection_pool=self._pool)
         self._ch = invalidate_channel or os.getenv("NLBONE_REDIS_INVALIDATE_CHANNEL", "cache:invalidate")
 
     @property
     def redis(self) -> Redis:
         return self._r
 
+    async def close(self):
+        await self._r.close()
+        await self._pool.disconnect()
+
     async def _current_ver(self, ns: str) -> int:
-        v = await self._r.get(_nsver_key(ns))
-        return int(v) if v else 1
+        try:
+            v = await self._r.get(_nsver_key(ns))
+            return int(v) if v else 1
+        except (ValueError, TypeError):
+            return 1
 
     async def _full_key(self, key: str) -> str:
         try:
             ns, rest = key.split(":", 1)
         except ValueError:
             ns, rest = "app", key
+
         ver = await self._current_ver(ns)
         return f"{ns}:{ver}:{rest}"
 
@@ -46,14 +70,17 @@ class AsyncRedisCache(AsyncCachePort):
         self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
     ) -> None:
         fk = await self._full_key(key)
-        if ttl is None:
-            await self._r.set(fk, value)
-        else:
-            await self._r.setex(fk, ttl, value)
-        if tags:
-            pipe = self._r.pipeline()
-            for t in tags:
-                pipe.sadd(_tag_key(t), fk)
+
+        async with self._r.pipeline() as pipe:
+            if ttl is None:
+                await pipe.set(fk, value)
+            else:
+                await pipe.setex(fk, ttl, value)
+
+            if tags:
+                for t in tags:
+                    await pipe.sadd(_tag_key(t), fk)
+
             await pipe.execute()
 
     async def delete(self, key: str) -> None:
@@ -61,83 +88,87 @@ class AsyncRedisCache(AsyncCachePort):
         await self._r.delete(fk)
 
     async def exists(self, key: str) -> bool:
-        return (await self.get(key)) is not None
+        fk = await self._full_key(key)
+        return bool(await self._r.exists(fk))
 
     async def ttl(self, key: str) -> Optional[int]:
         fk = await self._full_key(key)
         t = await self._r.ttl(fk)
-        return None if t < 0 else int(t)
+        return int(t) if t >= 0 else None
 
-        # -------- multi --------
+    # -------- multi --------
 
     async def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
+        if not keys:
+            return []
+        # Alternatively, await asyncio.gather(*[self._full_key(k) for k in keys])
         fks = [await self._full_key(k) for k in keys]
         return await self._r.mget(fks)
 
     async def mset(
         self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
     ) -> None:
-        pipe = self._r.pipeline()
-        if ttl is None:
-            for k, v in items.items():
-                fk = await self._full_key(k)
-                pipe.set(fk, v)
-        else:
+        if not items:
+            return
+
+        async with self._r.pipeline() as pipe:
             for k, v in items.items():
                 fk = await self._full_key(k)
-                pipe.setex(fk, ttl, v)
-        await pipe.execute()
+                if ttl is None:
+                    await pipe.set(fk, v)
+                else:
+                    await pipe.setex(fk, ttl, v)
+
+                if tags:
+                    for t in tags:
+                        await pipe.sadd(_tag_key(t), fk)
 
-        if tags:
-            pipe = self._r.pipeline()
-            for t in tags:
-                for k in items.keys():
-                    fk = await self._full_key(k)
-                    pipe.sadd(_tag_key(t), fk)
             await pipe.execute()
 
-        # -------- json --------
+    # -------- json --------
 
     async def get_json(self, key: str) -> Optional[Any]:
         b = await self.get(key)
-        return None if b is None else json.loads(b)
+        if b is None:
+            return None
+        try:
+            return json.loads(b)
+        except json.JSONDecodeError:
+            return None
 
     async def set_json(
         self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
     ) -> None:
-        await self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
+        payload = json.dumps(value).encode("utf-8")
+        await self.set(key, payload, ttl=ttl, tags=tags)
 
-        # -------- invalidation --------
+    # -------- invalidation --------
 
     async def invalidate_tags(self, tags: Iterable[str]) -> int:
         removed = 0
-        pipe = self._r.pipeline()
-        key_sets: list[tuple[str, set[bytes]]] = []
-        for t in tags:
-            tk = _tag_key(t)
-            members = await self._r.smembers(tk)
-            if members:
-                pipe.delete(*members)
-            pipe.delete(tk)
-            key_sets.append((tk, members))
-            removed += len(members or [])
-        await pipe.execute()
-
-        # publish notification for other processes
+        async with self._r.pipeline() as pipe:
+            for t in tags:
+                tk = _tag_key(t)
+                members = await self._r.smembers(tk)
+                if members:
+                    await pipe.delete(*members)
+                await pipe.delete(tk)
+                removed += len(members or [])
+            await pipe.execute()
+
         try:
             payload = json.dumps({"tags": list(tags)}).encode("utf-8")
             await self._r.publish(self._ch, payload)
-        except Exception:
+        except RedisError:
             pass
 
         return removed
 
     async def bump_namespace(self, namespace: str) -> int:
         v = await self._r.incr(_nsver_key(namespace))
-        # اطلاع‌رسانی اختیاری
         try:
             await self._r.publish(self._ch, json.dumps({"ns_bump": namespace}).encode("utf-8"))
-        except Exception:
+        except RedisError:
             pass
         return int(v)
 
@@ -145,6 +176,7 @@ class AsyncRedisCache(AsyncCachePort):
         cnt = 0
         cursor = 0
         pattern = f"{namespace}:*"
+
         while True:
             cursor, keys = await self._r.scan(cursor=cursor, match=pattern, count=1000)
             if keys:
@@ -152,39 +184,57 @@ class AsyncRedisCache(AsyncCachePort):
                 cnt += len(keys)
             if cursor == 0:
                 break
+
         try:
             await self._r.publish(self._ch, json.dumps({"ns_clear": namespace}).encode("utf-8"))
-        except Exception:
+        except RedisError:
             pass
+
         return cnt
 
-        # -------- dogpile-safe get_or_set --------
+    # -------- dogpile-safe get_or_set --------
 
-    async def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:
+    async def get_or_set(
+        self,
+        key: str,
+        producer: Callable[[], Union[bytes, str, Awaitable[Union[bytes, str]]]],
+        *,
+        ttl: int,
+        tags: Optional[Iterable[str]] = None,
+    ) -> bytes:
         fk = await self._full_key(key)
+
         val = await self._r.get(fk)
         if val is not None:
             return val
 
-        lock_key = f"lock:{fk}"
-        got = await self._r.set(lock_key, b"1", ex=10, nx=True)
-        if got:
-            try:
-                produced = await producer() if asyncio.iscoroutinefunction(producer) else producer()
+        lock_name = f"lock:{fk}"
+
+        try:
+            async with self._r.lock(lock_name, timeout=10, blocking_timeout=5):
+                val = await self._r.get(fk)
+                if val is not None:
+                    return val
+
+                if inspect.iscoroutinefunction(producer):
+                    produced = await producer()
+                else:
+                    produced = producer()
+
                 if isinstance(produced, str):
                     produced = produced.encode("utf-8")
+
                 await self.set(key, produced, ttl=ttl, tags=tags)
                 return produced
-            finally:
-                await self._r.delete(lock_key)
-
-        await asyncio.sleep(0.05)
-        val2 = await self._r.get(fk)
-        if val2 is not None:
-            return val2
-        # fallback
-        produced = await producer() if asyncio.iscoroutinefunction(producer) else producer()
-        if isinstance(produced, str):
-            produced = produced.encode("utf-8")
-        await self.set(key, produced, ttl=ttl, tags=tags)
-        return produced
+
+        except LockError:
+            if inspect.iscoroutinefunction(producer):
+                produced = await producer()
+            else:
+                produced = producer()
+
+            if isinstance(produced, str):
+                produced = produced.encode("utf-8")
+
+            await self.set(key, produced, ttl=ttl, tags=tags)
+            return produced

nlbone/adapters/cache/redis.py

@@ -2,11 +2,15 @@ from __future__ import annotations
 
 import json
 import os
-import time
 from typing import Any, Iterable, Mapping, Optional, Sequence
 
-import redis  # redis-py (sync)
+import redis
+from redis import RedisError
+from redis.backoff import ExponentialBackoff
+from redis.exceptions import LockError
+from redis.retry import Retry
 
+from nlbone.config.settings import get_settings
 from nlbone.core.ports.cache import CachePort
 
 
@@ -20,17 +24,32 @@ def _tag_key(tag: str) -> str:
 
 class RedisCache(CachePort):
     def __init__(self, url: str):
-        self.r = redis.Redis.from_url(url, decode_responses=False)
+        self._pool = redis.ConnectionPool.from_url(
+            url,
+            decode_responses=False,
+            max_connections=get_settings().REDIS_MAX_CONNECTIONS,
+            socket_timeout=get_settings().REDIS_TIMEOUT,
+            socket_connect_timeout=get_settings().REDIS_TIMEOUT,
+            health_check_interval=get_settings().REDIS_CHECK_INTERVAL,
+            retry_on_timeout=True,
+            retry=Retry(ExponentialBackoff(), 3),
+        )
+
+        self.r = redis.Redis(connection_pool=self._pool)
 
     def _current_ver(self, ns: str) -> int:
-        v = self.r.get(_nsver_key(ns))
-        return int(v) if v else 1
+        try:
+            v = self.r.get(_nsver_key(ns))
+            return int(v) if v else 1
+        except (ValueError, TypeError):
+            return 1
 
     def _full_key(self, key: str) -> str:
         try:
             ns, rest = key.split(":", 1)
         except ValueError:
             ns, rest = "app", key
+
         ver = self._current_ver(ns)
         return f"{ns}:{ver}:{rest}"
 
@@ -40,53 +59,67 @@ class RedisCache(CachePort):
 
     def set(self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
         fk = self._full_key(key)
+
+        pipe = self.r.pipeline()
+
         if ttl is None:
-            self.r.set(fk, value)
+            pipe.set(fk, value)
         else:
-            self.r.setex(fk, ttl, value)
+            pipe.setex(fk, ttl, value)
+
         if tags:
-            pipe = self.r.pipeline()
             for t in tags:
                 pipe.sadd(_tag_key(t), fk)
-            pipe.execute()
+
+        pipe.execute()
 
     def delete(self, key: str) -> None:
         fk = self._full_key(key)
         self.r.delete(fk)
 
     def exists(self, key: str) -> bool:
-        return bool(self.get(key))
+        return bool(self.r.exists(self._full_key(key)))
 
     def ttl(self, key: str) -> Optional[int]:
         fk = self._full_key(key)
         t = self.r.ttl(fk)
-        return None if t < 0 else int(t)
+        return int(t) if t >= 0 else None
 
     def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
+        if not keys:
+            return []
         fks = [self._full_key(k) for k in keys]
         return self.r.mget(fks)
 
     def mset(
         self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
     ) -> None:
+        if not items:
+            return
+
         pipe = self.r.pipeline()
-        if ttl is None:
-            for k, v in items.items():
-                pipe.set(self._full_key(k), v)
-        else:
-            for k, v in items.items():
-                pipe.setex(self._full_key(k), ttl, v)
+
+        for k, v in items.items():
+            fk = self._full_key(k)
+            if ttl is None:
+                pipe.set(fk, v)
+            else:
+                pipe.setex(fk, ttl, v)
+
+            if tags:
+                for t in tags:
+                    pipe.sadd(_tag_key(t), fk)
+
         pipe.execute()
-        if tags:
-            pipe = self.r.pipeline()
-            for t in tags:
-                for k in items.keys():
-                    pipe.sadd(_tag_key(t), self._full_key(k))
-            pipe.execute()
 
     def get_json(self, key: str) -> Optional[Any]:
         b = self.get(key)
-        return None if b is None else json.loads(b)
+        if b is None:
+            return None
+        try:
+            return json.loads(b)
+        except json.JSONDecodeError:
+            return None
 
     def set_json(
         self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
@@ -96,6 +129,7 @@ class RedisCache(CachePort):
     def invalidate_tags(self, tags: Iterable[str]) -> int:
         removed = 0
         pipe = self.r.pipeline()
+
         for t in tags:
             tk = _tag_key(t)
             keys = self.r.smembers(tk)
@@ -103,12 +137,15 @@ class RedisCache(CachePort):
                 pipe.delete(*keys)
             pipe.delete(tk)
             removed += len(keys or [])
+
         pipe.execute()
+
         try:
             ch = os.getenv("NLBONE_REDIS_INVALIDATE_CHANNEL", "cache:invalidate")
             self.r.publish(ch, json.dumps({"tags": list(tags)}).encode("utf-8"))
-        except Exception:
+        except RedisError:
             pass
+
         return removed
 
     def bump_namespace(self, namespace: str) -> int:
@@ -119,6 +156,7 @@ class RedisCache(CachePort):
         cnt = 0
         cursor = 0
         pattern = f"{namespace}:*"
+
         while True:
             cursor, keys = self.r.scan(cursor=cursor, match=pattern, count=1000)
             if keys:
@@ -128,24 +166,28 @@ class RedisCache(CachePort):
                 break
         return cnt
 
-    def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:
+    def get_or_set(self, key: str, producer, *, ttl: int, tags: Optional[Iterable[str]] = None) -> bytes:
         fk = self._full_key(key)
+
         val = self.r.get(fk)
         if val is not None:
             return val
-        lock_key = f"lock:{fk}"
-        got = self.r.set(lock_key, b"1", nx=True, ex=10)
-        if got:
-            try:
+
+        lock_name = f"lock:{fk}"
+        try:
+            with self.r.lock(lock_name, timeout=10, blocking_timeout=5):
+                val = self.r.get(fk)
+                if val is not None:
+                    return val
+
                 produced: bytes = producer()
                 self.set(key, produced, ttl=ttl, tags=tags)
                 return produced
-            finally:
-                self.r.delete(lock_key)
-        time.sleep(0.05)
-        val2 = self.r.get(fk)
-        if val2 is not None:
-            return val2
-        produced: bytes = producer()
-        self.set(key, produced, ttl=ttl, tags=tags)
-        return produced
+
+        except LockError:
+            try:
+                produced = producer()
+                self.set(key, produced, ttl=ttl, tags=tags)
+                return produced
+            except Exception:
+                raise

nlbone/adapters/db/postgres/engine.py

@@ -15,12 +15,16 @@ from nlbone.config.settings import get_settings
 
 _settings = get_settings()
 
-ASYNC_DSN: str = _settings.POSTGRES_DB_DSN
+_dsn = _settings.POSTGRES_DB_DSN
 
-if "+asyncpg" in ASYNC_DSN:
-    SYNC_DSN: str = ASYNC_DSN.replace("+asyncpg", "+psycopg")
+if "+asyncpg" in _dsn:
+    ASYNC_DSN = _dsn.replace("+asyncpg", "+psycopg")
+elif "+psycopg" not in _dsn:
+    ASYNC_DSN = _dsn.replace("postgresql://", "postgresql+psycopg://")
 else:
-    SYNC_DSN = ASYNC_DSN
+    ASYNC_DSN = _dsn
+
+SYNC_DSN = ASYNC_DSN
 
 _async_engine: Optional[AsyncEngine] = None
 _async_session_factory: Optional[async_sessionmaker[AsyncSession]] = None
@@ -38,14 +42,19 @@ def init_async_engine(echo: Optional[bool] = None) -> AsyncEngine:
         ASYNC_DSN,
         echo=_settings.DEBUG if echo is None else echo,
         pool_pre_ping=True,
-        pool_size=5,
-        max_overflow=10,
+        pool_size=_settings.POSTGRES_POOL_SIZE,
+        max_overflow=_settings.POSTGRES_MAX_OVERFLOW,
+        pool_recycle=_settings.POSTGRES_POOL_RECYCLE,
+        pool_timeout=_settings.POSTGRES_POOL_TIMEOUT,
     )
+
     _async_session_factory = async_sessionmaker(
         bind=_async_engine,
         expire_on_commit=False,
         autoflush=False,
+        class_=AsyncSession,
     )
+
     return _async_engine
 
 
@@ -54,6 +63,7 @@ async def async_session() -> AsyncGenerator[AsyncSession, Any]:
     if _async_session_factory is None:
         init_async_engine()
     assert _async_session_factory is not None
+
     session = _async_session_factory()
     try:
         yield session
@@ -64,12 +74,6 @@ async def async_session() -> AsyncGenerator[AsyncSession, Any]:
         await session.close()
 
 
-async def async_ping() -> None:
-    eng = init_async_engine()
-    async with eng.connect() as conn:
-        await conn.execute(text("SELECT 1"))
-
-
 def init_sync_engine(echo: Optional[bool] = None) -> Engine:
     global _sync_engine, _sync_session_factory
     if _sync_engine is not None:
@@ -80,11 +84,12 @@ def init_sync_engine(echo: Optional[bool] = None) -> Engine:
         echo=_settings.DEBUG if echo is None else echo,
         pool_pre_ping=True,
         pool_size=_settings.POSTGRES_POOL_SIZE,
-        max_overflow=_settings.POSTGRES_MAX_POOL_SIZE,
-        pool_timeout=30,
-        pool_recycle=1800,
+        max_overflow=_settings.POSTGRES_MAX_OVERFLOW,
+        pool_recycle=_settings.POSTGRES_POOL_RECYCLE,
+        pool_timeout=_settings.POSTGRES_POOL_TIMEOUT,
         future=True,
     )
+
     _sync_session_factory = sessionmaker(
         bind=_sync_engine,
         autocommit=False,
@@ -110,11 +115,17 @@ def sync_session() -> Generator[Session, None, None]:
         s.close()
 
 
+# --- Health Checks & Getters ---
+
+
+async def async_ping() -> None:
+    async with async_session() as session:
+        await session.execute(text("SELECT 1"))
+
+
 def sync_ping() -> None:
-    """Health check for sync."""
-    eng = init_sync_engine()
-    with eng.connect() as conn:
-        conn.execute(text("SELECT 1"))
+    with sync_session() as session:
+        session.execute(text("SELECT 1"))
 
 
 def get_async_session_factory() -> async_sessionmaker[AsyncSession]:

nlbone/adapters/db/redis/client.py

@@ -1,15 +1,16 @@
-import redis
+from redis import Redis
+from redis.asyncio import Redis as AsyncRedis
 
 from nlbone.config.settings import get_settings
 
 
 class RedisClient:
-    _client: redis.Redis | None = None
+    _client: Redis | None = None
 
     @classmethod
-    def get_client(cls) -> redis.Redis:
+    def get_client(cls) -> Redis:
         if cls._client is None:
-            cls._client = redis.from_url(get_settings().REDIS_URL, decode_responses=True)
+            cls._client = Redis.from_url(get_settings().REDIS_URL, decode_responses=True)
         return cls._client
 
     @classmethod
@@ -17,3 +18,19 @@ class RedisClient:
         if cls._client is not None:
             cls._client.close()
             cls._client = None
+
+
+class AsyncRedisClient:
+    _client: AsyncRedis | None = None
+
+    @classmethod
+    def get_client(cls) -> Redis:
+        if cls._client is None:
+            cls._client = AsyncRedis.from_url(get_settings().REDIS_URL, decode_responses=True)
+        return cls._client
+
+    @classmethod
+    async def close(cls):
+        if cls._client is not None:
+            await cls._client.close()
+            cls._client = None

nlbone/config/settings.py

@@ -70,24 +70,37 @@ class Settings(BaseSettings):
     # Database
     # ---------------------------
     POSTGRES_DB_DSN: str = Field(default="postgresql+asyncpg://user:pass@localhost:5432/nlbone")
+    POSTGRES_DB_ECHO: bool = Field(default=False)
     POSTGRES_POOL_SIZE: int = Field(default=5)
-    POSTGRES_MAX_POOL_SIZE: int = Field(default=10)
-    DB_ECHO: bool = Field(default=False)
-    DB_POOL_SIZE: int = Field(default=5)
-    DB_MAX_OVERFLOW: int = Field(default=10)
+    POSTGRES_MAX_OVERFLOW: int = Field(default=10)
+    POSTGRES_POOL_TIMEOUT: int = Field(default=30)
+    POSTGRES_POOL_RECYCLE: int = Field(default=1800)
 
     # ---------------------------
     # Messaging / Cache
     # ---------------------------
     REDIS_URL: str = Field(default="redis://localhost:6379/0")
+    REDIS_MAX_CONNECTIONS: int = Field(default=5)
+    REDIS_CHECK_INTERVAL: int = Field(default=30)
+    REDIS_TIMEOUT: float = Field(default=3.0)
+
     CACHE_BACKEND: Literal["memory", "redis"] = Field(default="memory")
     CACHE_DEFAULT_TTL_S: int = Field(default=300)
 
-    # --- Event bus / Outbox ---
+    # ---------------------------
+    # Event bus / Outbox
+    # ---------------------------
     EVENT_BUS_BACKEND: Literal["inmemory"] = Field(default="inmemory")
     OUTBOX_ENABLED: bool = Field(default=False)
     OUTBOX_POLL_INTERVAL_MS: int = Field(default=500)
 
+    # ---------------------------
+    # APM
+    # ---------------------------
+    APM_SERVER_URL: str = "https://apm.numberland.dev"
+    APM_SECRET_TOKEN: str = ""
+    APM_SAMPLE_RATE: float = Field(default=0.5)
+
     # ---------------------------
     # UPLOADCHI
     # ---------------------------

nlbone/interfaces/api/dependencies/async_auth.py

@@ -1,10 +1,10 @@
 import functools
 
 from nlbone.adapters.auth.auth_service import get_auth_service
-from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
+from nlbone.interfaces.api.exceptions import UnauthorizedException
 from nlbone.utils.context import current_request
 
-from .auth import client_has_access_func, client_or_user_has_access_func
+from .auth import client_has_access_func, client_or_user_has_access_func, user_has_access_func
 
 
 async def current_user_id() -> int:
@@ -47,18 +47,14 @@ def has_access(*, permissions=None):
     def decorator(func):
         @functools.wraps(func)
         async def wrapper(*args, **kwargs):
-            request = current_request()
-            if not await current_user_id():
-                raise UnauthorizedException()
-            if not get_auth_service().has_access(request.state.token, permissions=permissions):
-                raise ForbiddenException(f"Forbidden {permissions}")
-
+            user_has_access_func(permissions=permissions)
             return await func(*args, **kwargs)
 
         return wrapper
 
     return decorator
 
+
 def client_or_user_has_access(*, permissions=None, client_permissions=None):
     def decorator(func):
         @functools.wraps(func)
@@ -69,4 +65,3 @@ def client_or_user_has_access(*, permissions=None, client_permissions=None):
         return wrapper
 
     return decorator
-

nlbone/interfaces/api/dependencies/auth.py

@@ -1,8 +1,8 @@
 import functools
 
-from nlbone.core.domain.models import CurrentUserData
 from nlbone.adapters.auth.auth_service import get_auth_service
 from nlbone.config.settings import get_settings
+from nlbone.core.domain.models import CurrentUserData
 from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
 from nlbone.utils.context import current_request
 
@@ -66,7 +66,7 @@ def user_authenticated(func):
 
 def user_has_access_func(*, permissions=None):
     if bypass_authz():
-        return
+        return True
     request = current_request()
     if not current_user_id():
         raise UnauthorizedException()
@@ -89,7 +89,7 @@ def has_access(*, permissions=None):
 
 def client_or_user_has_access_func(permissions=None, client_permissions=None):
     if bypass_authz():
-        return
+        return True
     request = current_request()
     token = getattr(request.state, "token", None)
     if not token:

nlbone/interfaces/api/exception_handlers.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
-from typing import Any, Mapping, Optional, List
+from typing import Any, List, Mapping, Optional
 from uuid import uuid4
 
 from fastapi import FastAPI, Request
-from fastapi import HTTPException as FastAPIHTTPException
 from fastapi.exceptions import RequestValidationError
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel, ValidationError
 from starlette.exceptions import HTTPException as StarletteHTTPException
-from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR, HTTP_422_UNPROCESSABLE_ENTITY
+from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR
 
 from nlbone.adapters.i18n import translator as _
+
 from .exceptions import BaseHttpException, ErrorDetail, UnprocessableEntityException
 
 

nlbone/interfaces/api/middleware/authentication.py

@@ -3,9 +3,9 @@ from typing import Callable, Optional, Union
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
-from nlbone.core.domain.models import CurrentUserData
 from nlbone.adapters.auth.auth_service import AuthService
 from nlbone.config.settings import get_settings
+from nlbone.core.domain.models import CurrentUserData
 
 try:
     from dependency_injector import providers
@@ -54,8 +54,7 @@ def authenticate_admin_user(request, auth_service):
 
 def authenticate_user(request):
     token = (
-            request.cookies.get("access_token") or request.cookies.get("j_token") or request.headers.get(
-        "Authorization")
+        request.cookies.get("access_token") or request.cookies.get("j_token") or request.headers.get("Authorization")
     )
     if request.headers.get("Authorization"):
         scheme, token = request.headers.get("Authorization").split(" ", 1)

nlbone/utils/cache.py

@@ -111,14 +111,18 @@ def default_deserialize(b: bytes) -> Any:
 
 def _is_async_method(obj: Any, name: str) -> bool:
     meth = getattr(obj, name, None)
-    return asyncio.iscoroutinefunction(meth)
+    return inspect.iscoroutinefunction(meth)
 
 
 def _run_maybe_async(func: Callable, *args, **kwargs):
     """Call a function that may be async from sync context."""
     result = func(*args, **kwargs)
     if inspect.isawaitable(result):
-        return asyncio.run(result)
+        try:
+            return asyncio.run(result)
+        except RuntimeError:
+            result.close()
+            raise
     return result
 
 
@@ -135,7 +139,7 @@ def cached(
     cache_resolver: Optional[Callable[[], Any]] = None,
 ):
     def deco(func: Callable):
-        is_async_func = asyncio.iscoroutinefunction(func)
+        is_async_func = inspect.iscoroutinefunction(func)
 
         if is_async_func:
 
@@ -150,10 +154,11 @@ def cached(
                 # SAFE GET
                 cached_bytes = None
                 try:
-                    if _is_async_method(cache, "get"):
-                        cached_bytes = await cache.get(k)
+                    result = cache.get(k)
+                    if inspect.isawaitable(result):
+                        cached_bytes = await result
                     else:
-                        cached_bytes = cache.get(k)
+                        cached_bytes = result
                 except Exception:
                     pass
 
@@ -166,10 +171,9 @@ def cached(
                 # SAFE SET
                 data = serializer(result)
                 try:
-                    if _is_async_method(cache, "set"):
-                        await cache.set(k, data, ttl=ttl, tags=tg)
-                    else:
-                        cache.set(k, data, ttl=ttl, tags=tg)
+                    res = cache.set(k, data, ttl=ttl, tags=tg)
+                    if inspect.isawaitable(res):
+                        await res
                 except Exception:
                     pass
 
@@ -190,10 +194,7 @@ def cached(
             # SAFE GET (maybe async)
             cached_bytes = None
             try:
-                if _is_async_method(cache, "get"):
-                    cached_bytes = _run_maybe_async(cache.get, k)
-                else:
-                    cached_bytes = cache.get(k)
+                cached_bytes = _run_maybe_async(cache.get, k)
             except Exception:
                 pass
 
@@ -206,10 +207,7 @@ def cached(
             # SAFE SET (maybe async)
             data = serializer(result)
             try:
-                if _is_async_method(cache, "set"):
-                    _run_maybe_async(cache.set, k, data, ttl=ttl, tags=tg)
-                else:
-                    cache.set(k, data, ttl=ttl, tags=tg)
+                _run_maybe_async(cache.set, k, data, ttl=ttl, tags=tg)
             except Exception:
                 pass
 
@@ -227,7 +225,7 @@ def invalidate_by_tags(tags_builder: Callable[..., Iterable[str]]):
     """
 
     def deco(func: Callable):
-        is_async_func = asyncio.iscoroutinefunction(func)
+        is_async_func = inspect.iscoroutinefunction(func)
 
         if is_async_func:
 
@@ -236,10 +234,11 @@ def invalidate_by_tags(tags_builder: Callable[..., Iterable[str]]):
                 out = await func(*args, **kwargs)
                 cache = get_cache()
                 tags = list(tags_builder(*args, **kwargs))
-                if _is_async_method(cache, "invalidate_tags"):
-                    await cache.invalidate_tags(tags)
-                else:
-                    cache.invalidate_tags(tags)
+
+                res = cache.invalidate_tags(tags)
+                if inspect.isawaitable(res):
+                    await res
+
                 return out
 
             return aw
@@ -249,10 +248,9 @@ def invalidate_by_tags(tags_builder: Callable[..., Iterable[str]]):
             out = func(*args, **kwargs)
             cache = get_cache()
             tags = list(tags_builder(*args, **kwargs))
-            if _is_async_method(cache, "invalidate_tags"):
-                _run_maybe_async(cache.invalidate_tags, tags)
-            else:
-                cache.invalidate_tags(tags)
+
+            _run_maybe_async(cache.invalidate_tags, tags)
+
             return out
 
         return sw

{nlbone-0.9.0.dist-info → nlbone-0.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.9.0
+Version: 0.9.1
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT

{nlbone-0.9.0.dist-info → nlbone-0.9.1.dist-info}/RECORD

@@ -8,22 +8,22 @@ nlbone/adapters/auth/auth_service.py,sha256=l8SyskSyswas940i-hXEnJ-gboTpjsXURm_G
 nlbone/adapters/auth/keycloak.py,sha256=IhEriaFl5mjIGT6ZUCU9qROd678ARchvWgd4UJ6zH7s,4925
 nlbone/adapters/auth/token_provider.py,sha256=kzjFAaFY8SPnU0Tn6l-YVrhEOAiFV0QE3eit3D7u2VQ,1438
 nlbone/adapters/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/cache/async_redis.py,sha256=vvu5w4ANx0BVRHL95RAMGsD8CcaC-tSBMbCius2cuNc,6212
+nlbone/adapters/cache/async_redis.py,sha256=GRooGZvGdPih9XOSe_lnmV-jQFrg-vZRARdNmOWOkQw,7380
 nlbone/adapters/cache/memory.py,sha256=y8M4erHQXApiSMAqG6Qk4pxEb60hRdu1szPv6iqvO9c,3738
 nlbone/adapters/cache/pubsub_listener.py,sha256=3vfK4O4EzuQQhTsbZ_bweP06o99kDSyHJ5PrfUotUaE,1460
-nlbone/adapters/cache/redis.py,sha256=2Y1DYHBLCrbHTO6O7pw85u3qY6OnCIFTYJ-HBvBs0FM,4608
+nlbone/adapters/cache/redis.py,sha256=cVBEfT2bO7bF8lq_G50EcIDmXgLyRbeTCCxRl1tGFmA,5445
 nlbone/adapters/db/__init__.py,sha256=0CDSySEk4jJsqmwI0eNuaaLJOJDt8_iSiHBsFdC-L3s,212
 nlbone/adapters/db/postgres/__init__.py,sha256=tvCpHOdZbpQ57o7k-plq7L0e1uZe5_Frbh7I-LxW7zM,313
 nlbone/adapters/db/postgres/audit.py,sha256=IuWkPitr70UyQ6-GkAedckp8U-Z4cTgzFbdt_bQv1VQ,4800
 nlbone/adapters/db/postgres/base.py,sha256=I89PsEeR9ADEScG8D5pVSncPrPRBmf-KQQkjajl7Koo,132
-nlbone/adapters/db/postgres/engine.py,sha256=TJaCj6yiIUghCD4p1zAGfuJoz3BXkpLU_ZdzlL3lh8A,3507
+nlbone/adapters/db/postgres/engine.py,sha256=8bA5qbDN9kcbI2uFitxbD8bseRlI_wQRQQSgfRTH6l8,3812
 nlbone/adapters/db/postgres/query_builder.py,sha256=YSlrj7lEGI9RiJ__El5_4j7nCuFogg4pR0oVcBQ9h90,15836
 nlbone/adapters/db/postgres/repository.py,sha256=n01TAzdKd-UbOhirE6KMosuvRdJG2l1cszwVHjTM-Ks,10345
 nlbone/adapters/db/postgres/schema.py,sha256=NlE7Rr8uXypsw4oWkdZhZwcIBHQEPIpoHLxcUo98i6s,1039
 nlbone/adapters/db/postgres/types.py,sha256=0SVuIKokog6_ByrYUsYAoIypVM2-uKJhUTeDPtm0qhs,602
 nlbone/adapters/db/postgres/uow.py,sha256=I4RVeIbGEVhVGcuzhdEUJuX11RhEHTn0egrkCbcsz24,3852
 nlbone/adapters/db/redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/db/redis/client.py,sha256=5SUnwP2-GrueSFimUbiqDvrQsumvIE2aeozk8l-vOfQ,466
+nlbone/adapters/db/redis/client.py,sha256=cT9TCigE-ndB-ckcpuh8cTS1AOVKS3rWNG_WYxD0CAM,930
 nlbone/adapters/http_clients/__init__.py,sha256=w-Yr9CLuXMU71N0Ada5HbvP1DB53wqeP6B-i5rALlTo,150
 nlbone/adapters/http_clients/pricing/__init__.py,sha256=ElA9NFcAR9u4cqb_w3PPqKU3xGeyjNLQ8veJ0ql2iz0,81
 nlbone/adapters/http_clients/pricing/pricing_service.py,sha256=_15vyEwJD3S2DJG-yyKhKfiLDbcwZg5XdQFe0b3oadM,3441
@@ -47,7 +47,7 @@ nlbone/adapters/ticketing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJW
 nlbone/adapters/ticketing/client.py,sha256=J1-eT3qQDAJqrHcVpP1oqWNsRNnJ54dDdBeez-m9wyY,1291
 nlbone/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/config/logging.py,sha256=Ot6Ctf7EQZlW8YNB-uBdleqI6wixn5fH0Eo6QRgNkQk,4358
-nlbone/config/settings.py,sha256=yuMBUV1WsPwQrkIFq8sifnvCPUB54ux_i0rVfXxGCRk,4884
+nlbone/config/settings.py,sha256=4OLG9M9wB5H6slNcg61NuNEPoWQsjoA6RvesRYa1C7c,5330
 nlbone/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/base_worker.py,sha256=5brIToSd-vi6tw0ukhHnUZGZhOLq1SQ-NRRy-kp6D24,1193
@@ -70,7 +70,7 @@ nlbone/core/ports/translation.py,sha256=pnqbxhdRCR7eprm8UI8ZKKx7VDUPntvBtlytrnTG
 nlbone/core/ports/uow.py,sha256=VhqSc-Ryt9m-rlNMiXTzD3dPGz6mM_JxND8D0UJGRu4,962
 nlbone/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/interfaces/api/exception_handlers.py,sha256=2wJp0HZcsSNVsmjFXma3FQ994iga7m3zm9o1E4MIncw,5582
+nlbone/interfaces/api/exception_handlers.py,sha256=YpnYAwmmWaLLJs7YKLdspWuVjCkelpPnVBw5VQkTkco,5494
 nlbone/interfaces/api/exceptions.py,sha256=IggZxV9q6l4jqw-G7SWEmuyXnWgbNXJJT-rmnirRIK4,5057
 nlbone/interfaces/api/routers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/schemas.py,sha256=34Tz2EeXyf12rFL9iyYWaB2ftuaXUebQQQxSO9ouV94,133
@@ -81,15 +81,15 @@ nlbone/interfaces/api/additional_filed/resolver.py,sha256=jv1TIBBHN4LBIMwHGipcy4
 nlbone/interfaces/api/additional_filed/default_field_rules/__init__.py,sha256=LUSAOO3xRUt5ptlraIx7H-7dSkdr1D-WprmnqXRB16g,48
 nlbone/interfaces/api/additional_filed/default_field_rules/image_field_rules.py,sha256=ecKqPeXZ-YiF14RK9PmK7ln3PCzpCUc18S5zm5IF3fw,339
 nlbone/interfaces/api/dependencies/__init__.py,sha256=rnYRrFVZCfICQrp_PVFlzNg3BeC57yM08wn2DbOHCfk,359
-nlbone/interfaces/api/dependencies/async_auth.py,sha256=CSl87X76qNuUfvvmtDN6uPwFJNbdrKWUuW4U3CZ3e1E,2126
-nlbone/interfaces/api/dependencies/auth.py,sha256=tE9T5HeRPqtimVDB-lYX_5lBaVvERSILT9FP55P-9hk,3190
+nlbone/interfaces/api/dependencies/async_auth.py,sha256=TZlFzT-mnPz1WBL0wh3nOlBXDjY-7B0-b4wBT8O6pLM,1890
+nlbone/interfaces/api/dependencies/auth.py,sha256=4WrjR3UgHI4S-HnBwdyLKEKBtofHkNuJ63Piayu9Dh4,3200
 nlbone/interfaces/api/dependencies/client_credential.py,sha256=Bo4dYx75Qw0JzTKD9ZfV5EXDEOuwndJk2D-V37K2ePg,1293
 nlbone/interfaces/api/dependencies/db.py,sha256=-UD39J_86UU7ZJs2ZncpdND0yhAG0NeeeALrgSDuuFw,466
 nlbone/interfaces/api/dependencies/uow.py,sha256=QfLEvLYLNWZJQN1k-0q0hBVtUld3D75P4j39q_RjcnE,1181
 nlbone/interfaces/api/middleware/__init__.py,sha256=zbX2vaEAfxRMIYwO2MVY_2O6bqG5H9o7HqGpX14U3Is,158
 nlbone/interfaces/api/middleware/access_log.py,sha256=vIkxxxfy2HcjqqKb8XCfGCcSrivAC8u6ie75FMq5x-U,1032
 nlbone/interfaces/api/middleware/add_request_context.py,sha256=o8mdo-D6fODM9OyHunE5UodkVxsh4F__5tDv8ju8Sxg,1952
-nlbone/interfaces/api/middleware/authentication.py,sha256=scXytNOtV7bg7iLtw19tdhmeIFQmY5qF6HCXAUbKGXg,3339
+nlbone/interfaces/api/middleware/authentication.py,sha256=dWxA9Aw8eFUqsufT2mHGk6mgehXKdAA9AAEIOk_jZWY,3326
 nlbone/interfaces/api/pagination/__init__.py,sha256=pA1uC4rK6eqDI5IkLVxmgO2B6lExnOm8Pje2-hifJZw,431
 nlbone/interfaces/api/pagination/offset_base.py,sha256=pdfNgmP99eFC5qCWyY1JgW8hNhOuEGnmrlvQPGArdj8,4709
 nlbone/interfaces/api/schema/__init__.py,sha256=LAqgynfupeqOQ6u0I5ucrcYnojRMZUg9yW8IjKSQTNI,119
@@ -104,7 +104,7 @@ nlbone/interfaces/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 nlbone/interfaces/jobs/dispatch_outbox.py,sha256=yLZSC3nvkgxT2LL4Pq_DYzCyf_tZB-FknrjjgN89GFg,809
 nlbone/interfaces/jobs/sync_tokens.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/utils/cache.py,sha256=KHUYjhIo6dbaSdY9RjbxUJQlLMdacMLjdDm5QZ5dLUw,7305
+nlbone/utils/cache.py,sha256=DkOSwKXG6nShaUq5_MfZIxFWXem_CIZpbgO4CJEaRrE,6918
 nlbone/utils/cache_keys.py,sha256=Y2YSellHTbUOcoaNbl1jaD4r485VU_e4KXsfBWhYTBo,1075
 nlbone/utils/cache_registry.py,sha256=3FWYyhujW8oPBiVUPzk1CqJ3jJfxs9729Sbb1pQ5Fag,707
 nlbone/utils/context.py,sha256=Wq3QLYsMzo_xUiVAHLgEPQUG6LhgJTmFn8MO5Qa7S8w,1837
@@ -116,8 +116,8 @@ nlbone/utils/normalize_mobile.py,sha256=sGH4tV9gX-6eVKozviNWJhm1DN1J28Nj-ERldCYk
 nlbone/utils/read_files.py,sha256=mx8dfvtaaARQFRp_U7OOiERg-GT62h09_lpTzIQsVhs,291
 nlbone/utils/redactor.py,sha256=-V4HrHmHwPi3Kez587Ek1uJlgK35qGSrwBOvcbw8Jas,1279
 nlbone/utils/time.py,sha256=DjjyQ9GLsfXoT6NK8RDW2rOlJg3e6sF04Jw6PBUrSvg,1268
-nlbone-0.9.0.dist-info/METADATA,sha256=2GgKIXQKJN0w0vK9mjf5aPvQ3bjuC-Db0VLUY_Jwmh8,2294
-nlbone-0.9.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-nlbone-0.9.0.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
-nlbone-0.9.0.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.9.0.dist-info/RECORD,,
+nlbone-0.9.1.dist-info/METADATA,sha256=zXLVlrhKwEg_MAP8KqHT1DGOF21PHj5f4YOVM6cUPZo,2294
+nlbone-0.9.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+nlbone-0.9.1.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
+nlbone-0.9.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.9.1.dist-info/RECORD,,