nlbone 0.6.13__py3-none-any.whl → 0.6.15__py3-none-any.whl

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/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:
@@ -141,13 +137,15 @@ def _to_sql_like_pattern(s: str) -> str:
 
 def _parse_field_and_op(field: str):
     """
-    Supports 'field__ilike' to force ILIKE.
-    Returns (base_field, op) where op in {'eq', 'ilike'}
+    Supports suffix operators like:
+      __ilike, __gte, __lte, __lt, __gt, __ne
+    Returns (base_field, op) where op in {'eq','ilike','gte','lte','lt','gt','ne'}
     """
     if "__" in field:
         base, op = field.rsplit("__", 1)
-        if op.lower() == "ilike":
-            return base, "ilike"
+        op = op.lower()
+        if base and op in {"ilike", "gte", "lte", "lt", "gt", "ne"}:
+            return base, op
     return field, "eq"
 
 
@@ -201,6 +199,7 @@ def _apply_filters(pagination, entity, query):
                 return v
 
             try:
+
                 def _use_ilike(v) -> bool:
                     if op_hint == "ilike":
                         return True
@@ -217,10 +216,24 @@ def _apply_filters(pagination, entity, query):
                         patterns = [_to_sql_like_pattern(str(v)) for v in vals]
                         predicates.append(or_(*[col.ilike(p) for p in patterns]))
                     else:
-                        coerced = [coerce(v) for v in vals]
+                        coerced = [coerce(v) for v in vals if v is not None]
                         if not coerced:
                             continue
-                        predicates.append(col.in_(coerced))
+
+                        if op_hint == "eq":
+                            predicates.append(col.in_(coerced))
+                        elif op_hint == "ne":
+                            predicates.append(or_(*[col != v for v in coerced]))
+                        elif op_hint == "gt":
+                            predicates.append(or_(*[col > v for v in coerced]))
+                        elif op_hint == "gte":
+                            predicates.append(or_(*[col >= v for v in coerced]))
+                        elif op_hint == "lt":
+                            predicates.append(or_(*[col < v for v in coerced]))
+                        elif op_hint == "lte":
+                            predicates.append(or_(*[col <= v for v in coerced]))
+                        else:
+                            predicates.append(col.in_(coerced))
                 else:
                     if _use_ilike(value) and _is_text_type(coltype):
                         pattern = _to_sql_like_pattern(str(value))
@@ -228,9 +241,25 @@ def _apply_filters(pagination, entity, query):
                     else:
                         v = coerce(value)
                         if v is None:
-                            predicates.append(col.is_(None))
+                            if op_hint in {"eq", "ilike"}:
+                                predicates.append(col.is_(None))
+                            else:
+                                continue
                         else:
-                            predicates.append(col == v)
+                            if op_hint == "eq":
+                                predicates.append(col == v)
+                            elif op_hint == "ne":
+                                predicates.append(col != v)
+                            elif op_hint == "gt":
+                                predicates.append(col > v)
+                            elif op_hint == "gte":
+                                predicates.append(col >= v)
+                            elif op_hint == "lt":
+                                predicates.append(col < v)
+                            elif op_hint == "lte":
+                                predicates.append(col <= v)
+                            else:
+                                predicates.append(col == v)
 
             except _InvalidEnum as e:
                 raise UnprocessableEntityException(str(e), loc=["query", "filters", raw_field]) from e
@@ -304,13 +333,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/adapters/http_clients/pricing/pricing_service.py

@@ -1,6 +1,6 @@
 from decimal import Decimal
 from enum import Enum
-from typing import Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Union
 
 import httpx
 import requests
@@ -16,7 +16,7 @@ class PricingError(Exception):
 
 
 class CalculatePriceIn(BaseModel):
-    params: dict[str, str]
+    params: dict[str, Any]
     product_id: NonNegativeInt | None = None
     product_title: str | None = None
 
@@ -51,8 +51,8 @@ class Formula(BaseModel):
     id: int
     title: str
     key: str
-    status: str
-    description: str
+    status: str | None
+    description: str | None
 
 
 class PricingRule(BaseModel):

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/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/interfaces/api/additional_filed/__init__.py

@@ -0,0 +1,7 @@
+from nlbone.interfaces.api.additional_filed.assembler import assemble_response
+from nlbone.interfaces.api.additional_filed.field_registry import FieldRule, ResourceRegistry
+from nlbone.interfaces.api.additional_filed.resolver import (
+    AdditionalFieldsRequest,
+    build_query_plan,
+    resolve_requested_fields,
+)

