nlbone 0.6.8__tar.gz → 0.6.10__tar.gz

{nlbone-0.6.8 → nlbone-0.6.10}/PKG-INFO

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

{nlbone-0.6.8 → nlbone-0.6.10}/pyproject.toml

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

{nlbone-0.6.8 → nlbone-0.6.10}/src/nlbone/adapters/db/postgres/query_builder.py

@@ -1,6 +1,6 @@
 from typing import Any, Callable, Optional, Sequence, Type, Union
 
-from sqlalchemy import asc, desc, or_
+from sqlalchemy import asc, desc, or_, and_, case, literal
 from sqlalchemy.dialects.postgresql import ENUM as PGEnum
 from sqlalchemy.orm import Query, Session
 from sqlalchemy.orm.interfaces import LoaderOption
@@ -21,7 +21,7 @@ from sqlalchemy.sql.sqltypes import (
 from nlbone.interfaces.api.exceptions import UnprocessableEntityException
 from nlbone.interfaces.api.pagination import PaginateRequest, PaginateResponse
 
-NULL_SENTINELS = {"None", "null", ""}
+NULL_SENTINELS = ("None", "null", "")
 
 
 class _InvalidEnum(Exception):
@@ -29,8 +29,15 @@ class _InvalidEnum(Exception):
 
 
 def _apply_order(pagination: PaginateRequest, entity, query):
+    order_clauses = []
+
+    include_ids = getattr(pagination, "include_ids", []) or []
+    if include_ids and hasattr(entity, "id"):
+        id_col = getattr(entity, "id")
+        whens = [(id_col == _id, idx) for idx, _id in enumerate(include_ids)]
+        order_clauses.append(asc(case(*whens, else_=literal(999_999))))
+
     if pagination.sort:
-        order_clauses = []
         for sort in pagination.sort:
             field = sort["field"]
             order = sort["order"]
@@ -42,8 +49,8 @@ def _apply_order(pagination: PaginateRequest, entity, query):
                 else:
                     order_clauses.append(desc(column))
 
-        if order_clauses:
-            query = query.order_by(*order_clauses)
+    if order_clauses:
+        query = query.order_by(*order_clauses)
     return query
 
 
@@ -101,89 +108,100 @@ def _parse_field_and_op(field: str):
 
 
 def _apply_filters(pagination, entity, query):
-    if not getattr(pagination, "filters", None):
+    if not getattr(pagination, "filters", None) and not getattr(pagination, "include_ids", None):
         return query
 
-    for raw_field, value in pagination.filters.items():
-        if value is None or value in NULL_SENTINELS or value == [] or value == {}:
-            value = None
-
-        field, op_hint = _parse_field_and_op(raw_field)
-
-        if not hasattr(entity, field):
-            continue
-
-        col = getattr(entity, field)
-        coltype = getattr(col, "type", None)
-
-        def coerce(v):
-            if v is None:
-                return None
-            # Enums
-            if isinstance(coltype, (SAEnum, PGEnum)):
-                return _coerce_enum(coltype, v)
-            # Text
-            if _is_text_type(coltype):
-                return str(v)
-            # Numbers
-            if isinstance(coltype, (Integer, BigInteger, SmallInteger)):
-                return int(v)
-            if isinstance(coltype, (Float, Numeric)):
-                return float(v)
-            # Booleans
-            if isinstance(coltype, Boolean):
-                if isinstance(v, bool):
-                    return v
-                if isinstance(v, (int, float)):
-                    return bool(v)
-                if isinstance(v, str):
-                    vl = v.strip().lower()
-                    if vl in {"true", "1", "yes", "y", "t"}:
+    predicates = []
+
+    if getattr(pagination, "filters", None):
+        for raw_field, value in pagination.filters.items():
+            if value is None or value in NULL_SENTINELS or value == [] or value == {}:
+                value = None
+
+            field, op_hint = _parse_field_and_op(raw_field)
+
+            if not hasattr(entity, field):
+                continue
+
+            col = getattr(entity, field)
+            coltype = getattr(col, "type", None)
+
+            def coerce(v):
+                if v is None:
+                    return None
+                # Enums
+                if isinstance(coltype, (SAEnum, PGEnum)):
+                    return _coerce_enum(coltype, v)
+                # Text
+                if _is_text_type(coltype):
+                    return str(v)
+                # Numbers
+                if isinstance(coltype, (Integer, BigInteger, SmallInteger)):
+                    return int(v)
+                if isinstance(coltype, (Float, Numeric)):
+                    return float(v)
+                # Booleans
+                if isinstance(coltype, Boolean):
+                    if isinstance(v, bool):
+                        return v
+                    if isinstance(v, (int, float)):
+                        return bool(v)
+                    if isinstance(v, str):
+                        vl = v.strip().lower()
+                        if vl in {"true", "1", "yes", "y", "t"}:
+                            return True
+                        if vl in {"false", "0", "no", "n", "f"}:
+                            return False
+                    return None
+                return v
+
+            try:
+                def _use_ilike(v) -> bool:
+                    if op_hint == "ilike":
+                        return True
+                    if _is_text_type(coltype) and isinstance(v, str) and _looks_like_wildcard(v):
                         return True
-                    if vl in {"false", "0", "no", "n", "f"}:
-                        return False
-                return None
-            # fallback
-            return v
+                    return False
 
-        try:
-            # Decide operator: explicit __ilike OR automatic if wildcard on text
-            def _use_ilike(v) -> bool:
-                if op_hint == "ilike":
-                    return True
-                if _is_text_type(coltype) and isinstance(v, str) and _looks_like_wildcard(v):
-                    return True
-                return False
-
-            if isinstance(value, (list, tuple, set)):
-                vals = [v for v in value if v not in (None, "", "null", "None")]
-                if not vals:
-                    continue
-
-                # if any value signals ilike, apply OR of ilike; else IN / EQs
-                if any(_use_ilike(v) for v in vals) and _is_text_type(coltype):
-                    patterns = [_to_sql_like_pattern(str(v)) for v in vals]
-                    query = query.filter(or_(*[col.ilike(p) for p in patterns]))
-                else:
-                    coerced = [coerce(v) for v in vals]
-                    if not coerced:
+                if isinstance(value, (list, tuple, set)):
+                    vals = [v for v in value if v not in (None, "", "null", "None")]
+                    if not vals:
                         continue
-                    query = query.filter(col.in_(coerced))
-            else:
-                if _use_ilike(value) and _is_text_type(coltype):
-                    pattern = _to_sql_like_pattern(str(value))
-                    query = query.filter(col.ilike(pattern))
+
+                    if any(_use_ilike(v) for v in vals) and _is_text_type(coltype):
+                        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]
+                        if not coerced:
+                            continue
+                        predicates.append(col.in_(coerced))
                 else:
-                    v = coerce(value)
-                    if v is None:
-                        query = query.filter(col.is_(None))
+                    if _use_ilike(value) and _is_text_type(coltype):
+                        pattern = _to_sql_like_pattern(str(value))
+                        predicates.append(col.ilike(pattern))
                     else:
-                        query = query.filter(col == v)
-
-        except _InvalidEnum as e:
-            # Surface validation error like before
-            raise UnprocessableEntityException(str(e), loc=["query", "filters", raw_field]) from e
-
+                        v = coerce(value)
+                        if v is None:
+                            predicates.append(col.is_(None))
+                        else:
+                            predicates.append(col == v)
+
+            except _InvalidEnum as e:
+                raise UnprocessableEntityException(str(e), loc=["query", "filters", raw_field]) from e
+
+    include_ids = getattr(pagination, "include_ids", []) or []
+    if include_ids and hasattr(entity, "id"):
+        id_col = getattr(entity, "id")
+        include_pred = id_col.in_(include_ids)
+        if predicates:
+            final_pred = or_(and_(*predicates), include_pred)
+        else:
+            final_pred = or_(and_(*[1 == 1]), include_pred)
+        return query.filter(final_pred)
+
+    if predicates:
+        query = query.filter(and_(*predicates))
     return query
 
 
@@ -210,24 +228,24 @@ def _serialize_item(item: Any, output_cls: OutputType) -> Any:
 
     if hasattr(output_cls, "model_validate"):
         try:
-            model = output_cls.model_validate(item, from_attributes=True)  # type: ignore[attr-defined]
+            model = output_cls.model_validate(item, from_attributes=True)
             if hasattr(model, "model_dump"):
-                return model.model_dump()  # type: ignore[attr-defined]
+                return model.model_dump()
             return model
         except Exception:
             pass
 
     if hasattr(output_cls, "from_orm"):
         try:
-            model = output_cls.from_orm(item)  # type: ignore[attr-defined]
+            model = output_cls.from_orm(item)
             if hasattr(model, "dict"):
-                return model.dict()  # type: ignore[attr-defined]
+                return model.dict()
             return model
         except Exception:
             pass
 
     try:
-        obj = output_cls(item)  # type: ignore[call-arg]
+        obj = output_cls(item)
         try:
             from dataclasses import asdict, is_dataclass
 
@@ -249,7 +267,6 @@ def get_paginated_response(
     output_cls: Optional[Type] = None,
     eager_options: Optional[Sequence[LoaderOption]] = None,
 ) -> dict:
-    # پایه‌ی کوئری
     query = session.query(entity)
     if eager_options:
         query = query.options(*eager_options)

{nlbone-0.6.8 → nlbone-0.6.10}/src/nlbone/adapters/http_clients/pricing/pricing_service.py

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

{nlbone-0.6.8 → nlbone-0.6.10}/src/nlbone/container.py

@@ -15,6 +15,7 @@ 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
@@ -62,12 +63,12 @@ class Container(containers.DeclarativeContainer):
 def create_container(settings: Optional[Any] = None) -> Container:
     c = Container()
     if settings is not None:
-        if hasattr(settings, "model_dump"):
+        if isinstance(settings, Settings):
+            c.config.override(settings)
+        elif hasattr(settings, "model_dump"):
             c.config.from_dict(settings.model_dump())  # Pydantic v2
         elif hasattr(settings, "dict"):
             c.config.from_dict(settings.dict())  # Pydantic v1
         elif isinstance(settings, Mapping):
             c.config.from_dict(dict(settings))
-        else:
-            c.config.override(settings)
     return c

{nlbone-0.6.8 → nlbone-0.6.10}/src/nlbone/interfaces/api/pagination/offset_base.py

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