nlbone 0.11.0__tar.gz → 0.11.1__tar.gz

{nlbone-0.11.0 → nlbone-0.11.1}/PKG-INFO

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

{nlbone-0.11.0 → nlbone-0.11.1}/pyproject.toml

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

{nlbone-0.11.0 → nlbone-0.11.1}/src/nlbone/adapters/db/postgres/query_builder.py

@@ -1,7 +1,8 @@
 from typing import Any, Callable, List, Optional, Sequence, Type, Union
 
-from sqlalchemy import and_, asc, case, desc, literal, or_
+from sqlalchemy import Select, and_, asc, case, desc, func, literal, or_, select
 from sqlalchemy.dialects.postgresql import ENUM as PGEnum
+from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Query, Session, aliased
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.orm.interfaces import LoaderOption
@@ -384,6 +385,19 @@ def _apply_order(pagination: PaginateRequest, entity, query):
     return query
 
 
+def apply_pagination_async(pagination: PaginateRequest, entity, stmt: Select = None, limit: bool = True) -> Select:
+    if stmt is None:
+        stmt = select(entity)
+
+    stmt = _apply_filters(pagination, entity, stmt)
+    stmt = _apply_order(pagination, entity, stmt)
+
+    if limit:
+        stmt = stmt.limit(pagination.limit).offset(pagination.offset)
+
+    return stmt
+
+
 def apply_pagination(pagination: PaginateRequest, entity, session: Session, limit=True, query=None) -> Query:
     if not query:
         query = session.query(entity)
@@ -437,6 +451,43 @@ def _serialize_item(item: Any, output_cls: OutputType) -> Any:
         return item
 
 
