nlbone 0.6.0__py3-none-any.whl → 0.6.9__py3-none-any.whl

nlbone/adapters/__init__.py

@@ -0,0 +1 @@
+import nlbone.adapters.db.postgres.audit

nlbone/adapters/auth/keycloak.py

@@ -75,4 +75,4 @@ class KeycloakAuthService(AuthService):
     def client_has_access(self, token: str, permissions: list[str], allowed_clients: set[str] | None = None) -> bool:
         if not self.is_client_token(token, allowed_clients):
             return False
-        return self.has_access(token, permissions)
+        return self.has_access(token, permissions)

nlbone/adapters/auth/token_provider.py

@@ -1,6 +1,6 @@
 import threading
 import time
-from typing import Optional, Dict, Any
+from typing import Any, Dict, Optional
 
 from nlbone.adapters.auth.keycloak import KeycloakAuthService
 

nlbone/adapters/cache/async_redis.py

@@ -1,14 +1,20 @@
 import asyncio
 import json
 import os
-from typing import Optional, Iterable, Any, Mapping, Sequence, List
+from typing import Any, Iterable, Mapping, Optional, Sequence
 
 from redis.asyncio import Redis
+
 from nlbone.core.ports.cache import AsyncCachePort
 
 
-def _nsver_key(ns: str) -> str: return f"nsver:{ns}"
-def _tag_key(tag: str) -> str: return f"tag:{tag}"
+def _nsver_key(ns: str) -> str:
+    return f"nsver:{ns}"
+
+
+def _tag_key(tag: str) -> str:
+    return f"tag:{tag}"
+
 
 class AsyncRedisCache(AsyncCachePort):
     def __init__(self, url: str, *, invalidate_channel: str | None = None):
@@ -36,7 +42,9 @@ class AsyncRedisCache(AsyncCachePort):
         fk = await self._full_key(key)
         return await self._r.get(fk)
 
