nlbone 0.7.20__tar.gz → 0.7.22__tar.gz

{nlbone-0.7.20 → nlbone-0.7.22}/PKG-INFO

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

{nlbone-0.7.20 → nlbone-0.7.22}/pyproject.toml

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

{nlbone-0.7.20 → nlbone-0.7.22}/src/nlbone/adapters/auth/token_provider.py

@@ -2,13 +2,13 @@ import threading
 import time
 from typing import Any, Dict, Optional
 
-from nlbone.adapters.auth.keycloak import KeycloakAuthService
+from nlbone.core.ports.auth import AuthService as BaseAuthService
 
 
 class ClientTokenProvider:
     """Caches Keycloak client-credentials token and refreshes before expiry."""
 
-    def __init__(self, auth: KeycloakAuthService, *, skew_seconds: int = 30) -> None:
+    def __init__(self, auth: BaseAuthService, *, skew_seconds: int = 30) -> None:
         self._auth = auth
         self._skew = skew_seconds
         self._lock = threading.Lock()

{nlbone-0.7.20 → nlbone-0.7.22}/src/nlbone/interfaces/api/exceptions.py

@@ -86,3 +86,11 @@ class UnprocessableEntityException(BaseHttpException):
 class LogicalValidationException(UnprocessableEntityException):
     def __init__(self, detail: str, loc: Iterable[Any] | None = None, type_: str = "logical_error"):
         super().__init__(detail=detail, loc=loc, type_=type_)
+
+
+class GoneException(BaseHttpException):
+    def __init__(self, detail: str = "Gone"):
+        super().__init__(
+            status_code=status.HTTP_410_GONE,
+            detail=detail,
+        )

{nlbone-0.7.20 → nlbone-0.7.22}/src/nlbone/interfaces/api/schema/base_response_model.py

@@ -1,9 +1,15 @@
+from typing import Any
 from pydantic import BaseModel, ConfigDict, model_serializer
 
 from nlbone.core.domain.base import BaseId
 
 EXCLUDE_NONE = "exclude_none"
 
+def convert_decimal_to_string(v: Any) -> Any:
+    """Converts a value to string if it's a large integer (over the safe limit)."""
+    if isinstance(v, int) and v > 9007199254740991:
+        return str(v)
+    return v
 
 class BaseResponseModel(BaseModel):
     model_config = ConfigDict(
@@ -11,6 +17,7 @@ class BaseResponseModel(BaseModel):
         arbitrary_types_allowed=True,
         json_encoders={
             BaseId: lambda v: str(v.value),
+            int: convert_decimal_to_string,
         },
     )
 

{nlbone-0.7.20 → nlbone-0.7.22}/src/nlbone/utils/cache.py

@@ -1,10 +1,10 @@
 import asyncio
+import hashlib
 import inspect
 import json
-from typing import Any, Callable, Iterable, Optional, Mapping
-import hashlib
-from makefun import wraps as mf_wraps
+from typing import Any, Callable, Iterable, Optional
 
+from makefun import wraps as mf_wraps
 
 from nlbone.utils.cache_registry import get_cache
 
@@ -61,10 +61,10 @@ def to_jsonable(obj):
 
 
 def _key_from_template(
-        tpl: Optional[str],
-        func: Callable,
-        args,
-        kwargs,
+    tpl: Optional[str],
+    func: Callable,
+    args,
+    kwargs,
 ) -> str:
     """Format key template with bound arguments or build a stable default."""
     bound = _bind(func, args, kwargs)
@@ -84,10 +84,10 @@ def _key_from_template(
 
 
 def _format_tags(
-        tag_tpls: Optional[Iterable[str]],
-        func: Callable,
-        args,
-        kwargs,
+    tag_tpls: Optional[Iterable[str]],
+    func: Callable,
+    args,
+    kwargs,
 ) -> list[str] | None:
     if not tag_tpls:
         return None
@@ -126,21 +126,14 @@ def _run_maybe_async(func: Callable, *args, **kwargs):
 
 
 def cached(
-        *,
-        ttl: int,
-        key: str | None = None,
-        tags: Iterable[str] | None = None,
-        serializer: Callable[[Any], bytes] = default_serialize,
-        deserializer: Callable[[bytes], Any] = default_deserialize,
-        cache_resolver: Optional[Callable[[], Any]] = None,
+    *,
+    ttl: int,
+    key: str | None = None,
+    tags: Iterable[str] | None = None,
+    serializer: Callable[[Any], bytes] = default_serialize,
+    deserializer: Callable[[bytes], Any] = default_deserialize,
+    cache_resolver: Optional[Callable[[], Any]] = None,
 ):
-    """
-    Framework-agnostic caching for SYNC or ASYNC callables.
-    - Preserves function signature (good for FastAPI/OpenAPI).
-    - Works with sync/async cache backends (CachePort / AsyncCachePort).
-    - `key` & `tags` are string templates, e.g. "file:{file_id}".
-    """
-
     def deco(func: Callable):
         is_async_func = asyncio.iscoroutinefunction(func)
 
@@ -154,24 +147,31 @@ def cached(
                 k = _key_from_template(key, func, args, kwargs)
                 tg = _format_tags(tags, func, args, kwargs)
 
-                # GET
-                if _is_async_method(cache, "get"):
-                    cached_bytes = await cache.get(k)
-                else:
-                    cached_bytes = cache.get(k)
+                # SAFE GET
+                cached_bytes = None
+                try:
+                    if _is_async_method(cache, "get"):
+                        cached_bytes = await cache.get(k)
+                    else:
+                        cached_bytes = cache.get(k)
+                except Exception:
+                    pass
 
                 if cached_bytes is not None:
                     return deserializer(cached_bytes)
 
-                # MISS -> compute
+                # MISS → compute
                 result = await func(*args, **kwargs)
 
-                # SET
+                # SAFE SET
                 data = serializer(result)
-                if _is_async_method(cache, "set"):
-                    await cache.set(k, data, ttl=ttl, tags=tg)
-                else:
-                    cache.set(k, data, ttl=ttl, tags=tg)
+                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)
+                except Exception:
+                    pass
 
                 return result
 
@@ -183,27 +183,35 @@ def cached(
             cache = (cache_resolver or get_cache)()
             if not cache:
                 return func(*args, **kwargs)
+
             k = _key_from_template(key, func, args, kwargs)
             tg = _format_tags(tags, func, args, kwargs)
 
-            # GET (may be async)
-            if _is_async_method(cache, "get"):
-                cached_bytes = _run_maybe_async(cache.get, k)
-            else:
-                cached_bytes = cache.get(k)
+            # 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)
+            except Exception:
+                pass
 
             if cached_bytes is not None:
                 return deserializer(cached_bytes)
 
-            # MISS -> compute
+            # MISS → compute
             result = func(*args, **kwargs)
 
-            # SET (may be async)
+            # SAFE SET (maybe async)
             data = serializer(result)
-            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)
+            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)
+            except Exception:
+                pass
 
             return result