nlbone 0.6.0__py3-none-any.whl → 0.6.9__py3-none-any.whl

nlbone/adapters/http_clients/pricing/pricing_service.py

@@ -1,5 +1,6 @@
+from decimal import Decimal
 from enum import Enum
-from typing import Optional, Literal, List
+from typing import Dict, List, Literal, Optional, Union
 
 import httpx
 import requests
@@ -7,7 +8,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):
@@ -32,11 +33,18 @@ class Product(BaseModel):
 
 
 class Pricing(BaseModel):
-    source: Literal["formula", "static"]
-    price: float
+    source: Optional[Literal["formula", "static"]] = None
+    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,24 +57,22 @@ 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
 
 
-class CalculatePriceOut(RootModel[List[PricingRule]]):
+class CalculatePriceOut(RootModel[Union[List[PricingRule], Dict[str, 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,
+        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 +80,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):
@@ -94,3 +99,18 @@ class PricingService:
             return CalculatePriceOut.model_validate(root=[])
 
         return CalculatePriceOut.model_validate(r.json())
+
+    def exchange_rates(self) -> Dict[str, Decimal]:
+        r = self._client.get(
+            f"{self._base_url}/variables/key/exchange_rates",
+            headers=auth_headers(self._token_provider.get_access_token()),
+            timeout=self._timeout,
+            verify=False,
+        )
+
+        if r.status_code != 200:
+            raise PricingError(r.status_code, r.text)
+
+        values = r.json().get("values")
+
+        return {f"{value['key']}": Decimal(value["value"]) for value in values}

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/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/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/adapters/percolation/__init__.py

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

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

nlbone/config/logging.py

@@ -11,6 +11,7 @@ from nlbone.utils.redactor import PiiRedactor
 
 settings = get_settings()
 
+
 # ---------- Filters ----------
 class ContextFilter(logging.Filter):
     def filter(self, record: logging.LogRecord) -> bool:
@@ -21,12 +22,32 @@ class ContextFilter(logging.Filter):
         record.user_agent = ctx.get("user_agent")
         return True
 
+
 # ---------- Formatter ----------
 class JsonFormatter(logging.Formatter):
     RESERVED = {
-        "args","asctime","created","exc_info","exc_text","filename","funcName","levelname","levelno",
-        "lineno","module","msecs","message","msg","name","pathname","process","processName",
-        "relativeCreated","stack_info","thread","threadName",
+        "args",
+        "asctime",
+        "created",
+        "exc_info",
+        "exc_text",
+        "filename",
+        "funcName",
+        "levelname",
+        "levelno",
+        "lineno",
+        "module",
+        "msecs",
+        "message",
+        "msg",
+        "name",
+        "pathname",
+        "process",
+        "processName",
+        "relativeCreated",
+        "stack_info",
+        "thread",
+        "threadName",
     }
 
     def format(self, record: logging.LogRecord) -> str:
@@ -53,17 +74,23 @@ class JsonFormatter(logging.Formatter):
 
         return json.dumps(payload, ensure_ascii=False)
 
+
 class PlainFormatter(logging.Formatter):
     def __init__(self):
         super().__init__(
-            fmt="%(asctime)s | %(levelname)s | %(name)s | "
-                "req=%(request_id)s user=%(user_id)s ip=%(ip)s | %(message)s",
+            fmt="%(asctime)s | %(levelname)s | %(name)s | req=%(request_id)s user=%(user_id)s ip=%(ip)s | %(message)s",
             datefmt="%Y-%m-%dT%H:%M:%S%z",
         )
 
+
 # ---------- Setup ----------
-def setup_logging(*, log_json: bool=settings.LOG_JSON, log_level: str =settings.LOG_LEVEL,
-                  log_file: str | None = None, silence_uvicorn_access: bool = True):
+def setup_logging(
+    *,
+    log_json: bool = settings.LOG_JSON,
+    log_level: str = settings.LOG_LEVEL,
+    log_file: str | None = None,
+    silence_uvicorn_access: bool = True,
+):
     handlers = {
         "console": {
             "class": "logging.StreamHandler",
@@ -82,23 +109,25 @@ def setup_logging(*, log_json: bool=settings.LOG_JSON, log_level: str =settings.
             "formatter": "json" if log_json else "plain",
         }
 
-    dictConfig({
-        "version": 1,
-        "disable_existing_loggers": False,
-        "filters": {
-            "ctx": {"()": ContextFilter},
-            "pii": {"()": PiiRedactor},
-        },
-        "formatters": {
-            "json": {"()": JsonFormatter},
-            "plain": {"()": PlainFormatter},
-        },
-        "handlers": handlers,
-        "root": {
-            "level": log_level,
-            "handlers": list(handlers.keys()),
-        },
-    })
+    dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "filters": {
+                "ctx": {"()": ContextFilter},
+                "pii": {"()": PiiRedactor},
+            },
+            "formatters": {
+                "json": {"()": JsonFormatter},
+                "plain": {"()": PlainFormatter},
+            },
+            "handlers": handlers,
+            "root": {
+                "level": log_level,
+                "handlers": list(handlers.keys()),
+            },
+        }
+    )
 
     logging.getLogger("asyncio").setLevel(logging.WARNING)
     logging.getLogger("httpx").setLevel(logging.WARNING)
@@ -115,5 +144,6 @@ def setup_logging(*, log_json: bool=settings.LOG_JSON, log_level: str =settings.
         uvicorn_access.handlers = []
         uvicorn_access.propagate = True
 
+
 def get_logger(name: str | None = None) -> logging.Logger:
     return logging.getLogger(name or "app")

nlbone/container.py

@@ -15,8 +15,9 @@ from nlbone.adapters.http_clients import PricingService
 from nlbone.adapters.http_clients.uploadchi import UploadchiClient
 from nlbone.adapters.http_clients.uploadchi.uploadchi_async import UploadchiAsyncClient
 from nlbone.adapters.messaging import InMemoryEventBus
+from nlbone.config.settings import Settings
 from nlbone.core.ports import EventBusPort
-from nlbone.core.ports.cache import CachePort, AsyncCachePort
+from nlbone.core.ports.cache import AsyncCachePort, CachePort
 from nlbone.core.ports.files import AsyncFileServicePort, FileServicePort
 
 
@@ -36,11 +37,15 @@ class Container(containers.DeclarativeContainer):
     # --- Services ---
     auth: providers.Singleton[KeycloakAuthService] = providers.Singleton(KeycloakAuthService, settings=config)
     token_provider = providers.Singleton(ClientTokenProvider, auth=auth, skew_seconds=30)
-    file_service: providers.Singleton[FileServicePort] = providers.Singleton(UploadchiClient,
-                                                                             token_provider=token_provider)
-    afiles_service: providers.Singleton[AsyncFileServicePort] = providers.Singleton(UploadchiAsyncClient,
-                                                                                    token_provider=token_provider)
-    pricing_service: providers.Singleton[PricingService] = providers.Singleton(PricingService, token_provider=token_provider)
+    file_service: providers.Singleton[FileServicePort] = providers.Singleton(
+        UploadchiClient, token_provider=token_provider
+    )
+    afiles_service: providers.Singleton[AsyncFileServicePort] = providers.Singleton(
+        UploadchiAsyncClient, token_provider=token_provider
+    )
+    pricing_service: providers.Singleton[PricingService] = providers.Singleton(
+        PricingService, token_provider=token_provider
+    )
 
     cache: providers.Singleton[CachePort] = providers.Selector(
         config.CACHE_BACKEND,
@@ -58,12 +63,12 @@ class Container(containers.DeclarativeContainer):
 def create_container(settings: Optional[Any] = None) -> Container:
     c = Container()
     if settings is not None:
-        if hasattr(settings, "model_dump"):
+        if isinstance(settings, Settings):
+            c.config.override(settings)
+        elif hasattr(settings, "model_dump"):
             c.config.from_dict(settings.model_dump())  # Pydantic v2
         elif hasattr(settings, "dict"):
             c.config.from_dict(settings.dict())  # Pydantic v1
         elif isinstance(settings, Mapping):
             c.config.from_dict(dict(settings))
-        else:
-            c.config.override(settings)
     return c

nlbone/core/application/base_worker.py

@@ -33,4 +33,4 @@ class BaseWorker(ABC):
 
     @abstractmethod
     async def process(self, *args, **kwargs) -> Any:
-        pass
+        pass

nlbone/core/domain/models.py

@@ -1,7 +1,8 @@
 import uuid
 from datetime import datetime
-from sqlalchemy import String, DateTime, Index, Text
+
 from sqlalchemy import JSON as SA_JSON
+from sqlalchemy import DateTime, Index, String, Text
 from sqlalchemy.orm import Mapped, mapped_column
 from sqlalchemy.sql import func
 
@@ -9,6 +10,7 @@ from nlbone.adapters.db import Base
 
 try:
     from sqlalchemy.dialects.postgresql import JSONB, UUID
+
     JSONType = JSONB
     UUIDType = UUID(as_uuid=True)
 except Exception:
@@ -35,4 +37,4 @@ class AuditLog(Base):
     __table_args__ = (
         Index("ix_audit_entity_entityid", "entity", "entity_id"),
         Index("ix_audit_created_at", "created_at"),
-    )
+    )

nlbone/core/ports/cache.py

@@ -1,37 +1,53 @@
-from typing import Protocol, Optional, Iterable, Any, Mapping, Sequence, Tuple, TypeVar, Callable
+from typing import Any, Callable, Iterable, Mapping, Optional, Protocol, Sequence, TypeVar
 
 T = TypeVar("T")
 
+
 class CachePort(Protocol):
     def get(self, key: str) -> Optional[bytes]: ...
-    def set(self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None: ...
+    def set(
+        self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None: ...
     def delete(self, key: str) -> None: ...
     def exists(self, key: str) -> bool: ...
     def ttl(self, key: str) -> Optional[int]: ...
 
     def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]: ...
-    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: ...
 
     def get_json(self, key: str) -> Optional[Any]: ...
-    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: ...
 
     def invalidate_tags(self, tags: Iterable[str]) -> int: ...
     def bump_namespace(self, namespace: str) -> int: ...  # versioned keys
     def clear_namespace(self, namespace: str) -> int: ...
 
-    def get_or_set(self, key: str, producer: Callable[[], bytes], *, ttl: int, tags: Optional[Iterable[str]] = None) -> bytes: ...
+    def get_or_set(
+        self, key: str, producer: Callable[[], bytes], *, ttl: int, tags: Optional[Iterable[str]] = None
+    ) -> bytes: ...
+
 
 class AsyncCachePort(Protocol):
     async def get(self, key: str) -> Optional[bytes]: ...
-    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: ...
     async def delete(self, key: str) -> None: ...
     async def exists(self, key: str) -> bool: ...
     async def ttl(self, key: str) -> Optional[int]: ...
     async def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]: ...
-    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: ...
     async def get_json(self, key: str) -> Optional[Any]: ...
-    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: ...
     async def invalidate_tags(self, tags: Iterable[str]) -> int: ...
     async def bump_namespace(self, namespace: str) -> int: ...
     async def clear_namespace(self, namespace: str) -> int: ...
-    async def get_or_set(self, key: str, producer, *, ttl: int, tags: Optional[Iterable[str]] = None) -> bytes: ...
+    async def get_or_set(self, key: str, producer, *, ttl: int, tags: Optional[Iterable[str]] = None) -> bytes: ...

nlbone/interfaces/api/dependencies/auth.py

@@ -59,3 +59,29 @@ def has_access(*, permissions=None):
         return wrapper
 
     return decorator
+
+
+def client_or_user_has_access(*, permissions=None, client_permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            request = current_request()
+            token = getattr(request.state, "token", None)
+            if not token:
+                raise UnauthorizedException()
+
+            auth = KeycloakAuthService()
+
+            if auth.get_client_id(token):
+                needed = client_permissions or permissions
+                if not auth.client_has_access(token, permissions=needed):
+                    raise ForbiddenException(f"Forbidden (client) {needed}")
+            else:
+                if not current_user_id():
+                    raise UnauthorizedException()
+                if not auth.has_access(token, permissions=permissions):
+                    raise ForbiddenException(f"Forbidden (user) {permissions}")
+
+            return func(*args, **kwargs)
+        return wrapper
+    return decorator

nlbone/interfaces/api/pagination/offset_base.py

@@ -1,6 +1,6 @@
 import json
 from math import ceil
-from typing import Any, Optional
+from typing import Any, Optional, List
 
 from fastapi import Query
 
@@ -13,16 +13,18 @@ class PaginateRequest:
     """
 
     def __init__(
-        self,
-        limit: int = 10,
-        offset: int = 0,
-        sort: Optional[str] = None,
-        filters: Optional[str] = Query(None, description="e.g. title:abc"),
+            self,
+            limit: int = 10,
+            offset: int = 0,
+            sort: Optional[str] = None,
+            filters: Optional[str] = Query(None, description="e.g. title:abc"),
+            include: Optional[str] = None,
     ) -> None:
         self.limit = max(0, limit)
         self.offset = max(0, offset)
         self.sort = self._parse_sort(sort)
         self.filters = self._parse_filters(filters or "")
+        self.include_ids: List[int] = ([int(x) for x in include.split(",") if x.strip().isdigit()] if include else [])[:50]
 
     @staticmethod
     def _parse_sort(sort_str: Optional[str]) -> list[dict[str, str]]:
@@ -81,12 +83,12 @@ class PaginateResponse:
     """
 
     def __init__(
-        self,
-        data: list[Any],
-        total_count: int | None,
-        limit: int,
-        offset: int,
-        use_data_key: bool = True,
+            self,
+            data: list[Any],
+            total_count: int | None,
+            limit: int,
+            offset: int,
+            use_data_key: bool = True,
     ) -> None:
         self.data = data
         self.total_count = total_count

nlbone/interfaces/cli/init_db.py

@@ -1,6 +1,6 @@
 import typer
 
-from nlbone.adapters.db import init_sync_engine, Base, sync_ping
+from nlbone.adapters.db import Base, init_sync_engine, sync_ping
 
 init_db_command = typer.Typer(help="Database utilities")
 

nlbone/interfaces/cli/main.py

@@ -1,6 +1,7 @@
-import typer
 from typing import Optional
 
+import typer
+
 from nlbone.adapters.db import init_sync_engine
 from nlbone.config.settings import get_settings
 from nlbone.interfaces.cli.init_db import init_db_command
@@ -9,12 +10,10 @@ app = typer.Typer(help="NLBone CLI")
 
 app.add_typer(init_db_command, name="db")
 
+
 @app.callback()
 def common(
-    env_file: Optional[str] = typer.Option(
-        None, "--env-file", "-e",
-        help="Path to .env file. In prod omit this."
-    ),
+    env_file: Optional[str] = typer.Option(None, "--env-file", "-e", help="Path to .env file. In prod omit this."),
     debug: bool = typer.Option(False, "--debug", help="Enable debug logging"),
 ):
     settings = get_settings(env_file=env_file)
@@ -22,8 +21,10 @@ def common(
         pass
     init_sync_engine(echo=settings.DEBUG)
 
+
 def main():
     app()
 
+
 if __name__ == "__main__":
     main()