nlbone/interfaces/api/additional_filed/assembler.py

@@ -0,0 +1,54 @@
+import inspect
+from typing import Any, Dict
+
+from pydantic import BaseModel
+
+from nlbone.container import Container
+from nlbone.interfaces.api.additional_filed.field_registry import FieldRule, ResourceRegistry
+
+
+def assemble_response(
+    obj: Any,
+    reg: ResourceRegistry,
+    selected_rules: Dict[str, FieldRule],
+    base_schema: type[BaseModel] | None,
+    session,
+) -> Dict[str, Any]:
+    base = {f: getattr(obj, f, None) for f in reg.default_fields - set(reg.rules.keys())}
+    if base_schema:
+        base = base_schema.model_validate(base).model_dump()
+
+    ctx = {"file_service": Container.file_service(), "entity": obj, "db": session}
+    for name, rule in selected_rules.items():
+        if rule.loader:
+            value = inject_dependencies(rule.loader, dependencies=ctx)
+        else:
+            value = _get_nested_attr(obj, name)
+        _put_nested_key(base, name, value)
+
+    return base
+
+
+def inject_dependencies(handler, dependencies):
+    params = inspect.signature(handler).parameters
+    deps = {name: dependency for name, dependency in dependencies.items() if name in params}
+    return handler(**deps)
+
+
+def _get_nested_attr(obj: Any, dotted: str):
+    cur = obj
+    for part in dotted.split("."):
+        if cur is None:
+            return None
+        cur = getattr(cur, part, None)
+    return cur
+
+
+def _put_nested_key(base: Dict[str, Any], dotted: str, value: Any):
+    parts = dotted.split(".")
+    cur = base
+    for p in parts[:-1]:
+        if p not in cur or not isinstance(cur[p], dict):
+            cur[p] = {}
+        cur = cur[p]
+    cur[parts[-1]] = value

nlbone/interfaces/api/additional_filed/default_field_rules/__init__.py

@@ -0,0 +1 @@
+from .image_field_rules import IMAGE_FILED_RULE

nlbone/interfaces/api/additional_filed/default_field_rules/image_field_rules.py

@@ -0,0 +1,13 @@
+from nlbone.interfaces.api.additional_filed import FieldRule
+
+
+def get_image(entity, file_service):
+    image_id = entity.image_id
+    if image_id:
+        try:
+            return file_service.get_file(image_id)
+        except Exception:
+            return None
+
+
+IMAGE_FILED_RULE = FieldRule(default=True, name="image", loader=get_image)

nlbone/interfaces/api/additional_filed/field_registry.py