-    async def set(self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+    async def set(
+        self, key: str, value: bytes, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         fk = await self._full_key(key)
         if ttl is None:
             await self._r.set(fk, value)
@@ -66,8 +74,9 @@ class AsyncRedisCache(AsyncCachePort):
         fks = [await self._full_key(k) for k in keys]
         return await self._r.mget(fks)
 
-    async def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None,
-                   tags: Optional[Iterable[str]] = None) -> None:
+    async def mset(
+        self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         pipe = self._r.pipeline()
         if ttl is None:
             for k, v in items.items():
@@ -93,8 +102,9 @@ class AsyncRedisCache(AsyncCachePort):
         b = await self.get(key)
         return None if b is None else json.loads(b)
 
-    async def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None,
-                       tags: Optional[Iterable[str]] = None) -> None:
+    async def set_json(
+        self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         await self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
 
         # -------- invalidation --------

nlbone/adapters/cache/memory.py

@@ -1,5 +1,8 @@
-import json, threading, time
-from typing import Optional, Iterable, Any, Mapping, Sequence, Dict, Set
+import json
+import threading
+import time
+from typing import Any, Dict, Iterable, Mapping, Optional, Sequence, Set
+
 from nlbone.core.ports.cache import CachePort
 
 
@@ -12,7 +15,8 @@ class InMemoryCache(CachePort):
 
     def _expired(self, key: str) -> bool:
         v = self._data.get(key)
-        if not v: return True
+        if not v:
+            return True
         _, exp = v
         return exp is not None and time.time() > exp
 
@@ -21,7 +25,8 @@ class InMemoryCache(CachePort):
             self._data.pop(key, None)
 
     def _attach_tags(self, key: str, tags: Optional[Iterable[str]]) -> None:
-        if not tags: return
+        if not tags:
+            return
         for t in tags:
             self._tags.setdefault(t, set()).add(key)
 
@@ -50,17 +55,20 @@ class InMemoryCache(CachePort):
         with self._lock:
             self._gc(key)
             v = self._data.get(key)
-            if not v: return None
+            if not v:
+                return None
             _, exp = v
-            if exp is None: return None
+            if exp is None:
+                return None
             rem = int(exp - time.time())
             return rem if rem >= 0 else 0
 
     def mget(self, keys: Sequence[str]) -> list[Optional[bytes]]:
         return [self.get(k) for k in keys]
 
-    def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None,
-             tags: Optional[Iterable[str]] = None) -> None:
+    def mset(
+        self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         for k, v in items.items():
             self.set(k, v, ttl=ttl, tags=tags)
 
@@ -68,8 +76,9 @@ class InMemoryCache(CachePort):
         b = self.get(key)
         return None if b is None else json.loads(b)
 
-    def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None,
-                 tags: Optional[Iterable[str]] = None) -> None:
+    def set_json(
+        self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
 
     def invalidate_tags(self, tags: Iterable[str]) -> int:
@@ -91,7 +100,8 @@ class InMemoryCache(CachePort):
     def clear_namespace(self, namespace: str) -> int:
         with self._lock:
             keys = [k for k in self._data.keys() if k.startswith(namespace + ":")]
-            for k in keys: self.delete(k)
+            for k in keys:
+                self.delete(k)
             return len(keys)
 
     def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:

nlbone/adapters/cache/pubsub_listener.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
+
 import asyncio
 import json
 from typing import Awaitable, Callable, Optional
+
 from redis.asyncio import Redis
 
+
 async def run_cache_invalidation_listener(
     redis: Redis,
     channel: str = "cache:invalidate",

nlbone/adapters/cache/redis.py

@@ -1,13 +1,22 @@
 from __future__ import annotations
-import json, os, time
-from typing import Optional, Iterable, Any, Mapping, Sequence, List, Set
+
+import json
+import os
+import time
+from typing import Any, Iterable, Mapping, Optional, Sequence
+
 import redis  # redis-py (sync)
+
 from nlbone.core.ports.cache import CachePort
 
 
+def _nsver_key(ns: str) -> str:
+    return f"nsver:{ns}"
+
+
+def _tag_key(tag: str) -> str:
+    return f"tag:{tag}"
 
-def _nsver_key(ns: str) -> str: return f"nsver:{ns}"
-def _tag_key(tag: str) -> str: return f"tag:{tag}"
 
 class RedisCache(CachePort):
     def __init__(self, url: str):
@@ -57,7 +66,9 @@ class RedisCache(CachePort):
         fks = [self._full_key(k) for k in keys]
         return self.r.mget(fks)
 
-    def mset(self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+    def mset(
+        self, items: Mapping[str, bytes], *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         pipe = self.r.pipeline()
         if ttl is None:
             for k, v in items.items():
@@ -77,7 +88,9 @@ class RedisCache(CachePort):
         b = self.get(key)
         return None if b is None else json.loads(b)
 
-    def set_json(self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None) -> None:
+    def set_json(
+        self, key: str, value: Any, *, ttl: Optional[int] = None, tags: Optional[Iterable[str]] = None
+    ) -> None:
         self.set(key, json.dumps(value).encode("utf-8"), ttl=ttl, tags=tags)
 
     def invalidate_tags(self, tags: Iterable[str]) -> int:
@@ -109,8 +122,10 @@ class RedisCache(CachePort):
         while True:
             cursor, keys = self.r.scan(cursor=cursor, match=pattern, count=1000)
             if keys:
-                self.r.delete(*keys); cnt += len(keys)
-            if cursor == 0: break
+                self.r.delete(*keys)
+                cnt += len(keys)
+            if cursor == 0:
+                break
         return cnt
 
     def get_or_set(self, key: str, producer, *, ttl: int, tags=None) -> bytes:

nlbone/adapters/db/__init__.py

@@ -1,4 +1,3 @@
 from .postgres import apply_pagination, get_paginated_response
 from .postgres.base import Base
 from .postgres.engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session
-import nlbone.adapters.db.postgres.audit

nlbone/adapters/db/postgres/audit.py

@@ -1,10 +1,12 @@
 import uuid
 from datetime import date, datetime
+from decimal import Decimal
+from enum import Enum as _Enum
 from typing import Any
-from sqlalchemy import event, inspect as sa_inspect
+
+from sqlalchemy import event
+from sqlalchemy import inspect as sa_inspect
 from sqlalchemy.orm import Session as SASession
-from enum import Enum as _Enum
-from decimal import Decimal
 
 from nlbone.core.domain.models import AuditLog
 from nlbone.utils.context import current_context_dict
@@ -54,8 +56,11 @@ def _ser(val):
 
 
 def _entity_name(obj: Any) -> str:
-    return getattr(getattr(obj, "__table__", None), "name", None) or getattr(obj, "__tablename__",
-                                                                             None) or obj.__class__.__name__
+    return (
+        getattr(getattr(obj, "__table__", None), "name", None)
+        or getattr(obj, "__tablename__", None)
+        or obj.__class__.__name__
+    )
 
 
 def _entity_id(obj: Any) -> str:
@@ -84,13 +89,15 @@ def _changes_for_update(obj: any) -> dict[str, dict[str, any]]:
         except KeyError:
             continue
 
-        hist = state.history                 # History object
+        hist = state.history  # History object
         if hist.has_changes():
             old = hist.deleted[0] if hist.deleted else None
             new = hist.added[0] if hist.added else None
             if old != new:
                 changes[key] = {"old": _ser(old), "new": _ser(new)}
     return changes
+
+
 @event.listens_for(SASession, "before_flush")
 def before_flush(session: SASession, flush_context, instances):
     entries = session.info.setdefault("_audit_entries", [])
@@ -107,11 +114,7 @@ def before_flush(session: SASession, flush_context, instances):
             if key in exclude:
                 continue
             row[key] = _ser(getattr(obj, key, None))
-        entries.append({
-            "obj": obj,
-            "op": "INSERT",
-            "changes": {k: {"old": None, "new": v} for k, v in row.items()}
-        })
+        entries.append({"obj": obj, "op": "INSERT", "changes": {k: {"old": None, "new": v} for k, v in row.items()}})
 
     # UPDATE
     for obj in session.dirty:

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
@@ -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/adapters/db/redis/client.py

@@ -9,10 +9,7 @@ class RedisClient:
     @classmethod
     def get_client(cls) -> redis.Redis:
         if cls._client is None:
-            cls._client = redis.from_url(
-                get_settings().REDIS_URL,
-                decode_responses=True
-            )
+            cls._client = redis.from_url(get_settings().REDIS_URL, decode_responses=True)
         return cls._client
 
     @classmethod

nlbone/adapters/http_clients/__init__.py

@@ -1,2 +1,2 @@
-from .uploadchi import UploadchiClient, UploadchiAsyncClient, UploadchiError
-from .pricing import PricingService, CalculatePriceIn, CalculatePriceOut
+from .pricing import CalculatePriceIn, CalculatePriceOut, PricingService
+from .uploadchi import UploadchiAsyncClient, UploadchiClient, UploadchiError

nlbone/adapters/http_clients/pricing/__init__.py

@@ -1 +1 @@
-from .pricing_service import PricingService, CalculatePriceIn, CalculatePriceOut
+from .pricing_service import CalculatePriceIn, CalculatePriceOut, PricingService