nlbone 0.7.21__py3-none-any.whl → 0.7.23__py3-none-any.whl

nlbone/adapters/auth/auth_service.py

@@ -2,8 +2,8 @@ import requests
 
 from nlbone.config.settings import get_settings
 from nlbone.core.ports.auth import AuthService as BaseAuthService
-from nlbone.utils.http import normalize_https_base
 from nlbone.utils.cache import cached
+from nlbone.utils.http import normalize_https_base
 
 
 class AuthService(BaseAuthService):
@@ -15,15 +15,12 @@ class AuthService(BaseAuthService):
         self._timeout = float(s.HTTP_TIMEOUT_SECONDS)
         self._client = requests.session()
 
-    def has_access(self, token: str, permissions: list[str]) -> bool:
-        ...
+    def has_access(self, token: str, permissions: list[str]) -> bool: ...
 
     @cached(ttl=15 * 60)
     def verify_token(self, token: str) -> dict:
         url = f"{self._base_url}/introspect"
-        result = self._client.post(url, data={
-            "token": token
-        })
+        result = self._client.post(url, data={"token": token})
         if result.status_code == 200:
             return result.json()
         return None
@@ -31,22 +28,20 @@ class AuthService(BaseAuthService):
     def get_client_id(self, token: str):
         data = self.verify_token(token)
         if data:
-            return data["sub"] if data["sub"].startswith('service-account') else None
+            return data["sub"] if data["sub"].startswith("service-account") else None
         return None
 
     def get_client_token(self) -> dict | None:
         url = f"{self._base_url}/token"
-        result = self._client.post(url, data={
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "grant_type": "client_credentials"
-        })
+        result = self._client.post(
+            url,
+            data={"client_id": self.client_id, "client_secret": self.client_secret, "grant_type": "client_credentials"},
+        )
         if result.status_code == 200:
             return result.json()
         return None
 
-    def is_client_token(self, token: str, allowed_clients: set[str] | None = None) -> bool:
-        ...
+    def is_client_token(self, token: str, allowed_clients: set[str] | None = None) -> bool: ...
 
     def client_has_access(self, token: str, permissions: list[str], allowed_clients: set[str] | None = None) -> bool:
         data = self.verify_token(token)
@@ -55,5 +50,4 @@ class AuthService(BaseAuthService):
         has_access = [self.client_id + "#" + perm in data.get("allowed_permissions", []) for perm in permissions]
         return all(has_access)
 
-    def get_permissions(self, token: str) -> list[str]:
-        ...
+    def get_permissions(self, token: str) -> list[str]: ...

nlbone/adapters/db/postgres/query_builder.py

@@ -1,4 +1,4 @@
-from typing import Any, Callable, Optional, Sequence, Type, Union
+from typing import Any, Callable, List, Optional, Sequence, Type, Union
 
 from sqlalchemy import and_, asc, case, desc, literal, or_
 from sqlalchemy.dialects.postgresql import ENUM as PGEnum
@@ -30,7 +30,14 @@ class _InvalidEnum(Exception):
     pass
 
 
-def _resolve_column_and_joins(entity, query, field_path: str, join_cache: dict[str, Any]):
+VALID_OPERATORS = {"ilike", "gte", "lte", "lt", "gt", "ne", "in", "notin", "eq"}
+
+
+def _resolve_column_and_joins(entity, query: Query, field_path: str, join_cache: dict[str, Any]):
+    """
+    Resolves nested fields like 'items.product.name' into SQLAlchemy columns,
+    performing necessary joins and caching aliases to prevent duplicate joins.
+    """
     parts = [p for p in field_path.split(".") if p]
     if not parts:
         return None, query
