nlbone 0.9.0__tar.gz → 0.9.1__tar.gz

{nlbone-0.9.0 → nlbone-0.9.1}/PKG-INFO

@@ -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 → nlbone-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.9.0"
+version = "0.9.1"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"

nlbone-0.9.1/src/nlbone/adapters/cache/async_redis.py

@@ -0,0 +1,240 @@
+from __future__ import annotations
+
+import inspect
+import json
+import os
+from typing import Any, Awaitable, Callable, Iterable, Mapping, Optional, Sequence, Union
+
+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
+
+
+def _nsver_key(ns: str) -> str:
+    return f"nsver:{ns}"
+
+
+def _tag_key(tag: str) -> str:
+    return f"tag:{tag}"
+
+
+class AsyncRedisCache(AsyncCachePort):
+    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:
+        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}"
+
+    # -------- basic --------
+    async def get(self, key: str) -> Optional[bytes]:
+        fk = await self._full_key(key)
+        return await self._r.get(fk)
+
+    async def set(
+        self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
+        fk = await self._full_key(key)
+
+        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:
+        fk = await self._full_key(key)
+        await self._r.delete(fk)
+
+    async def exists(self, key: str) -> bool:
+        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 int(t) if t >= 0 else None
+
+    # -------- 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:
+        if not items:
+            return
+
+        async with self._r.pipeline() as pipe:
+            for k, v in items.items():
+                fk = await self._full_key(k)
+                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)
+
+            await pipe.execute()
+
+    # -------- json --------
+
+    async def get_json(self, key: str) -> Optional[Any]:
+        b = await self.get(key)
+        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:
+        payload = json.dumps(value).encode("utf-8")
+        await self.set(key, payload, ttl=ttl, tags=tags)
+
+    # -------- invalidation --------
+
+    async def invalidate_tags(self, tags: Iterable[str]) -> int:
+        removed = 0
+        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 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 RedisError:
+            pass
+        return int(v)
+
+    async def clear_namespace(self, namespace: str) -> int:
+        cnt = 0
+        cursor = 0
+        pattern = f"{namespace}:*"
+
+        while True:
+            cursor, keys = await self._r.scan(cursor=cursor, match=pattern, count=1000)
+            if keys:
+                await self._r.delete(*keys)
+                cnt += len(keys)
+            if cursor == 0:
+                break
+
+        try:
+            await self._r.publish(self._ch, json.dumps({"ns_clear": namespace}).encode("utf-8"))
+        except RedisError:
+            pass
+
+        return cnt
+
+    # -------- dogpile-safe get_or_set --------
+
+    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_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
+
+        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-0.9.0 → nlbone-0.9.1}/src/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-0.9.0 → nlbone-0.9.1}/src/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-0.9.1/src/nlbone/adapters/db/redis/client.py

@@ -0,0 +1,36 @@
+from redis import Redis
+from redis.asyncio import Redis as AsyncRedis
+
+from nlbone.config.settings import get_settings
+
+
+class RedisClient:
+    _client: Redis | None = None
+
+    @classmethod
+    def get_client(cls) -> Redis:
+        if cls._client is None:
+            cls._client = Redis.from_url(get_settings().REDIS_URL, decode_responses=True)
+        return cls._client
+
+    @classmethod
+    def close(cls):
+        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-0.9.0 → nlbone-0.9.1}/src/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-0.9.0 → nlbone-0.9.1}/src/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
-