nlbone 0.6.14__tar.gz → 0.6.16__tar.gz

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

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

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

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

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

@@ -137,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"
 
 
@@ -214,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))
@@ -225,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

{nlbone-0.6.14 → nlbone-0.6.16}/src/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-0.6.16/src/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-0.6.16/src/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-0.6.16/src/nlbone/interfaces/api/additional_filed/default_field_rules/__init__.py

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

nlbone-0.6.16/src/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-0.6.16/src/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-0.6.16/src/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-0.6.14 → nlbone-0.6.16}/src/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-0.6.14 → nlbone-0.6.16}/src/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-0.6.14 → nlbone-0.6.16}/src/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-0.6.14 → nlbone-0.6.16}/src/nlbone/interfaces/api/pagination/offset_base.py

@@ -13,20 +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
-        ]
+                                      :50
+                                      ]
 
     @staticmethod
     def _parse_sort(sort_str: Optional[str]) -> list[dict[str, str]]:
@@ -78,6 +78,9 @@ class PaginateRequest:
             filters_dict[key] = value_cast
         return filters_dict
 
+    def remove_deleted(self, deleted_at_field: str = 'deleted_at'):
+        self.filters = self.filters | {'deleted_at': None}
+
 
 class PaginateResponse:
     """
@@ -85,12 +88,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.16/src/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-0.6.16/src/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-0.6.16/src/nlbone/interfaces/api/schemas.py

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

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

@@ -1,78 +0,0 @@
-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

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