nlbone 0.5.0__py3-none-any.whl → 0.6.8__py3-none-any.whl

nlbone/adapters/__init__.py

@@ -0,0 +1 @@
+import nlbone.adapters.db.postgres.audit

nlbone/adapters/auth/keycloak.py

@@ -75,4 +75,4 @@ class KeycloakAuthService(AuthService):
     def client_has_access(self, token: str, permissions: list[str], allowed_clients: set[str] | None = None) -> bool:
         if not self.is_client_token(token, allowed_clients):
             return False
-        return self.has_access(token, permissions)
+        return self.has_access(token, permissions)

nlbone/adapters/auth/token_provider.py

@@ -1,6 +1,6 @@
 import threading
 import time
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 from nlbone.adapters.auth.keycloak import KeycloakAuthService
 

nlbone/adapters/cache/async_redis.py

@@ -1,14 +1,20 @@
 import asyncio
 import json
 import os
-from typing import Optional, Iterable, Any, Mapping, Sequence, List
+from typing import Any, Iterable, Mapping, Optional, Sequence
 
 from redis.asyncio import Redis
+
 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}"
+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: str | None = None):
@@ -36,7 +42,9 @@ class AsyncRedisCache(AsyncCachePort):
         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:
+    async def set(
+        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)
@@ -66,8 +74,9 @@ class AsyncRedisCache(AsyncCachePort):
         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:
+    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():
@@ -93,8 +102,9 @@ class AsyncRedisCache(AsyncCachePort):
         b = await self.get(key)
         return None if b is None else json.loads(b)
 
-    async def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None,
-                       tags: Optional[Iterable[str]] = None) -> 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)
 
         # -------- invalidation --------

nlbone/adapters/cache/memory.py

@@ -1,5 +1,8 @@
-import json, threading, time
-from typing import Optional, Iterable, Any, Mapping, Sequence, Dict, Set
+import json
+import threading
+import time
+from typing import Any, Dict, Iterable, Mapping, Optional, Sequence, Set
+
 from nlbone.core.ports.cache import CachePort
 
 
@@ -12,7 +15,8 @@ class InMemoryCache(CachePort):
 
     def _expired(self, key: str) -> bool:
         v = self._data.get(key)
-        if not v: return True
+        if not v:
+            return True
         _, exp = v
         return exp is not None and time.time() > exp
 
@@ -21,7 +25,8 @@ class InMemoryCache(CachePort):
             self._data.pop(key, None)
 
     def _attach_tags(self, key: str, tags: Optional[Iterable[str]]) -> None:
-        if not tags: return
+        if not tags:
+            return
         for t in tags:
             self._tags.setdefault(t, set()).add(key)
 
@@ -50,17 +55,20 @@ class InMemoryCache(CachePort):
         with self._lock:
             self._gc(key)
             v = self._data.get(key)
-            if not v: return None
+            if not v:
+                return None
             _, exp = v
-            if exp is None: return None
+            if exp is None:
+                return None
             rem = int(exp - time.time())
             return rem if rem >= 0 else 0
 
     def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
         return [self.get(k) for k in keys]
 