+async def get_paginated_response_async(
+    pagination,
+    entity,
+    session: AsyncSession,
+    *,
+    with_count: bool = True,
+    output_cls: Optional[Type] = None,
+    eager_options: Optional[Sequence[LoaderOption]] = None,
+    query: Optional[Select] = None,
+) -> dict:
+    stmt = query if query is not None else select(entity)
+
+    if eager_options:
+        stmt = stmt.options(*eager_options)
+
+    filtered_stmt = apply_pagination_async(pagination, entity, stmt=stmt, limit=False)
+
+    total_count = None
+    if with_count:
+        subquery = filtered_stmt.subquery()
+        count_stmt = select(func.count()).select_from(subquery)
+        total_count = await session.scalar(count_stmt)
+
+    final_stmt = filtered_stmt.limit(pagination.limit).offset(pagination.offset)
+    result = await session.execute(final_stmt)
+    rows = result.scalars().all()
+
+    if output_cls is not None:
+        data = [output_cls.model_validate(r, from_attributes=True).model_dump() for r in rows]
+    else:
+        data = rows
+
+    return PaginateResponse(
+        total_count=total_count, data=data, limit=pagination.limit, offset=pagination.offset
+    ).to_dict()
+
+
 def get_paginated_response(
     pagination,
     entity,

{nlbone-0.11.0 → nlbone-0.11.1}/src/nlbone/interfaces/api/additional_filed/assembler.py

@@ -2,11 +2,61 @@ import inspect
 from typing import Any, Dict
 
 from pydantic import BaseModel
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from nlbone.container import Container
 from nlbone.interfaces.api.additional_filed.field_registry import FieldRule, ResourceRegistry
 
 
+async def assemble_response_async(
+    obj: Any,
+    reg: ResourceRegistry,
+    selected_rules: Dict[str, FieldRule],
+    session: AsyncSession,
+    base_schema: type[BaseModel] | None,
+    scope_map: dict[str, set[str]] = None,
+    **kwargs,
+) -> Dict[str, Any]:
+    """
+    Async version of assemble_response.
+    Awaits loaders if they are coroutines.
+    """
+    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.afiles_service(),
+        "entity": obj,
+        "db": session,
+        "pricing_service": Container.async_pricing_service(),
+        **kwargs,
+    }
+
+    roots = {name.split(".", 1)[0] for name in selected_rules.keys()}
+
+    for root in roots:
+        rule = reg.rules.get(root)
+        if not rule:
+            continue
+
+        if rule.loader:
+            dependencies = ctx | {"scope": scope_map.get(root, {""})} if scope_map else ctx
+
+            result = inject_dependencies(rule.loader, dependencies=dependencies)
+
+            if inspect.iscoroutine(result):
+                value = await result
+            else:
+                value = result
+        else:
+            value = _get_nested_attr(obj, root)
+
+        _put_nested_key(base, root, value)
+
+    return base
+
+
 def assemble_response(
     obj: Any,
     reg: ResourceRegistry,

{nlbone-0.11.0 → nlbone-0.11.1}/src/nlbone/interfaces/api/additional_filed/field_registry.py

@@ -1,10 +1,11 @@
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Callable, Dict, Iterable, Optional, Set, Tuple, Type
+from typing import Any, Awaitable, Callable, Dict, Iterable, Optional, Set, Tuple, Type
 
 from pydantic import BaseModel
 
 PermissionChecker = Callable[[Any, str], bool]
+AsyncPermissionChecker = Callable[[str], Awaitable[bool]]
 Loader = Callable
 
 

{nlbone-0.11.0 → nlbone-0.11.1}/src/nlbone/interfaces/api/additional_filed/resolver.py

@@ -2,11 +2,15 @@ from collections import defaultdict
 from typing import Dict, List, Set, Tuple
 
 from nlbone.interfaces.api.additional_filed.field_registry import (
+    AsyncPermissionChecker,
     DefaultsMergeMode,
     FieldRule,
     PermissionChecker,
     ResourceRegistry,
 )
+from nlbone.interfaces.api.dependencies.async_auth import (
+    client_or_user_has_access_func as async_client_or_user_has_access_func,
+)
 from nlbone.interfaces.api.dependencies.auth import client_or_user_has_access_func
 from nlbone.interfaces.api.exceptions import BadRequestException, InternalServerException
 
@@ -36,6 +40,81 @@ class AdditionalFieldsRequest:
         return [x.strip() for x in s.split(",") if x.strip()]
 
 
+async def resolve_requested_fields_async(
+    reg: ResourceRegistry,
+    additional_fields: AdditionalFieldsRequest = None,
+    can: AsyncPermissionChecker = None,
+    mode: DefaultsMergeMode = DefaultsMergeMode.UNION,
+) -> Tuple[Set[str], Dict[str, FieldRule]]:
+    if not additional_fields:
+        additional_fields = AdditionalFieldsRequest()
+    if not can:
+        can = async_client_or_user_has_access_func
+
+    reg.finalize_defaults(mode=mode)
+
+    expanded_bundles = _expand_bundles(reg, set(additional_fields.bundles))
+    requested = set(reg.default_fields) | set(additional_fields.fields) | expanded_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)}")
+
+    selected_rules: Dict[str, FieldRule] = {}
+
+    for f in requested:
+        rule = reg.rules.get(f)
+
+        if f in reg.default_fields and f not in reg.rules:
+            continue
+
+        if not rule:
+            continue
+
+        # Check Permission
+        if rule.permission:
+            try:
+                if not await can(rule.permission):
+                    continue
+            except Exception:
+                continue
+
+        is_explicit = f in additional_fields.fields
+        if not rule.default and not is_explicit:
+            continue
+
+        selected_rules[f] = rule
+
+    # Dependencies
+    final_set = set(requested)
+
+    def add_deps_recursive(name: str):
+        _rule = reg.rules.get(name)
+        if not _rule or not _rule.deps:
+            return
+        for d in _rule.deps:
+            if d not in final_set:
+                final_set.add(d)
+                add_deps_recursive(d)
+
+    for field_with_rule in list(selected_rules.keys()):
+        add_deps_recursive(field_with_rule)
+
+    parents = {f.split(".", 1)[0] for f in final_set if "." in f}
+    for p in parents:
+        if p in reg.rules:
+            final_set.add(p)
+            if p not in selected_rules:
+                selected_rules[p] = reg.rules[p]
+
+    missing_deps = (final_set - set(reg.default_fields)) - set(reg.rules.keys())
+    if missing_deps:
+        raise InternalServerException(f"registry_missing_rules_for: {sorted(missing_deps)}")
+
+    return final_set, selected_rules
+
+
 def resolve_requested_fields(
     reg: ResourceRegistry,
     additional_fields: AdditionalFieldsRequest = None,

{nlbone-0.11.0 → nlbone-0.11.1}/src/nlbone/interfaces/api/dependencies/async_auth.py

@@ -92,7 +92,7 @@ def client_or_user_has_access(*, permissions=None, client_permissions=None):
     return decorator
 
 
-async def is_permitted_user(permissions=None):
+def is_permitted_user(permissions=None):
     async def check_permissions():
         try:
             if bypass_authz():