@@ -0,0 +1,105 @@
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Callable, Dict, Iterable, Optional, Set, Tuple, Type
+
+from pydantic import BaseModel
+
+PermissionChecker = Callable[[Any, str], bool]
+Loader = Callable
+
+
+def _schema_fields(schema: Type[BaseModel], by_alias: bool = True) -> Set[str]:
+    names = set()
+    for name, f in schema.model_fields.items():
+        names.add(f.alias or name if by_alias else name)
+    return names
+
+
+@dataclass(frozen=True)
+class FieldRule:
+    """
+    name: field name (nested with dot)
+    permission: None for public
+    deps: dependencies
+    columns: relationship (SQLAlchemy Column/InstrumentedAttribute)
+    join_paths: required paths for eager-load (ex. Product.supplier, Supplier.address)
+    loader:
+    """
+
+    name: str
+    default: bool = False
+    permission: Optional[str] = None
+    deps: Tuple[str, ...] = ()
+    columns: Tuple[Any, ...] = ()
+    join_paths: Tuple[Any, ...] = ()
+    loader: Optional[Loader] = None
+
+
+class DefaultsMergeMode(str, Enum):
+    STRICT = "strict"  # schema == rules; else raise
+    SCHEMA_PRIORITY = "schema"  # defaults = schema_fields
+    RULES_PRIORITY = "rules"  # defaults = rules_default_fields
+    UNION = "union"  # defaults = schema ∪ rules
+    INTERSECTION = "intersection"  # defaults = schema ∩ rules
+
+
+@dataclass
+class ResourceRegistry:
+    resource: str
+    default_fields: Set[str] = field(default_factory=set)
+    base_schema: Optional[Type[BaseModel]] = None
+    rules: Dict[str, FieldRule] = field(default_factory=dict)
+    bundles: Dict[str, Set[str]] = field(default_factory=dict)
+    _schema_fields_cache: Set[str] = field(default_factory=set, repr=False)
+
+    def add_rule(self, rule: FieldRule) -> "ResourceRegistry":
+        self.rules[rule.name] = rule
+        return self
+
+    def add_bundle(self, bundle: str, items: Iterable[str]) -> "ResourceRegistry":
+        self.bundles[bundle] = set(items)
+        return self
+
+    def set_defaults(self, fields: Iterable[str]) -> "ResourceRegistry":
+        self.default_fields = set(fields)
+        return self
+
+    def recompute_defaults_from_rules(self) -> "ResourceRegistry":
+        self.default_fields = {r.name for r in self.rules.values() if r.default}
+        return self
+
+    def from_paydantc(self, schema: Type[BaseModel], *, by_alias: bool = True) -> "ResourceRegistry":
+        self.base_schema = schema
+        self._schema_fields_cache = _schema_fields(schema, by_alias=by_alias)
+        return self
+
+    def finalize_defaults(self, mode: DefaultsMergeMode = DefaultsMergeMode.UNION) -> "ResourceRegistry":
+        schema_set: Set[str] = self._schema_fields_cache if self.base_schema else set()
+        rules_set: Set[str] = {r.name for r in self.rules.values() if r.default}
+
+        manual_set: Set[str] = set(self.default_fields)
+
+        if mode == DefaultsMergeMode.STRICT:
+            if self.base_schema is None or not rules_set:
+                base = schema_set or rules_set
+            else:
+                if schema_set != rules_set:
+                    raise ValueError(
+                        f"[{self.resource}] Default fields diverged: "
+                        f"schema={sorted(schema_set)} vs rules={sorted(rules_set)}"
+                    )
+                base = schema_set
+        elif mode == DefaultsMergeMode.SCHEMA_PRIORITY:
+            base = schema_set or rules_set
+        elif mode == DefaultsMergeMode.RULES_PRIORITY:
+            base = rules_set or schema_set
+        elif mode == DefaultsMergeMode.UNION:
+            base = schema_set | rules_set
+        elif mode == DefaultsMergeMode.INTERSECTION:
+            base = schema_set & rules_set
+        else:
+            base = schema_set or rules_set
+        final = base | manual_set
+
+        self.default_fields = final
+        return self

nlbone/interfaces/api/additional_filed/resolver.py

@@ -0,0 +1,132 @@
+from typing import Dict, List, Set, Tuple
+
+from nlbone.interfaces.api.additional_filed.field_registry import (
+    DefaultsMergeMode,
+    FieldRule,
+    PermissionChecker,
+    ResourceRegistry,
+)
+from nlbone.interfaces.api.dependencies.auth import client_or_user_has_access_func
+from nlbone.interfaces.api.exceptions import BadRequestException, InternalServerException
+
+MAX_FIELDS = 50
+MAX_BUNDLES = 20
+
+
+class AdditionalFieldsRequest:
+    """
+    FastAPI dependency
+    - fields: ?fields=rating,costPrice,supplier.address.city
+    - bundles: ?bundles=@analytics,@internal
+    """
+
+    def __init__(
+        self,
+        fields: str | None = None,
+        bundles: str | None = None,
+    ) -> None:
+        self.fields = self._parse_csv(fields)[:MAX_FIELDS]
+        self.bundles = self._parse_csv(bundles)[:MAX_BUNDLES]
+
+    @staticmethod
+    def _parse_csv(s: str | None) -> List[str]:
+        if not s:
+            return []
+        return [x.strip() for x in s.split(",") if x.strip()]
+
+
+def resolve_requested_fields(
+    reg: ResourceRegistry,
+    additional_fields: AdditionalFieldsRequest = None,
+    can: PermissionChecker = None,
+    mode: DefaultsMergeMode = DefaultsMergeMode.UNION,
+) -> Tuple[Set[str], Dict[str, FieldRule]]:
+    if not additional_fields:
+        additional_fields = AdditionalFieldsRequest()
+    if not can:
+        can = client_or_user_has_access_func
+    reg.finalize_defaults(mode=mode)
+    expanded_from_bundles = _expand_bundles(reg, set(additional_fields.bundles))
+
+    requested = set(reg.default_fields) | set(additional_fields.fields) | expanded_from_bundles
+
+    # validation
+    unknown = {f for f in requested if (f not in reg.default_fields and f not in reg.rules)}
+    if unknown:
+        raise BadRequestException(f"unknown_fields: {sorted(unknown)}")
+
+    # permission
+    selected_rules: Dict[str, FieldRule] = {}
+    for f in requested:
+        rule = reg.rules.get(f)
+        if rule and rule.permission:
+            try:
+                if not can(rule.permission):
+                    continue
+            except Exception:
+                continue
+
+        if f in reg.default_fields and f not in list(reg.rules.keys()):
+            continue
+
+        if not rule.default and f not in additional_fields.fields:
+            continue
+        selected_rules[f] = rule
+
+    # dependencies
+    final = set(requested)
+
+    def add_deps(name: str):
+        if name in reg.default_fields:
+            return
+        r = reg.rules.get(name)
+        if not r:
+            return
+        for d in r.deps:
+            final.add(d)
+            add_deps(d)
+
+    for f in list(selected_rules.keys()):
+        add_deps(f)
+
+    # validate deps too
+    unknown_deps = {d for d in final if (d not in reg.default_fields and d not in reg.rules)}
+    if unknown_deps:
+        raise InternalServerException(f"registry_missing_rules_for: {sorted(unknown_deps)}")
+
+    # rules
+    return final, selected_rules
+
+
+def _expand_bundles(reg: ResourceRegistry, bundles: Set[str]) -> Set[str]:
+    out: Set[str] = set()
+    seen_bundles: Set[str] = set()
+
+    def dfs(b: str):
+        if b not in reg.bundles:
+            raise BadRequestException(f"Unknown bundle: {b}")
+        if b in seen_bundles:
+            return
+        seen_bundles.add(b)
+        for item in reg.bundles[b]:
+            if item.startswith("@"):
+                dfs(item)
+            else:
+                out.add(item)
+
+    for b in bundles:
+        b = b.lstrip("@")
+        dfs(b)
+    return out
+
+
+def build_query_plan(
+    reg: ResourceRegistry,
+    selected_rules: Dict[str, FieldRule],
+):
+    columns = []
+    joins = []
+    for r in selected_rules.values():
+        columns.extend(r.columns or [])
+        joins.extend(r.join_paths or [])
+    return columns, joins