@@ -46,8 +53,8 @@ def _resolve_column_and_joins(entity, query, field_path: str, join_cache: dict[s
             return None, query
 
         attr = getattr(current_cls_or_alias, part)
-
         prop = getattr(attr, "property", None)
+
         if isinstance(prop, RelationshipProperty):
             alias = join_cache.get(path_key)
             if alias is None:
@@ -63,35 +70,51 @@ def _resolve_column_and_joins(entity, query, field_path: str, join_cache: dict[s
             else:
                 return None, query
 
-        return None, query
-
     return None, query
 
 
-def _apply_order(pagination: PaginateRequest, entity, query):
-    order_clauses = []
+def _coerce_value(coltype, value):
+    """
+    Single responsibility: Convert raw string/input to the correct python type based on column definition.
+    """
+    if value is None:
+        return None
 
-    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))))
+    # Enums
+    if isinstance(coltype, (SAEnum, PGEnum)):
+        return _coerce_enum(coltype, value)
 
-    if pagination.sort:
-        for sort in pagination.sort:
-            field = sort["field"]
-            order = sort["order"]
+    # Text
+    if _is_text_type(coltype):
+        return str(value)
 
-            if hasattr(entity, field):
-                column = getattr(entity, field)
-                if order == "asc":
-                    order_clauses.append(asc(column))
-                else:
-                    order_clauses.append(desc(column))
+    # Numbers
+    if isinstance(coltype, (Integer, BigInteger, SmallInteger)):
+        try:
+            return int(value)
+        except (ValueError, TypeError):
+            return None
+    if isinstance(coltype, (Float, Numeric)):
+        try:
+            return float(value)
+        except (ValueError, TypeError):
+            return None
+
+    # Booleans
+    if isinstance(coltype, Boolean):
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, (int, float)):
+            return bool(value)
+        if isinstance(value, str):
+            vl = value.strip().lower()
+            if vl in {"true", "1", "yes", "y", "t"}:
+                return True
+            if vl in {"false", "0", "no", "n", "f"}:
+                return False
+        return None
 
-    if order_clauses:
-        query = query.order_by(*order_clauses)
-    return query
+    return value
 
 
 def _coerce_enum(col_type, raw):
@@ -121,7 +144,6 @@ def _is_text_type(coltype):
 
 
 def _looks_like_wildcard(s: str) -> bool:
-    # treat '*' and '%' as wildcards
     return isinstance(s, str) and ("*" in s or "%" in s)
 
 
@@ -137,18 +159,53 @@ def _to_sql_like_pattern(s: str) -> str:
 
 def _parse_field_and_op(field: str):
     """
-    Supports suffix operators like:
-      __ilike, __gte, __lte, __lt, __gt, __ne
-    Returns (base_field, op) where op in {'eq','ilike','gte','lte','lt','gt','ne'}
+    Parses 'field__op' syntax.
+    Example: 'age__gt' -> ('age', 'gt')
+             'items.price__in' -> ('items.price', 'in')
     """
     if "__" in field:
         base, op = field.rsplit("__", 1)
         op = op.lower()
-        if base and op in {"ilike", "gte", "lte", "lt", "gt", "ne"}:
+        if base and op in VALID_OPERATORS:
             return base, op
     return field, "eq"
 
 
+def _build_relational_negation(entity, path_parts: List[str], values: List[Any]):
+    current_part = path_parts[0]
+    remaining_parts = path_parts[1:]
+
+    if not hasattr(entity, current_part):
+        return None
+
+    attr = getattr(entity, current_part)
+    prop = getattr(attr, "property", None)
+
+    if isinstance(prop, RelationshipProperty):
+        related_class = prop.mapper.class_
+
+        inner_clause = _build_relational_negation(related_class, remaining_parts, values)
+
+        if inner_clause is None:
+            return None
+
+        if prop.direction.name in ("MANYTOONE", "ONETOONE"):
+            return attr.has(inner_clause)
+        else:  # ONETOMANY, MANYTOMANY
+            return attr.any(inner_clause)
+
+    else:
+        col = attr
+        coltype = getattr(col, "type", None)
+
+        coerced_vals = [_coerce_value(coltype, v) for v in values if v not in (None, "", "null", "None")]
+
+        if not coerced_vals:
+            return None
+
+        return col.in_(coerced_vals)
+
+
 def _apply_filters(pagination, entity, query):
     if not getattr(pagination, "filters", None) and not getattr(pagination, "include_ids", None):
         return query