-    def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None,
-             tags: Optional[Iterable[str]] = None) -> None:
+    def mset(
+        self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         for k, v in items.items():
             self.set(k, v, ttl=ttl, tags=tags)
 
@@ -68,8 +76,9 @@ class InMemoryCache(CachePort):
         b = self.get(key)
         return None if b is None else json.loads(b)
 
-    def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None,
-                 tags: Optional[Iterable[str]] = None) -> None:
+    def set_json(
+        self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
 
     def invalidate_tags(self, tags: Iterable[str]) -> int:
@@ -91,7 +100,8 @@ class InMemoryCache(CachePort):
     def clear_namespace(self, namespace: str) -> int:
         with self._lock:
             keys = [k for k in self._data.keys() if k.startswith(namespace + ":")]
-            for k in keys: self.delete(k)
+            for k in keys:
+                self.delete(k)
             return len(keys)
 
     def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:

nlbone/adapters/cache/pubsub_listener.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
+
 import asyncio
 import json
 from typing import Awaitable, Callable, Optional
+
 from redis.asyncio import Redis
 
+
 async def run_cache_invalidation_listener(
     redis: Redis,
     channel: str = "cache:invalidate",

nlbone/adapters/cache/redis.py

@@ -1,13 +1,22 @@
 from __future__ import annotations
-import json, os, time
-from typing import Optional, Iterable, Any, Mapping, Sequence, List, Set
+
+import json
+import os
+import time
+from typing import Any, Iterable, Mapping, Optional, Sequence
+
 import redis  # redis-py (sync)
+
 from nlbone.core.ports.cache import CachePort
 
 
+def _nsver_key(ns: str) -> str:
+    return f"nsver:{ns}"
+
+
+def _tag_key(tag: str) -> str:
+    return f"tag:{tag}"
 
-def _nsver_key(ns: str) -> str: return f"nsver:{ns}"
-def _tag_key(tag: str) -> str: return f"tag:{tag}"
 
 class RedisCache(CachePort):
     def __init__(self, url: str):
@@ -57,7 +66,9 @@ class RedisCache(CachePort):
         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:
+    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():
@@ -77,7 +88,9 @@ class RedisCache(CachePort):
         b = self.get(key)
         return None if b is None else json.loads(b)
 
-    def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+    def set_json(
+        self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
 
     def invalidate_tags(self, tags: Iterable[str]) -> int:
@@ -109,8 +122,10 @@ class RedisCache(CachePort):
         while True:
             cursor, keys = self.r.scan(cursor=cursor, match=pattern, count=1000)
             if keys:
-                self.r.delete(*keys); cnt += len(keys)
-            if cursor == 0: break
+                self.r.delete(*keys)
+                cnt += len(keys)
+            if cursor == 0:
+                break
         return cnt
 
     def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:

nlbone/adapters/db/__init__.py

@@ -1,4 +1,3 @@
 from .postgres import apply_pagination, get_paginated_response
 from .postgres.base import Base
 from .postgres.engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session
-import nlbone.adapters.db.postgres.audit

nlbone/adapters/db/postgres/audit.py

@@ -1,10 +1,12 @@
 import uuid
 from datetime import date, datetime
+from decimal import Decimal
+from enum import Enum as _Enum
 from typing import Any
-from sqlalchemy import event, inspect as sa_inspect
+
+from sqlalchemy import event
+from sqlalchemy import inspect as sa_inspect
 from sqlalchemy.orm import Session as SASession
-from enum import Enum as _Enum
-from decimal import Decimal
 
 from nlbone.core.domain.models import AuditLog
 from nlbone.utils.context import current_context_dict
@@ -54,8 +56,11 @@ def _ser(val):
 
 
 def _entity_name(obj: Any) -> str:
-    return getattr(getattr(obj, "__table__", None), "name", None) or getattr(obj, "__tablename__",
-                                                                             None) or obj.__class__.__name__
+    return (
+        getattr(getattr(obj, "__table__", None), "name", None)
+        or getattr(obj, "__tablename__", None)
+        or obj.__class__.__name__
+    )
 
 
 def _entity_id(obj: Any) -> str:
@@ -84,13 +89,15 @@ def _changes_for_update(obj: any) -> dict[str, dict[str, any]]:
         except KeyError:
             continue
 
-        hist = state.history                 # History object
+        hist = state.history  # History object
         if hist.has_changes():
             old = hist.deleted[0] if hist.deleted else None
             new = hist.added[0] if hist.added else None
             if old != new:
                 changes[key] = {"old": _ser(old), "new": _ser(new)}
     return changes
+
+
 @event.listens_for(SASession, "before_flush")
 def before_flush(session: SASession, flush_context, instances):
     entries = session.info.setdefault("_audit_entries", [])
@@ -107,11 +114,7 @@ def before_flush(session: SASession, flush_context, instances):
             if key in exclude:
                 continue
             row[key] = _ser(getattr(obj, key, None))
-        entries.append({
-            "obj": obj,
-            "op": "INSERT",
-            "changes": {k: {"old": None, "new": v} for k, v in row.items()}
-        })
+        entries.append({"obj": obj, "op": "INSERT", "changes": {k: {"old": None, "new": v} for k, v in row.items()}})
 
     # UPDATE
     for obj in session.dirty:

nlbone/adapters/db/redis/client.py

@@ -9,10 +9,7 @@ class RedisClient:
     @classmethod
     def get_client(cls) -> redis.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

nlbone/adapters/http_clients/__init__.py

@@ -0,0 +1,2 @@
+from .pricing import CalculatePriceIn, CalculatePriceOut, PricingService
+from .uploadchi import UploadchiAsyncClient, UploadchiClient, UploadchiError

nlbone/adapters/http_clients/pricing/__init__.py

@@ -0,0 +1 @@
+from .pricing_service import CalculatePriceIn, CalculatePriceOut, PricingService

nlbone/adapters/http_clients/pricing/pricing_service.py

@@ -0,0 +1,100 @@
+from enum import Enum
+from typing import List, Literal, Optional
+
+import httpx
+import requests
+from pydantic import BaseModel, Field, NonNegativeInt, RootModel
+
+from nlbone.adapters.auth.token_provider import ClientTokenProvider
+from nlbone.config.settings import get_settings
+from nlbone.utils.http import auth_headers, normalize_https_base
+
+
+class PricingError(Exception):
+    pass
+
+
+class CalculatePriceIn(BaseModel):
+    params: dict[str, str]
+    product_id: NonNegativeInt | None = None
+    product_title: str | None = None
+
+
+class DiscountType(str, Enum):
+    percent = "percent"
+    amount = "amount"
+
+
+class Product(BaseModel):
+    id: Optional[int] = Field(None, description="Nullable product id")
+    service_product_id: NonNegativeInt
+    title: Optional[str] = None
+
+
+class Pricing(BaseModel):
+    source: Literal["formula", "static"]
+    price: Optional[float] = None
+    discount: Optional[float] = None
+    discount_type: Optional[DiscountType] = None
+    params: Optional[dict] = None
+
+
+class Segment(BaseModel):
+    id: str
+    name: str
+    specificity: int
+    matched_fields: list
+
+
+class Formula(BaseModel):
+    id: int
+    title: str
+    key: str
+    status: str
+    description: str
+
+
+class PricingRule(BaseModel):
+    product: Product
+    segment: Segment | None
+    formula: Optional[Formula] = None
+    pricing: Pricing
+
+
+class CalculatePriceOut(RootModel[List[PricingRule]]):
+    pass
+
+
+class PricingService:
+    def __init__(
+        self,
+        token_provider: ClientTokenProvider,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.Client | None = None,
+    ) -> None:
+        s = get_settings()
+        self._base_url = normalize_https_base(base_url or str(s.PRICING_SERVICE_URL), enforce_https=False)
+        self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
+        self._client = client or requests.session()
+        self._token_provider = token_provider
+
+    def calculate(self, items: list[CalculatePriceIn], response: Literal["list", "dict"] = "dict") -> CalculatePriceOut:
+        body = {"items": [i.model_dump() for i in items]}
+
+        r = self._client.post(
+            f"{self._base_url}/price/calculate",
+            params={"response": response},
+            headers=auth_headers(self._token_provider.get_access_token()),
+            json=body,
+            timeout=self._timeout,
+            verify=False,
+        )
+
+        if r.status_code not in (200, 204):
+            raise PricingError(r.status_code, r.text)
+
+        if r.status_code == 204 or not r.content:
+            return CalculatePriceOut.model_validate(root=[])
+
+        return CalculatePriceOut.model_validate(r.json())

nlbone/adapters/http_clients/uploadchi/__init__.py

@@ -0,0 +1,2 @@
+from .uploadchi import UploadchiClient, UploadchiError
+from .uploadchi_async import UploadchiAsyncClient

nlbone/adapters/http_clients/{uploadchi.py → uploadchi/uploadchi.py}

@@ -1,8 +1,6 @@
 from __future__ import annotations
 
-import json
 from typing import Any, Optional
-from urllib.parse import urlparse, urlunparse
 
 import httpx
 import requests
@@ -10,6 +8,7 @@ import requests
 from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.config.settings import get_settings
 from nlbone.core.ports.files import FileServicePort
+from nlbone.utils.http import auth_headers, build_list_query, normalize_https_base
 
 
 class UploadchiError(RuntimeError):
@@ -26,21 +25,6 @@ def _resolve_token(explicit: str | None) -> str | None:
     return s.UPLOADCHI_TOKEN.get_secret_value() if s.UPLOADCHI_TOKEN else None
 
 
-def _auth_headers(token: str | None) -> dict[str, str]:
-    return {"Authorization": f"Bearer {token}"} if token else {}
-
-
-def _build_list_query(
-        limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
-) -> dict[str, Any]:
-    q: dict[str, Any] = {"limit": limit, "offset": offset}
-    if filters:
-        q["filters"] = json.dumps(filters)
-    if sort:
-        q["sort"] = ",".join([f"{f}:{o}" for f, o in sort])
-    return q
-
-
 def _filename_from_cd(cd: str | None, fallback: str) -> str:
     if not cd:
         return fallback
@@ -49,24 +33,16 @@ def _filename_from_cd(cd: str | None, fallback: str) -> str:
     return fallback
 
 
-def _normalize_https_base(url: str) -> str:
-    p = urlparse(url.strip())
-    p = p._replace(scheme="https")  # enforce https
-    if p.path.endswith("/"):
-        p = p._replace(path=p.path.rstrip("/"))
-    return str(urlunparse(p))
-
-
 class UploadchiClient(FileServicePort):
     def __init__(
-            self,
-            token_provider: ClientTokenProvider | None = None,
-            base_url: Optional[str] = None,
-            timeout_seconds: Optional[float] = None,
-            client: httpx.Client | None = None,
+        self,
+        token_provider: ClientTokenProvider | None = None,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.Client | None = None,
     ) -> None:
         s = get_settings()
-        self._base_url = _normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
+        self._base_url = normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
         self._client = client or requests.session()
         self._token_provider = token_provider
@@ -75,12 +51,12 @@ class UploadchiClient(FileServicePort):
         self._client.close()
 
     def upload_file(
-            self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None
+        self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None
     ) -> dict:
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
-        r = self._client.post(self._base_url, files=files, data=data, headers=_auth_headers(tok))
+        r = self._client.post(self._base_url, files=files, data=data, headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
@@ -91,7 +67,7 @@ class UploadchiClient(FileServicePort):
         tok = _resolve_token(token)
         r = self._client.post(
             f"{self._base_url}/{file_id}/commit",
-            headers=_auth_headers(tok or self._token_provider.get_access_token()),
+            headers=auth_headers(tok or self._token_provider.get_access_token()),
         )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)
@@ -102,36 +78,36 @@ class UploadchiClient(FileServicePort):
         tok = _resolve_token(token)
         r = self._client.post(
             f"{self._base_url}/{file_id}/rollback",
-            headers=_auth_headers(tok or self._token_provider.get_access_token()),
+            headers=auth_headers(tok or self._token_provider.get_access_token()),
         )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)
 
     def list_files(
-            self,
-            limit: int = 10,
-            offset: int = 0,
-            filters: dict[str, Any] | None = None,
-            sort: list[tuple[str, str]] | None = None,
-            token: str | None = None,
+        self,
+        limit: int = 10,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        sort: list[tuple[str, str]] | None = None,
+        token: str | None = None,
     ) -> dict:
         tok = _resolve_token(token)
-        q = _build_list_query(limit, offset, filters, sort)
-        r = self._client.get(self._base_url, params=q, headers=_auth_headers(tok))
+        q = build_list_query(limit, offset, filters, sort)
+        r = self._client.get(self._base_url, params=q, headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def get_file(self, file_id: str, token: str | None = None) -> dict:
         tok = _resolve_token(token)
-        r = self._client.get(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
+        r = self._client.get(f"{self._base_url}/{file_id}", headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def download_file(self, file_id: str, token: str | None = None) -> tuple[bytes, str, str]:
         tok = _resolve_token(token)
-        r = self._client.get(f"{self._base_url}/{file_id}/download", headers=_auth_headers(tok))
+        r = self._client.get(f"{self._base_url}/{file_id}/download", headers=auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         filename = _filename_from_cd(r.headers.get("content-disposition"), fallback=f"file-{file_id}")
@@ -140,6 +116,6 @@ class UploadchiClient(FileServicePort):
 
     def delete_file(self, file_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = self._client.delete(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
+        r = self._client.delete(f"{self._base_url}/{file_id}", headers=auth_headers(tok))
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)