nlbone 0.6.12__tar.gz → 0.6.14__tar.gz

{nlbone-0.6.12 → nlbone-0.6.14}/PKG-INFO

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

{nlbone-0.6.12 → nlbone-0.6.14}/pyproject.toml

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

{nlbone-0.6.12 → nlbone-0.6.14}/src/nlbone/adapters/auth/keycloak.py

@@ -36,7 +36,7 @@ class KeycloakAuthService(AuthService):
             realm_name=s.KEYCLOAK_REALM_NAME,
             client_secret_key=s.KEYCLOAK_CLIENT_SECRET.get_secret_value().strip(),
         )
-        self.bypass = s.ENV != 'prod'
+        self.bypass = s.ENV != "prod"
 
     def has_access(self, token, permissions):
         if self.bypass:
@@ -145,4 +145,4 @@ class KeycloakAuthService(AuthService):
 
 @functools.lru_cache(maxsize=1)
 def get_auth_service() -> KeycloakAuthService:
-    return KeycloakAuthService()
+    return KeycloakAuthService()

{nlbone-0.6.12 → nlbone-0.6.14}/src/nlbone/adapters/db/postgres/query_builder.py

@@ -1,9 +1,11 @@
 from typing import Any, Callable, Optional, Sequence, Type, Union
 
-from sqlalchemy import asc, desc, or_, and_, case, literal
+from sqlalchemy import and_, asc, case, desc, literal, or_
 from sqlalchemy.dialects.postgresql import ENUM as PGEnum
-from sqlalchemy.orm import Query, Session
+from sqlalchemy.orm import Query, Session, aliased
+from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.orm.interfaces import LoaderOption
+from sqlalchemy.orm.relationships import RelationshipProperty
 from sqlalchemy.sql.sqltypes import (
     BigInteger,
     Boolean,
@@ -28,12 +30,6 @@ class _InvalidEnum(Exception):
     pass
 
 
-from sqlalchemy.orm import aliased
-from sqlalchemy.inspection import inspect
-from sqlalchemy.orm.attributes import InstrumentedAttribute
-from sqlalchemy.orm.relationships import RelationshipProperty
-
-
 def _resolve_column_and_joins(entity, query, field_path: str, join_cache: dict[str, Any]):
     parts = [p for p in field_path.split(".") if p]
     if not parts:
@@ -201,6 +197,7 @@ def _apply_filters(pagination, entity, query):
                 return v
 
             try:
+
                 def _use_ilike(v) -> bool:
                     if op_hint == "ilike":
                         return True
@@ -304,13 +301,13 @@ def _serialize_item(item: Any, output_cls: OutputType) -> Any:
 
 
 def get_paginated_response(
-        pagination,
-        entity,
-        session: Session,
-        *,
-        with_count: bool = True,
-        output_cls: Optional[Type] = None,
-        eager_options: Optional[Sequence[LoaderOption]] = None,
+    pagination,
+    entity,
+    session: Session,
+    *,
+    with_count: bool = True,
+    output_cls: Optional[Type] = None,
+    eager_options: Optional[Sequence[LoaderOption]] = None,
 ) -> dict:
     query = session.query(entity)
     if eager_options:

{nlbone-0.6.12 → nlbone-0.6.14}/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)
@@ -116,7 +116,8 @@ 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 or self._token_provider.get_access_token()))
+        r = self._client.delete(
+            f"{self._base_url}/{file_id}", 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)

{nlbone-0.6.12 → nlbone-0.6.14}/src/nlbone/adapters/percolation/connection.py

@@ -9,6 +9,8 @@ def get_es_client():
     es = Elasticsearch(
         setting.ELASTIC_PERCOLATE_URL,
         basic_auth=(setting.ELASTIC_PERCOLATE_USER, setting.ELASTIC_PERCOLATE_PASS.get_secret_value().strip()),
-        http_compress=True, max_retries=2, retry_on_timeout=True
+        http_compress=True,
+        max_retries=2,
+        retry_on_timeout=True,
     )
     return es

{nlbone-0.6.12 → nlbone-0.6.14}/src/nlbone/container.py

@@ -1,8 +1,9 @@
 from __future__ import annotations
 
-from typing import Any, Mapping, Optional
+from typing import Dict, Optional
 
 from dependency_injector import containers, providers
+from pydantic_settings import BaseSettings
 
 from nlbone.adapters.auth.keycloak import KeycloakAuthService
 from nlbone.adapters.auth.token_provider import ClientTokenProvider