@@ -156,74 +213,90 @@ def _apply_filters(pagination, entity, query):
     predicates = []
     join_cache: dict[str, Any] = {}
 
-    if getattr(pagination, "filters", None):
-        for raw_field, value in pagination.filters.items():
+    filters = getattr(pagination, "filters", {})
+    if filters:
+        for raw_field, value in filters.items():
             if value is None or value in NULL_SENTINELS or value == [] or value == {}:
-                value = None
+                continue
 
             field, op_hint = _parse_field_and_op(raw_field)
+            is_nested = "." in field
+            if op_hint == "notin" and is_nested:
+                vals = []
+                if isinstance(value, str):
+                    clean_value = value.strip().strip("[]")
+                    if clean_value:
+                        if "," in clean_value:
+                            vals = [x.strip() for x in clean_value.split(",")]
+                        else:
+                            vals = [clean_value.strip()]
+                elif isinstance(value, (list, tuple, set)):
+                    vals = list(value)
+                else:
+                    vals = [value]
+
+                if vals:
+                    path_parts = field.split(".")
+                    negation_clause = _build_relational_negation(entity, path_parts, vals)
+
+                    if negation_clause is not None:
+                        predicates.append(~negation_clause)
+                        continue
 
-            col, query2 = _resolve_column_and_joins(entity, query, field, join_cache)
+            col, query = _resolve_column_and_joins(entity, query, field, join_cache)
             if col is None:
                 continue
-            query = query2
-            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
+            coltype = getattr(col, "type", None)
 
             try:
+                if op_hint in ("in", "notin"):
+                    if isinstance(value, str):
+                        clean_value = value.strip().strip("[]")
+                        if not clean_value:
+                            continue
+                        if "," in clean_value:
+                            vals = [x.strip() for x in clean_value.split(",")]
+                        else:
+                            vals = [clean_value.strip()]
+                    elif isinstance(value, (list, tuple, set)):
+                        vals = value
+                    else:
+                        vals = [value]
+
+                    coerced_vals = [_coerce_value(coltype, v) for v in vals if v not in (None, "", "null", "None")]
 
-                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 not coerced_vals:
+                        continue
+
+                    if op_hint == "in":
+                        predicates.append(col.in_(coerced_vals))
+                    else:
+                        predicates.append(col.notin_(coerced_vals))
+                    continue
 
                 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(_use_ilike(v) for v in vals) and _is_text_type(coltype):
+                    use_ilike_any = op_hint == "ilike" or (
+                        _is_text_type(coltype) and any(_looks_like_wildcard(str(v)) for v in vals)
+                    )
+
+                    if use_ilike_any 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 v is not None]
+                        coerced = [_coerce_value(coltype, v) for v in vals]
+                        coerced = [c for c in coerced if c is not None]
                         if not coerced:
                             continue
 
                         if op_hint == "eq":
                             predicates.append(col.in_(coerced))
                         elif op_hint == "ne":
-                            predicates.append(or_(*[col != v for v in coerced]))
+                            predicates.append(col.notin_(coerced))
                         elif op_hint == "gt":
                             predicates.append(or_(*[col > v for v in coerced]))
                         elif op_hint == "gte":
@@ -234,17 +307,22 @@ def _apply_filters(pagination, entity, query):
                             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):
+                    use_ilike = op_hint == "ilike" or (
+                        _is_text_type(coltype) and isinstance(value, str) and _looks_like_wildcard(value)
+                    )
+
+                    if use_ilike and _is_text_type(coltype):
                         pattern = _to_sql_like_pattern(str(value))
                         predicates.append(col.ilike(pattern))
                     else:
-                        v = coerce(value)
+                        v = _coerce_value(coltype, value)
                         if v is None:
                             if op_hint in {"eq", "ilike"}:
                                 predicates.append(col.is_(None))
-                            else:
-                                continue
+                            elif op_hint == "ne":
+                                predicates.append(col.is_not(None))
                         else:
                             if op_hint == "eq":
                                 predicates.append(col == v)
