nlbone 0.6.0__tar.gz → 0.6.8__tar.gz

{nlbone-0.6.0 → nlbone-0.6.8}/PKG-INFO

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

{nlbone-0.6.0 → nlbone-0.6.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.6.0"
+version = "0.6.8"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -63,4 +63,4 @@ dev = [
 ]
 
 [project.scripts]
-nlbone = "nlbone.interfaces.cli.main:main"
+nlbone = "nlbone.interfaces.cli.main:main"

nlbone-0.6.8/src/nlbone/adapters/__init__.py

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

{nlbone-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.0 → nlbone-0.6.8}/src/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-0.6.8/src/nlbone/adapters/http_clients/__init__.py

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

nlbone-0.6.8/src/nlbone/adapters/http_clients/pricing/__init__.py

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

{nlbone-0.6.0 → nlbone-0.6.8}/src/nlbone/adapters/http_clients/pricing/pricing_service.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from typing import Optional, Literal, List
+from typing import List, Literal, Optional
 
 import httpx
 import requests
@@ -7,7 +7,7 @@ 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 normalize_https_base, auth_headers
+from nlbone.utils.http import auth_headers, normalize_https_base
 
 
 class PricingError(Exception):
@@ -33,10 +33,17 @@ class Product(BaseModel):
 
 class Pricing(BaseModel):
     source: Literal["formula", "static"]
-    price: float
+    price: Optional[float] = None
     discount: Optional[float] = None
     discount_type: Optional[DiscountType] = None
-    params: dict
+    params: Optional[dict] = None
+
+
+class Segment(BaseModel):
+    id: str
+    name: str
+    specificity: int
+    matched_fields: list
 
 
 class Formula(BaseModel):
@@ -49,10 +56,8 @@ class Formula(BaseModel):
 
 class PricingRule(BaseModel):
     product: Product
-    segment_name: str | None
+    segment: Segment | None
     formula: Optional[Formula] = None
-    specificity: int
-    matched_fields: list
     pricing: Pricing
 
 
@@ -62,11 +67,11 @@ class CalculatePriceOut(RootModel[List[PricingRule]]):
 
 class PricingService:
     def __init__(
-            self,
-            token_provider: ClientTokenProvider,
-            base_url: Optional[str] = None,
-            timeout_seconds: Optional[float] = None,
-            client: httpx.Client | None = None,
+        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)
@@ -74,17 +79,16 @@ class PricingService:
         self._client = client or requests.session()
         self._token_provider = token_provider
 
-    def calculate(self, items: list[CalculatePriceIn]) -> CalculatePriceOut:
-        body = {
-            "items": [i.model_dump() for i in items]
-        }
+    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}/priced",
+            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
+            verify=False,
         )
 
         if r.status_code not in (200, 204):

{nlbone-0.6.0 → nlbone-0.6.8}/src/nlbone/adapters/http_clients/uploadchi/__init__.py

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

{nlbone-0.6.0 → nlbone-0.6.8}/src/nlbone/adapters/http_clients/uploadchi/uploadchi.py

@@ -35,11 +35,11 @@ def _filename_from_cd(cd: str | None, fallback: str) -> str:
 
 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))
@@ -51,7 +51,7 @@ 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)}
@@ -84,12 +84,12 @@ class UploadchiClient(FileServicePort):
             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)

{nlbone-0.6.0 → nlbone-0.6.8}/src/nlbone/adapters/http_clients/uploadchi/uploadchi_async.py

@@ -4,21 +4,20 @@ from typing import Any, AsyncIterator, Optional
 
 import httpx
 
+from nlbone.adapters.auth.token_provider import ClientTokenProvider
+from nlbone.adapters.http_clients.uploadchi.uploadchi import UploadchiError, _filename_from_cd, _resolve_token
 from nlbone.config.settings import get_settings
 from nlbone.core.ports.files import AsyncFileServicePort
-
-from nlbone.adapters.http_clients.uploadchi.uploadchi import UploadchiError, _filename_from_cd, _resolve_token
-from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.utils.http import auth_headers, build_list_query
 
 
 class UploadchiAsyncClient(AsyncFileServicePort):
     def __init__(
-            self,
-            token_provider: ClientTokenProvider | None = None,
-            base_url: Optional[str] = None,
-            timeout_seconds: Optional[float] = None,
-            client: httpx.AsyncClient | None = None,
+        self,
+        token_provider: ClientTokenProvider | None = None,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.AsyncClient | None = None,
     ) -> None:
         s = get_settings()
         self._base_url = base_url or str(s.UPLOADCHI_BASE_URL)
@@ -32,7 +31,7 @@ class UploadchiAsyncClient(AsyncFileServicePort):
         await self._client.aclose()
 
     async 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)}
@@ -63,12 +62,12 @@ class UploadchiAsyncClient(AsyncFileServicePort):
             raise UploadchiError(r.status_code, await r.aread())
 
     async 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)

nlbone-0.6.8/src/nlbone/adapters/percolation/__init__.py

@@ -0,0 +1 @@
+from .connection import get_es_client

{nlbone-0.6.0 → nlbone-0.6.8}/src/nlbone/adapters/percolation/connection.py

@@ -4,9 +4,10 @@ from nlbone.config.settings import get_settings
 
 setting = get_settings()
 
+
 def get_es_client():
     es = Elasticsearch(
         setting.ELASTIC_PERCOLATE_URL,
-        basic_auth=(setting.ELASTIC_PERCOLATE_USER, setting.ELASTIC_PERCOLATE_PASS.get_secret_value().strip())
+        basic_auth=(setting.ELASTIC_PERCOLATE_USER, setting.ELASTIC_PERCOLATE_PASS.get_secret_value().strip()),
     )
     return es