@@ -15,7 +16,6 @@ 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 AsyncCachePort, CachePort
 from nlbone.core.ports.files import AsyncFileServicePort, FileServicePort
@@ -35,7 +35,7 @@ class Container(containers.DeclarativeContainer):
     event_bus: providers.Singleton[EventBusPort] = providers.Singleton(InMemoryEventBus)
 
     # --- Services ---
-    auth: providers.Singleton[KeycloakAuthService] = providers.Singleton(KeycloakAuthService, settings=config)
+    auth: providers.Singleton[KeycloakAuthService] = providers.Singleton(KeycloakAuthService)
     token_provider = providers.Singleton(ClientTokenProvider, auth=auth, skew_seconds=30)
     file_service: providers.Singleton[FileServicePort] = providers.Singleton(
         UploadchiClient, token_provider=token_provider
@@ -60,15 +60,11 @@ class Container(containers.DeclarativeContainer):
     )
 
 
-def create_container(settings: Optional[Any] = None) -> Container:
+def create_container(settings: Optional[BaseSettings | Dict] = None) -> Container:
     c = Container()
     if settings is not None:
-        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))
+        if isinstance(settings, BaseSettings):
+            c.config.from_pydantic(settings)
+        elif isinstance(settings, Dict):
+            c.config.from_dict(settings)
     return c

{nlbone-0.6.12 → nlbone-0.6.14}/src/nlbone/interfaces/api/pagination/offset_base.py

@@ -1,6 +1,6 @@
 import json
 from math import ceil
-from typing import Any, Optional, List
+from typing import Any, List, Optional
 
 from fastapi import Query
 
@@ -13,18 +13,20 @@ 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"),
-            include: Optional[str] = None,
+        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]
+        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]]:
@@ -83,12 +85,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-0.6.14/src/nlbone/interfaces/api/schema/__init__.py

@@ -0,0 +1,2 @@
+from .adaptive_schema import AdaptiveSchemaBase, ResponsePreference
+from .base_response_model import BaseResponseModel

nlbone-0.6.14/src/nlbone/interfaces/api/schema/adaptive_schema.py

@@ -0,0 +1,78 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, List, Type, get_args, get_origin
+
+from pydantic import BaseModel
+
+from nlbone.utils.context import current_request
+
+
+class ResponsePreference(str, Enum):
+    minimal = "minimal"
+    lite = "lite"
+    full = "full"
+
+
+class AdaptiveSchemaBase(ABC):
+    @classmethod
+    @abstractmethod
+    def minimal(cls) -> Type:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def lite(cls) -> Type:
+        pass
+
+    @classmethod
+    @abstractmethod
+    def full(cls) -> Type:
+        pass
+
+    @classmethod
+    def choose(cls, preference: ResponsePreference) -> Type:
+        if preference == ResponsePreference.minimal:
+            return cls.minimal()
+        elif preference == ResponsePreference.lite:
+            return cls.lite()
+        elif preference == ResponsePreference.full:
+            return cls.full()
+        return cls.lite()
+
+    @classmethod
+    def serialize(cls, obj: Any, preference: ResponsePreference = None) -> Any:
+        if not preference:
+            preference = current_request().state.response_preference
+
+        schema = cls.choose(preference)
+
+        if isinstance(obj, list):
+            return [cls._recursive_serialize(schema, item) for item in obj]
+
+        return cls._recursive_serialize(schema, obj)
+
+    @classmethod
+    def _recursive_serialize(cls, schema_cls: type[BaseModel], item: Any) -> dict:
+        # Create base dict from ORM model
+        raw_data = schema_cls.model_validate(item).model_dump()
+
+        # Check each field to see if it needs nested serialization
+        annotations = schema_cls.__annotations__
+
+        for field_name, field_type in annotations.items():
+            field_value = getattr(item, field_name, None)
+
+            if field_value is None:
+                continue
+
+            # Check for nested AdaptiveSchemaBase (single object)
+            if isinstance(field_type, type) and issubclass(field_type, AdaptiveSchemaBase):
+                raw_data[field_name] = field_type.serialize(field_value)
+
+            # Check for list[AdaptiveSchemaBase]
+            elif get_origin(field_type) in (list, List):
+                sub_type = get_args(field_type)[0]
+                if isinstance(sub_type, type) and issubclass(sub_type, AdaptiveSchemaBase):
+                    raw_data[field_name] = sub_type.serialize(field_value)
+
+        return raw_data

nlbone-0.6.14/src/nlbone/interfaces/api/schema/base_response_model.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class BaseResponseModel(BaseModel):
+    pass