nlbone/interfaces/api/dependencies/auth.py

@@ -20,14 +20,18 @@ def current_client_id() -> str:
     raise UnauthorizedException()
 
 
+def client_has_access_func(*, permissions=None):
+    request = current_request()
+    if not KeycloakAuthService().client_has_access(request.state.token, permissions=permissions):
+        raise ForbiddenException(f"Forbidden {permissions}")
+    return True
+
+
 def client_has_access(*, permissions=None):
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            request = current_request()
-            if not KeycloakAuthService().client_has_access(request.state.token, permissions=permissions):
-                raise ForbiddenException(f"Forbidden {permissions}")
-
+            client_has_access_func(permissions=permissions)
             return func(*args, **kwargs)
 
         return wrapper
@@ -45,18 +49,22 @@ def user_authenticated(func):
     return wrapper
 
 
+def user_has_access_func(*, permissions=None):
+    request = current_request()
+    if not current_user_id():
+        raise UnauthorizedException()
+    user_permissions = get_auth_service().get_permissions(request.state.token)
+    for p in permissions or []:
+        if p not in user_permissions:
+            raise ForbiddenException(f"Forbidden {permissions}")
+    return True
+
+
 def has_access(*, permissions=None):
     def decorator(func):
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
-            request = current_request()
-            if not current_user_id():
-                raise UnauthorizedException()
-            user_permissions = get_auth_service().get_permissions(request.state.token)
-            for p in permissions or []:
-                if p not in user_permissions:
-                    raise ForbiddenException(f"Forbidden {permissions}")
-
+            user_has_access_func(permissions=permissions)
             return func(*args, **kwargs)
 
         return wrapper
@@ -64,30 +72,23 @@ def has_access(*, permissions=None):
     return decorator
 
 
+def client_or_user_has_access_func(permissions=None, client_permissions=None):
+    request = current_request()
+    token = getattr(request.state, "token", None)
+    if not token:
+        raise UnauthorizedException()
+    needed = client_permissions or permissions
+    if client_has_access_func(permissions=needed):
+        return
+    if user_has_access_func(permissions=needed):
+        return
+
+
 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()
-
-                user_permissions = get_auth_service().get_permissions(request.state.token)
-                for p in permissions or []:
-                    if p not in user_permissions:
-                        raise ForbiddenException(f"Forbidden {permissions}")
-
+            client_or_user_has_access_func(permissions=permissions, client_permissions=client_permissions)
             return func(*args, **kwargs)
 
         return wrapper

nlbone/interfaces/api/exceptions.py

@@ -67,6 +67,14 @@ class NotSupportedException(BaseHttpException):
         )
 
 