@@ -271,11 +349,38 @@ def _apply_filters(pagination, entity, query):
         if predicates:
             final_pred = or_(and_(*predicates), include_pred)
         else:
-            final_pred = or_(and_(*[1 == 1]), include_pred)
+            final_pred = or_(and_(*[literal(True)]), include_pred)
         return query.filter(final_pred)
 
     if predicates:
         query = query.filter(and_(*predicates))
+
+    return query
+
+
+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:
+        for sort in pagination.sort:
+            field = sort["field"]
+            order = sort["order"]
+
+            if hasattr(entity, field):
+                column = getattr(entity, field)
+                if order == "asc":
+                    order_clauses.append(asc(column))
+                else:
+                    order_clauses.append(desc(column))
+
+    if order_clauses:
+        query = query.order_by(*order_clauses)
     return query
 
 

nlbone/adapters/db/postgres/types.py

@@ -1,7 +1,9 @@
-from sqlalchemy.types import TypeDecorator, BigInteger
+from sqlalchemy.types import BigInteger, TypeDecorator
+
 
 class BaseIntegerIdType(TypeDecorator):
     """Maps BaseId subclasses <-> BIGINT transparently (Infrastructure-only)."""
+
     impl = BigInteger
     cache_ok = True
 

nlbone/adapters/http_clients/pricing/pricing_service.py