+class InternalServerException(BaseHttpException):
+    def __init__(self, detail: str = "internal_server_error"):
+        super().__init__(
+            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            detail=detail,
+        )
+
+
 class UnprocessableEntityException(BaseHttpException):
     def __init__(self, detail: str, loc: Iterable[Any] | None = None, type_: str = "unprocessable_entity"):
         super().__init__(

nlbone/interfaces/api/pagination/__init__.py

@@ -14,6 +14,6 @@ T = TypeVar("T")
 
 
 class Paginated(BaseModel, Generic[T]):
-    total_count: Optional[int]
-    total_page: Optional[int]
+    total_count: Optional[int] = None
+    total_page: Optional[int] = None
     data: List[T]

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/interfaces/api/schema/__init__.py

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

nlbone/interfaces/api/schema/adaptive_schema.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from enum import Enum
+from typing import Any, Iterable, Optional, Type, TypeVar, Union, get_args, get_origin
+
+from pydantic import BaseModel, TypeAdapter
+
+
+class ResponsePreference(str, Enum):
+    minimal = "minimal"
+    lite = "lite"
+    full = "full"
+
+
+M = TypeVar("M", bound=BaseModel)
+
+
+class AdaptiveSchemaBase(ABC):
+    """Base for a *family* of Pydantic schemas of the same resource."""
+
+    @classmethod
+    @abstractmethod
+    def minimal(cls) -> Type[M]: ...
+    @classmethod
+    @abstractmethod
+    def lite(cls) -> Type[M]: ...
+    @classmethod
+    @abstractmethod
+    def full(cls) -> Type[M]: ...
+
+    @classmethod
+    def choose(cls, pref: Optional[ResponsePreference]) -> Type[M]:
+        if pref is None:
+            pref = ResponsePreference.lite
+        return {
+            ResponsePreference.minimal: cls.minimal(),
+            ResponsePreference.lite: cls.lite(),
+            ResponsePreference.full: cls.full(),
+        }.get(pref, cls.lite())
+
+    @classmethod
+    def serialize(cls, obj: Any, pref: Optional[ResponsePreference] = None) -> Any:
+        schema = cls.choose(pref)
+        adapter = TypeAdapter(schema)
+
+        if _is_iterable(obj):
+            return [cls._serialize_one(adapter, schema, x, pref) for x in obj]
+        return cls._serialize_one(adapter, schema, obj, pref)
+
+    @classmethod
+    def _serialize_one(
+        cls, adapter: TypeAdapter, schema_cls: Type[BaseModel], item: Any, pref: Optional[ResponsePreference]
+    ) -> dict:
+        model = adapter.validate_python(item)
+        data = model.model_dump()
+
+        annotations = getattr(schema_cls, "__annotations__", {})
+        for field_name, annotated_type in annotations.items():
+            if field_name not in data:
+                continue
+            value = getattr(item, field_name, None)
+            if value is None:
+                continue
+
+            if _is_adaptive(annotated_type):
+                # تک‌شیء
+                data[field_name] = annotated_type.serialize(value, pref)
+            elif _is_list_of_adaptive(annotated_type):
+                data[field_name] = annotated_type.__args__[0].serialize(value, pref)
+            elif _is_optional_of_adaptive(annotated_type):
+                inner = _unwrap_optional(annotated_type)
+                data[field_name] = None if value is None else inner.serialize(value, pref)
+
+        return data
+
+
+# ---------- helpers ----------
+def _is_iterable(x: Any) -> bool:
+    if isinstance(x, (str, bytes, dict)):
+        return False
+    try:
+        iter(x)
+        return True
+    except TypeError:
+        return False
+
+
+def _is_adaptive(t) -> bool:
+    return isinstance(t, type) and issubclass(t, AdaptiveSchemaBase)
+
+
+def _is_list_of_adaptive(t) -> bool:
+    origin = get_origin(t)
+    if origin not in (
+        list,
+        list.__class__,
+        Iterable,
+    ):
+        return False
+    args = get_args(t)
+    return len(args) == 1 and _is_adaptive(args[0])
+
+
+def _is_optional_of_adaptive(t) -> bool:
+    return (
+        get_origin(t) is Union
+        and len([a for a in get_args(t) if a is not type(None)]) == 1
+        and _is_adaptive([a for a in get_args(t) if a is not type(None)][0])
+    )
+
+
+def _unwrap_optional(t):
+    return [a for a in get_args(t) if a is not type(None)][0]

nlbone/interfaces/api/schema/base_response_model.py

@@ -0,0 +1,22 @@
+
+from pydantic import BaseModel, ConfigDict, model_serializer
+
+EXCLUDE_NONE = "exclude_none"
+
+
+class BaseResponseModel(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+
+    @model_serializer(mode="wrap")
+    def _auto_hide_none_fields(self, handler):
+        data = handler(self)
+
+        hide_candidates = {
+            name for name, f in self.model_fields.items() if (f.json_schema_extra or {}).get(EXCLUDE_NONE) is True
+        }
+
+        for key in list(data.keys()):
+            if key in hide_candidates and data[key] is None:
+                data.pop(key)
+
+        return data

nlbone/interfaces/api/schemas.py

@@ -0,0 +1,5 @@
+from nlbone.interfaces.api.schema import BaseResponseModel
+
+
+class FileOut(BaseResponseModel):
+    url: str

{nlbone-0.6.13.dist-info → nlbone-0.6.15.dist-info}/METADATA

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

{nlbone-0.6.13.dist-info → nlbone-0.6.15.dist-info}/RECORD

@@ -3,7 +3,7 @@ nlbone/container.py,sha256=rVYzH-jIM8iCcefDOo29mNjvFdf3nJ4EtPNUws9SDnA,3089
 nlbone/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/__init__.py,sha256=NzUmk4XPyp3GJOw7VSE86xkQMZLtG3MrOoXLeoB551M,41
 nlbone/adapters/auth/__init__.py,sha256=hkDHvsFhw_UiOHG9ZSMqjiAhK4wumEforitveSZswVw,42
-nlbone/adapters/auth/keycloak.py,sha256=ZGWeq9by2onb440kNRm4BdcxnO7N1qDPmg8UUrXrUrQ,4924
+nlbone/adapters/auth/keycloak.py,sha256=IhEriaFl5mjIGT6ZUCU9qROd678ARchvWgd4UJ6zH7s,4925
 nlbone/adapters/auth/token_provider.py,sha256=vL2Hk6HXnBbpk40Tq1wpqak5QQ7KEQf3nRquT0N8V4Q,1433
 nlbone/adapters/cache/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/cache/async_redis.py,sha256=vvu5w4ANx0BVRHL95RAMGsD8CcaC-tSBMbCius2cuNc,6212
@@ -15,7 +15,7 @@ nlbone/adapters/db/postgres/__init__.py,sha256=6JYJH0xZs3aR-zuyMpRhsdzFugmqz8npr
 nlbone/adapters/db/postgres/audit.py,sha256=8f5XOuW7_ybJyy_STam1FNzqmZAAVAu7tmMRUkCGJOM,4594
 nlbone/adapters/db/postgres/base.py,sha256=kha9xmklzhuQAK8QEkNBn-mAHq8dUKbOM-3abaBpWmQ,71
 nlbone/adapters/db/postgres/engine.py,sha256=UCegauVB1gvo42ThytYnn5VIcQBwR-5xhcXYFApRFNk,3448
-nlbone/adapters/db/postgres/query_builder.py,sha256=SNNkmoMuzcuOwxZlTlplAGqJ0mDQevixLOruqHPa8zM,10855
+nlbone/adapters/db/postgres/query_builder.py,sha256=V-Eb98xi9ajhJaEAW1BMtZot9A3muZa5gO_NRhYR0bQ,12505
 nlbone/adapters/db/postgres/repository.py,sha256=J_DBE73JhHPYCk90c5-O7lQtZbxDgqjjN9OcWy4Omvs,1660
 nlbone/adapters/db/postgres/schema.py,sha256=NlE7Rr8uXypsw4oWkdZhZwcIBHQEPIpoHLxcUo98i6s,1039
 nlbone/adapters/db/postgres/uow.py,sha256=nRxNpY-WoWHpym-XeZ8VHm0MYvtB9wuopOeNdV_ebk8,2088
@@ -23,15 +23,15 @@ nlbone/adapters/db/redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZ
 nlbone/adapters/db/redis/client.py,sha256=5SUnwP2-GrueSFimUbiqDvrQsumvIE2aeozk8l-vOfQ,466
 nlbone/adapters/http_clients/__init__.py,sha256=w-Yr9CLuXMU71N0Ada5HbvP1DB53wqeP6B-i5rALlTo,150
 nlbone/adapters/http_clients/pricing/__init__.py,sha256=ElA9NFcAR9u4cqb_w3PPqKU3xGeyjNLQ8veJ0ql2iz0,81
-nlbone/adapters/http_clients/pricing/pricing_service.py,sha256=PDG6CbLg_SL-BsrhNwfyypywcuZIsEyj5mpQGSPH4e4,3300
+nlbone/adapters/http_clients/pricing/pricing_service.py,sha256=fYfMQh3qW_YDNkBW19RkDkIet7zUDzb2HsIT5dr1Q7Y,3319
 nlbone/adapters/http_clients/uploadchi/__init__.py,sha256=uBzEOuVtY22teWW2b36Pitkdk5yVdSqa6xbg22JfTNg,105
-nlbone/adapters/http_clients/uploadchi/uploadchi.py,sha256=oOkjDA7MMGe7HNl7qgoPbeV_EI5PNIx1yidsxvnkhis,4939
+nlbone/adapters/http_clients/uploadchi/uploadchi.py,sha256=erpjOees25FW0nuK1PkYS-oU0h8MeRV9Rhs1cf3gaEs,4881
 nlbone/adapters/http_clients/uploadchi/uploadchi_async.py,sha256=PQbVNeaYde5CmgT3vcnQoI1PGeSs9AxHlPFuB8biOmU,4717
 nlbone/adapters/messaging/__init__.py,sha256=UDAwu3s-JQmOZjWz2Nu0SgHhnkbeOhKDH_zLD75oWMY,40
 nlbone/adapters/messaging/event_bus.py,sha256=w-NPwDiPMLFPU_enRQCtfQXOALsXfg31u57R8sG_-1U,781
 nlbone/adapters/messaging/redis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/percolation/__init__.py,sha256=0h1Bw7FzxgkDIHxeoyQXSfegrhP6VbpYV4QC8njYdRE,38
-nlbone/adapters/percolation/connection.py,sha256=KUlYPFBXyjv_IEt8zgwdNKynl4VnzL7bp-hcll48Z2w,398
+nlbone/adapters/percolation/connection.py,sha256=1iJISSwMEh4r_6nJI7mYf_v64Q0eeU1eSI0wLIfOK14,415
 nlbone/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/config/logging.py,sha256=Ot6Ctf7EQZlW8YNB-uBdleqI6wixn5fH0Eo6QRgNkQk,4358
 nlbone/config/settings.py,sha256=W3NHZP6yjIyyKiGWNkjlUt_RYFKkcIfMBoKih_z_0Bs,3911
@@ -57,20 +57,29 @@ nlbone/core/ports/uow.py,sha256=SmBdRf0NvSdIjQ3Le1QGz8kNGBk7jgNHtNguvXRwmgs,557
 nlbone/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/exception_handlers.py,sha256=vxNEBgAaQygLgAz1UNt3wHj0SdCJOwtLOv_BwTfir3o,4050
-nlbone/interfaces/api/exceptions.py,sha256=6zWkMnmNGaSa3Myk3MxPCFje0yWWDcbqivIeOKxZuhs,2258
+nlbone/interfaces/api/exceptions.py,sha256=mvpfTf_CUy1V3Y1iGLMGJh_yWfNlJs_ubrYtJmpNW7o,2499
 nlbone/interfaces/api/routers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/interfaces/api/schemas.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/interfaces/api/schemas.py,sha256=NIEKeTdJtwwIkIxL7WURNZF8g34I4TlRAqs-x1Uq7YI,108
+nlbone/interfaces/api/additional_filed/__init__.py,sha256=BWemliLSQV9iq1vdUaF733q0FOSipSWBOQk9eYj732Q,318
+nlbone/interfaces/api/additional_filed/assembler.py,sha256=MyB6YimAAzMe5WUZtHei7a4ITsOpYhrDWIWNAKq7tY8,1599
+nlbone/interfaces/api/additional_filed/field_registry.py,sha256=ScpMsjDBkuUdh_FaBmk1EXBeydERcNthyom1tcJK3BM,3820
+nlbone/interfaces/api/additional_filed/resolver.py,sha256=eVBPj6WsUkZbM3wGPyexwA6d5GThCSgbwNzzHImaOyU,3767
+nlbone/interfaces/api/additional_filed/default_field_rules/__init__.py,sha256=LUSAOO3xRUt5ptlraIx7H-7dSkdr1D-WprmnqXRB16g,48
+nlbone/interfaces/api/additional_filed/default_field_rules/image_field_rules.py,sha256=ecKqPeXZ-YiF14RK9PmK7ln3PCzpCUc18S5zm5IF3fw,339
 nlbone/interfaces/api/dependencies/__init__.py,sha256=rnYRrFVZCfICQrp_PVFlzNg3BeC57yM08wn2DbOHCfk,359
 nlbone/interfaces/api/dependencies/async_auth.py,sha256=bfxgBXhp29WqevjTG4jrdPNR-75APm4jKyHdOOtxnp4,1825
-nlbone/interfaces/api/dependencies/auth.py,sha256=D3D-UA2fMtEU-pSQNWk4cb3W74rXiz4a8u1reI7Wrkk,3001
+nlbone/interfaces/api/dependencies/auth.py,sha256=SVqdH78ek65MdT-81_tJo9QiEbnERAh9dR10pRdTDb8,2833
 nlbone/interfaces/api/dependencies/db.py,sha256=-UD39J_86UU7ZJs2ZncpdND0yhAG0NeeeALrgSDuuFw,466
 nlbone/interfaces/api/dependencies/uow.py,sha256=QfLEvLYLNWZJQN1k-0q0hBVtUld3D75P4j39q_RjcnE,1181
 nlbone/interfaces/api/middleware/__init__.py,sha256=zbX2vaEAfxRMIYwO2MVY_2O6bqG5H9o7HqGpX14U3Is,158
 nlbone/interfaces/api/middleware/access_log.py,sha256=vIkxxxfy2HcjqqKb8XCfGCcSrivAC8u6ie75FMq5x-U,1032
 nlbone/interfaces/api/middleware/add_request_context.py,sha256=av-qs0biOYuF9R6RJOo2eYsFqDL9WRYWcjVakFhbt-w,1834
 nlbone/interfaces/api/middleware/authentication.py,sha256=ze7vCm492QsX9nPL6A-PqZCmC1C5ZgUE-OWI6fCLpsU,1809
-nlbone/interfaces/api/pagination/__init__.py,sha256=sWKKQFa2Z-1SlprQOqImOa2c9exq4wueKpUL_9QM7wc,417
-nlbone/interfaces/api/pagination/offset_base.py,sha256=BPG8veDRUA-67Z_JqLQTqT2nqCalxPblzSiQv_HZXUc,3838
+nlbone/interfaces/api/pagination/__init__.py,sha256=pA1uC4rK6eqDI5IkLVxmgO2B6lExnOm8Pje2-hifJZw,431
+nlbone/interfaces/api/pagination/offset_base.py,sha256=iipO09sAUb0U9ctMMujBHQo1IgMRbasvwnHJFtA9ZeA,3812
+nlbone/interfaces/api/schema/__init__.py,sha256=LAqgynfupeqOQ6u0I5ucrcYnojRMZUg9yW8IjKSQTNI,119
+nlbone/interfaces/api/schema/adaptive_schema.py,sha256=bdWBNpP2NfOJ_in4btXn0lrZOK70x-OqfmZ-NpIJdoQ,3347
+nlbone/interfaces/api/schema/base_response_model.py,sha256=Y-mqNzVheTaGkM4m2DsybK-GLhfODMhBUNyTRoaf_Zc,600
 nlbone/interfaces/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/cli/init_db.py,sha256=C67n2MsJ1vzkJxC8zfUYOxFdd6mEB_vT9agxN6jWoG8,790
 nlbone/interfaces/cli/main.py,sha256=pNldsTgplVyXa-Hx96dySO2I9gFRi49nDXv7J_dO73s,686
@@ -84,8 +93,8 @@ nlbone/utils/context.py,sha256=MmclJ24BG2uvSTg1IK7J-Da9BhVFDQ5ag4Ggs2FF1_w,1600
 nlbone/utils/http.py,sha256=UXUoXgQdTRNT08ho8zl-C5ekfDsD8uf-JiMQ323ooqw,872
 nlbone/utils/redactor.py,sha256=-V4HrHmHwPi3Kez587Ek1uJlgK35qGSrwBOvcbw8Jas,1279
 nlbone/utils/time.py,sha256=DjjyQ9GLsfXoT6NK8RDW2rOlJg3e6sF04Jw6PBUrSvg,1268
-nlbone-0.6.13.dist-info/METADATA,sha256=Q34YJD_7dJxWCLX_t_Ihh-JY8jDahy_mkSCpP7vMM9Y,2228
-nlbone-0.6.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nlbone-0.6.13.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
-nlbone-0.6.13.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.6.13.dist-info/RECORD,,
+nlbone-0.6.15.dist-info/METADATA,sha256=t9hCCQwgtmGzXZOwsvXsc5hinAX5ogPmN36zOQPdyfk,2228
+nlbone-0.6.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nlbone-0.6.15.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
+nlbone-0.6.15.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.6.15.dist-info/RECORD,,