@@ -86,7 +86,7 @@ class PricingService:
         r = self._client.post(
             f"{self._base_url}/price/calculate",
             params={"response": response},
-            headers={'X-Api-Key': get_settings().PRICING_API_SECRET, 'X-Client-Id': get_settings().KEYCLOAK_CLIENT_ID},
+            headers={"X-Api-Key": get_settings().PRICING_API_SECRET, "X-Client-Id": get_settings().KEYCLOAK_CLIENT_ID},
             # headers=auth_headers(self._token_provider.get_access_token()),
             json=body,
             timeout=self._timeout,

nlbone/adapters/i18n/engine.py

@@ -0,0 +1,28 @@
+from typing import Dict, Optional
+
+from nlbone.core.ports.translation import TranslationPort
+from nlbone.utils.context import get_locale
+
+from .loaders import BaseLoader
+
+
+class I18nAdapter(TranslationPort):
+    def __init__(self, loader: BaseLoader, default_locale: str = "fa"):
+        self.default_locale = default_locale
+        self._translations: Dict[str, Dict[str, str]] = loader.load()
+
+    def translate(self, key: str, locale: Optional[str] = None, **kwargs) -> str:
+        target_locale = locale or get_locale() or self.default_locale
+
+        locale_data = self._translations.get(target_locale, {})
+        text = locale_data.get(key)
+
+        if text is None:
+            text = self._translations.get(self.default_locale, {}).get(key, key)
+
+        if kwargs:
+            try:
+                return text.format(**kwargs)
+            except KeyError:
+                pass
+        return text

nlbone/adapters/i18n/loaders.py

@@ -0,0 +1,58 @@
+import json
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class BaseLoader(ABC):
+    @abstractmethod
+    def load(self) -> Dict[str, Dict[str, str]]:
+        pass
+
+
+class JSONFileLoader(BaseLoader):
+    def __init__(self, locales_path: str):
+        self.locales_path = locales_path
+
+    def load(self) -> Dict[str, Dict[str, str]]:
+        translations: Dict[str, Dict[str, str]] = {}
+
+        path_obj = Path(self.locales_path)
+
+        if not path_obj.exists():
+            logger.warning(f"Locales directory not found at: {self.locales_path}")
+            return translations
+
+        for file_path in path_obj.glob("*.json"):
+            try:
+                lang_code = file_path.stem
+
+                with open(file_path, "r", encoding="utf-8") as f:
+                    data = json.load(f)
+
+                flat_data = self._flatten_dict(data)
+                translations[lang_code] = flat_data
+
+                logger.info(f"Loaded locale '{lang_code}' with {len(flat_data)} keys.")
+
+            except json.JSONDecodeError as e:
+                logger.error(f"Invalid JSON format in {file_path}: {e}")
+            except Exception as e:
+                logger.error(f"Error loading locale {file_path}: {e}")
+
+        return translations
+
+    def _flatten_dict(self, d: Dict[str, Any], parent_key: str = "", sep: str = ".") -> Dict[str, str]:
+        items = []
+        for k, v in d.items():
+            new_key = f"{parent_key}{sep}{k}" if parent_key else k
+
+            if isinstance(v, dict):
+                items.extend(self._flatten_dict(v, new_key, sep=sep).items())
+            else:
+                items.append((new_key, str(v)))
+
+        return dict(items)

nlbone/adapters/i18n/locales/fa.json

@@ -0,0 +1,12 @@
+{
+  "general": {
+    "welcome": "خوش آمدید",
+    "buttons": {
+      "save": "ذخیره",
+      "cancel": "لغو"
+    }
+  },
+  "auth": {
+    "otp_sent": "کد تایید برای {mobile} ارسال شد."
+  }
+}

nlbone/adapters/messaging/rabbitmq.py

@@ -1,16 +1,12 @@
 import json
-from typing import Mapping, Any, Optional
+from typing import Any, Mapping, Optional
 
 import aio_pika
 from aio_pika import ExchangeType, Message
 
-
-import json
-from typing import Mapping, Any, Optional
-import aio_pika
-from aio_pika import ExchangeType, Message
 from nlbone.core.ports.event_bus import EventBus
 
+
 class RabbitMQEventBus(EventBus):
     def __init__(self, amqp_url: str, declare_passive: bool = True, exchange_type: ExchangeType = ExchangeType.DIRECT):
         self._amqp_url = amqp_url

nlbone/adapters/outbox/outbox_consumer.py

@@ -12,11 +12,11 @@ from nlbone.core.ports import UnitOfWork
 
 
 async def outbox_stream(
-        repo: AsyncOutboxRepository,
-        *,
-        batch_size: int = 100,
-        idle_sleep: float = 1.0,
-        stop_event: Optional[asyncio.Event] = None,
+    repo: AsyncOutboxRepository,
+    *,
+    batch_size: int = 100,
+    idle_sleep: float = 1.0,
+    stop_event: Optional[asyncio.Event] = None,
 ) -> AsyncIterator[Outbox]:
     """
     Yields Outbox one-by-one. If none available, waits (idle_sleep) and tries again.
@@ -35,10 +35,10 @@ async def outbox_stream(
 
 @asynccontextmanager
 async def process_message(
-        repo: AsyncOutboxRepository,
-        msg: Outbox,
-        *,
-        backoff: timedelta = timedelta(seconds=30),
+    repo: AsyncOutboxRepository,
+    msg: Outbox,
+    *,
+    backoff: timedelta = timedelta(seconds=30),
 ):
     """
     Usage:
@@ -57,12 +57,12 @@ async def process_message(
 
 
 async def process_batch(
-        repo: AsyncOutboxRepository,
-        messages: Iterable[Outbox],
-        *,
-        backoff: timedelta = timedelta(seconds=30),
-        concurrency: int = 1,
-        handler=None,
+    repo: AsyncOutboxRepository,
+    messages: Iterable[Outbox],
+    *,
+    backoff: timedelta = timedelta(seconds=30),
+    concurrency: int = 1,
+    handler=None,
 ):
     """
     Optional helper: run a handler concurrently on a batch.
@@ -80,12 +80,12 @@ async def process_batch(
 
 
 def outbox_stream_sync(
-        repo: OutboxRepository,
-        *,
-        topics : list[str] = None,
-        batch_size: int = 100,
-        idle_sleep: float = 1.0,
-        stop_flag: Optional[callable] = None,
+    repo: OutboxRepository,
+    *,
+    topics: list[str] = None,
+    batch_size: int = 100,
+    idle_sleep: float = 1.0,
+    stop_flag: Optional[callable] = None,
 ) -> Iterator[Outbox]:
     while True:
         if stop_flag and stop_flag():