nlbone 0.7.22__py3-none-any.whl → 0.7.24__py3-none-any.whl

nlbone/adapters/outbox/outbox_repo.py

@@ -36,7 +36,7 @@ class SQLAlchemyOutboxRepository(OutboxRepository):
         return row
 
     def enqueue_many(
-            self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
+        self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
     ) -> List[Outbox]:
         rows = [
             Outbox(topic=t, payload=p, headers=headers or {}, available_at=available_at or self._now())
@@ -46,8 +46,9 @@ class SQLAlchemyOutboxRepository(OutboxRepository):
         self.session.flush()
         return [r for r in rows]
 
-    def claim_batch(self, *, topics: list[str] = None, limit: int = 100, now: Optional[datetime] = None) -> List[
-        Outbox]:
+    def claim_batch(
+        self, *, topics: list[str] = None, limit: int = 100, now: Optional[datetime] = None
+    ) -> List[Outbox]:
         now = now or self._now()
         # Select candidates eligible to process
         stmt = (
@@ -113,7 +114,7 @@ class SQLAlchemyAsyncOutboxRepository(AsyncOutboxRepository):
         return datetime.now(timezone.utc)
 
     async def enqueue(
-            self, topic: str, payload: Dict[str, Any], *, headers=None, key=None, available_at=None
+        self, topic: str, payload: Dict[str, Any], *, headers=None, key=None, available_at=None
     ) -> Outbox:
         row = Outbox(
             topic=topic,
@@ -127,7 +128,7 @@ class SQLAlchemyAsyncOutboxRepository(AsyncOutboxRepository):
         return row
 
     async def enqueue_many(
-            self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
+        self, items: Iterable[Tuple[str, Dict[str, Any]]], *, headers=None, available_at=None
     ) -> List[Outbox]:
         rows = [
             Outbox(topic=t, payload=p, headers=headers or {}, available_at=available_at or self._now())

nlbone/adapters/snowflake.py

@@ -10,9 +10,9 @@ class Snowflake:
     DATACENTER_ID_BITS = 5
     SEQUENCE_BITS = 12
 
-    MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1      # 31
+    MAX_WORKER_ID = (1 << WORKER_ID_BITS) - 1  # 31
     MAX_DATACENTER_ID = (1 << DATACENTER_ID_BITS) - 1  # 31
-    SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1       # 4095
+    SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1  # 4095
 
     WORKER_ID_SHIFT = SEQUENCE_BITS
     DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS
@@ -58,12 +58,15 @@ class Snowflake:
 
             self.last_ts = ts
 
-            id64 = ((ts - self.EPOCH) << self.TIMESTAMP_SHIFT) | \
-                   (self.datacenter_id << self.DATACENTER_ID_SHIFT) | \
-                   (self.worker_id << self.WORKER_ID_SHIFT) | \
-                   self.sequence
+            id64 = (
+                ((ts - self.EPOCH) << self.TIMESTAMP_SHIFT)
+                | (self.datacenter_id << self.DATACENTER_ID_SHIFT)
+                | (self.worker_id << self.WORKER_ID_SHIFT)
+                | self.sequence
+            )
             return id64
 
+
 setting = get_settings()
 _DC_ID = int(setting.SNOWFLAKE_DATACENTER_ID)
 _WORKER_ID = int(setting.SNOWFLAKE_WORKER_ID)

nlbone/adapters/ticketing/client.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional
+from typing import Optional
 
 from pydantic import BaseModel
 
@@ -28,12 +28,17 @@ class TicketingClient:
         self._exchange = settings.RABBITMQ_TICKETING_EXCHANGE
         self._rk_create_v1 = settings.RABBITMQ_TICKETING_ROUTING_KEY_CREATE_V1
 
-    async def create_ticket(self, payload: CreateTicketIn, created_by_id: int, *,
-                            override_exchange: Optional[str] = None,
-                            override_routing_key: Optional[str] = None) -> None:
+    async def create_ticket(
+        self,
+        payload: CreateTicketIn,
+        created_by_id: int,
+        *,
+        override_exchange: Optional[str] = None,
+        override_routing_key: Optional[str] = None,
+    ) -> None:
         exchange = override_exchange or self._exchange
         routing_key = override_routing_key or self._rk_create_v1
         payload = payload.model_dump()
-        payload.update({'created_by_id': created_by_id})
+        payload.update({"created_by_id": created_by_id})
         print(payload)
         await self._bus.publish(exchange=exchange, routing_key=routing_key, payload=payload)

nlbone/config/settings.py

@@ -3,7 +3,7 @@ from functools import lru_cache
 from pathlib import Path
 from typing import Literal
 
-from pydantic import AnyHttpUrl, Field, SecretStr, AliasChoices
+from pydantic import AliasChoices, AnyHttpUrl, Field, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -43,7 +43,7 @@ class Settings(BaseSettings):
     LOG_LEVEL: Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"] = Field(default="INFO")
     LOG_JSON: bool = Field(default=True)
 
-    SNOWFLAKE_WORKER_ID : int = Field(default=1)
+    SNOWFLAKE_WORKER_ID: int = Field(default=1)
     SNOWFLAKE_DATACENTER_ID: int = Field(default=1)
 
     AUDIT_DEFAULT_ENABLE: bool = False
@@ -60,9 +60,9 @@ class Settings(BaseSettings):
     KEYCLOAK_REALM_NAME: str = Field(default="numberland")
     KEYCLOAK_CLIENT_ID: str = Field(default="nlbone")
     KEYCLOAK_CLIENT_SECRET: SecretStr = Field(default=SecretStr("dev-secret"))
-    PRICING_API_SECRET: str = ''
+    PRICING_API_SECRET: str = ""
 
-    AUTH_SERVICE_URL:  AnyHttpUrl = Field(default="https://auth.numberland.ir")
+    AUTH_SERVICE_URL: AnyHttpUrl = Field(default="https://auth.numberland.ir")
     CLIENT_ID: str = Field(default="", validation_alias=AliasChoices("KEYCLOAK_CLIENT_ID"))
     CLIENT_SECRET: SecretStr = Field(default="", validation_alias=AliasChoices("KEYCLOAK_CLIENT_SECRET"))
 

nlbone/container.py

@@ -6,8 +6,6 @@ from dependency_injector import containers, providers
 from pydantic_settings import BaseSettings
 
 from nlbone.adapters.auth.auth_service import AuthService as AuthService_IMP
-from nlbone.core.ports.auth import AuthService
-from nlbone.adapters.auth.keycloak import KeycloakAuthService
 from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.adapters.cache.async_redis import AsyncRedisCache
 from nlbone.adapters.cache.memory import InMemoryCache
@@ -16,6 +14,9 @@ from nlbone.adapters.db.postgres.engine import get_async_session_factory, get_sy
 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.i18n.engine import I18nAdapter
+from nlbone.adapters.i18n.loaders import JSONFileLoader
+from nlbone.core.ports.auth import AuthService
 from nlbone.core.ports.cache import AsyncCachePort, CachePort
 from nlbone.core.ports.files import AsyncFileServicePort, FileServicePort
 
@@ -54,6 +55,8 @@ class Container(containers.DeclarativeContainer):
         redis=providers.Singleton(AsyncRedisCache, url=config.REDIS_URL),
     )
 
+    translator = I18nAdapter(loader=JSONFileLoader(locales_path="path/to/locales"), default_locale="fa")
+
 
 def create_container(settings: Optional[BaseSettings | Dict] = None) -> Container:
     c = Container()

nlbone/core/domain/base.py

@@ -4,11 +4,9 @@ from _decimal import Decimal
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Generic, List, TypeVar, Callable, ClassVar
+from typing import Any, Callable, ClassVar, Generic, List, TypeVar
 from uuid import uuid4
 
-from pydantic import BaseModel
-
 from nlbone.adapters.snowflake import SNOWFLAKE
 
 TId = TypeVar("TId")
@@ -18,12 +16,10 @@ class DomainError(Exception):
     """Base domain exception."""
 
 
-
 class Message:
     pass
 
 
-
 class DomainEvent(Message):
     """Immutable domain event."""
 
@@ -84,9 +80,9 @@ class BaseEnum(Enum):
     pass
 
 
-
 ID = TypeVar("ID", bound="BaseId")
 
+
 @dataclass(frozen=True)
 class BaseId(ValueObject):
     value: int
@@ -118,4 +114,4 @@ class BaseId(ValueObject):
         return cls(v)
 
     def __repr__(self):
-        return f"<{self.value}>"
+        return f"<{self.value}>"

nlbone/core/domain/models.py

@@ -1,6 +1,6 @@
 import enum
 import uuid
-from datetime import datetime, timezone, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, Optional
 
 from sqlalchemy import JSON, DateTime, Index, Integer, String, Text
@@ -80,5 +80,6 @@ class Outbox(Base):
         self.status = OutboxStatus.PUBLISHED
         self.next_attempt_at = None
 
+
 def to_outbox_row(evt) -> Outbox:
     return Outbox(topic=evt.topic, payload=evt.__dict__)

nlbone/core/ports/outbox.py

@@ -8,29 +8,29 @@ from nlbone.core.domain.models import Outbox, OutboxStatus
 
 class OutboxRepository(Protocol):
     def enqueue(
-            self,
-            topic: str,
-            payload: Dict[str, Any],
-            *,
-            headers: Optional[Dict[str, Any]] = None,
-            key: Optional[str] = None,
-            available_at: Optional[datetime] = None,
+        self,
+        topic: str,
+        payload: Dict[str, Any],
+        *,
+        headers: Optional[Dict[str, Any]] = None,
+        key: Optional[str] = None,
+        available_at: Optional[datetime] = None,
     ) -> Outbox: ...
 
     def enqueue_many(
-            self,
-            items: Iterable[Tuple[str, Dict[str, Any]]],
-            *,
-            headers: Optional[Dict[str, Any]] = None,
-            available_at: Optional[datetime] = None,
+        self,
+        items: Iterable[Tuple[str, Dict[str, Any]]],
+        *,
+        headers: Optional[Dict[str, Any]] = None,
+        available_at: Optional[datetime] = None,
     ) -> List[Outbox]: ...
 
     def claim_batch(
-            self,
-            *,
-            topics: list[str] = None,
-            limit: int = 100,
-            now: Optional[datetime] = None,
+        self,
+        *,
+        topics: list[str] = None,
+        limit: int = 100,
+        now: Optional[datetime] = None,
     ) -> List[Outbox]: ...
 
     def mark_published(self, ids: Iterable[int]) -> None: ...
@@ -42,28 +42,28 @@ class OutboxRepository(Protocol):
 
 class AsyncOutboxRepository(Protocol):
     async def enqueue(
-            self,
-            topic: str,
-            payload: Dict[str, Any],
-            *,
-            headers: Optional[Dict[str, Any]] = None,
-            key: Optional[str] = None,
-            available_at: Optional[datetime] = None,
+        self,
+        topic: str,
+        payload: Dict[str, Any],
+        *,
+        headers: Optional[Dict[str, Any]] = None,
+        key: Optional[str] = None,
+        available_at: Optional[datetime] = None,
     ) -> Outbox: ...
 
     async def enqueue_many(
-            self,
-            items: Iterable[Tuple[str, Dict[str, Any]]],
-            *,
-            headers: Optional[Dict[str, Any]] = None,
-            available_at: Optional[datetime] = None,
+        self,
+        items: Iterable[Tuple[str, Dict[str, Any]]],
+        *,
+        headers: Optional[Dict[str, Any]] = None,
+        available_at: Optional[datetime] = None,
     ) -> List[Outbox]: ...
 
     async def claim_batch(
-            self,
-            *,
-            limit: int = 100,
-            now: Optional[datetime] = None,
+        self,
+        *,
+        limit: int = 100,
+        now: Optional[datetime] = None,
     ) -> List[Outbox]: ...
 
     async def mark_published(self, ids: Iterable[int]) -> None: ...

nlbone/core/ports/translation.py

@@ -0,0 +1,8 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class TranslationPort(ABC):
+    @abstractmethod
+    def translate(self, key: str, locale: Optional[str] = None, **kwargs) -> str:
+        pass

nlbone/interfaces/api/dependencies/async_auth.py

@@ -1,10 +1,11 @@
 import functools
 
-from .auth import client_has_access_func
 from nlbone.adapters.auth import KeycloakAuthService
 from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
 from nlbone.utils.context import current_request
 
+from .auth import client_has_access_func
+
 
 async def current_user_id() -> int:
     user_id = current_request().state.user_id

nlbone/interfaces/api/dependencies/auth.py

@@ -6,12 +6,14 @@ from nlbone.config.settings import get_settings
 from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
 from nlbone.utils.context import current_request
 
+
 @functools.lru_cache()
 def bypass_authz() -> bool:
-    if get_settings().ENV != 'prod':
+    if get_settings().ENV != "prod":
         return True
     return False
 
+
 def current_user_id() -> int:
     user_id = current_request().state.user_id
     if user_id is not None:

nlbone/interfaces/api/dependencies/client_credential.py

@@ -1,11 +1,10 @@
 import asyncio
-import functools
 from typing import Callable
 
 from makefun import wraps as mf_wraps
 
 from nlbone.adapters.auth.auth_service import AuthService
-from nlbone.interfaces.api.exceptions import UnauthorizedException, ForbiddenException
+from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
 from nlbone.utils.context import current_request
 
 
@@ -28,6 +27,7 @@ def client_has_access(*, permissions=None):
         is_async_func = asyncio.iscoroutinefunction(func)
 
         if is_async_func:
+
             @mf_wraps(func)
             async def aw(*args, **kwargs):
                 client_has_access_func(permissions=permissions)
@@ -41,4 +41,5 @@ def client_has_access(*, permissions=None):
             return func(*args, **kwargs)
 
         return sw
+
     return deco

nlbone/interfaces/api/middleware/add_request_context.py

@@ -45,8 +45,9 @@ class AddRequestContextMiddleware(BaseHTTPMiddleware):
         user_id = getattr(getattr(request, "state", None), "user_id", None) or request.headers.get("X-User-Id")
         ip = request.client.host if request.client else None
         ua = request.headers.get("user-agent")
+        locale = request.headers.get("Accept-Language")
 
-        tokens = bind_context(request=request, request_id=req_id, user_id=user_id, ip=ip, user_agent=ua)
+        tokens = bind_context(request=request, request_id=req_id, user_id=user_id, ip=ip, user_agent=ua, locale=locale)
         try:
             response = await call_next(request)
             response.headers.setdefault("X-Request-ID", req_id)

nlbone/interfaces/api/middleware/authentication.py

@@ -3,8 +3,8 @@ from typing import Callable, Optional, Union
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
-from nlbone.config.settings import get_settings
 from nlbone.adapters.auth.auth_service import AuthService
+from nlbone.config.settings import get_settings
 
 try:
     from dependency_injector import providers
@@ -50,8 +50,11 @@ def authenticate_admin_user(request, auth_service):
         except Exception:
             pass
 
+
 def authenticate_user(request):
-    token = request.cookies.get("access_token") or request.cookies.get("j_token") or request.headers.get("Authorization")
+    token = (
+        request.cookies.get("access_token") or request.cookies.get("j_token") or request.headers.get("Authorization")
+    )
     if request.headers.get("Authorization"):
         scheme, token = request.headers.get("Authorization").split(" ", 1)
 
@@ -75,11 +78,11 @@ class AuthenticationMiddleware(BaseHTTPMiddleware):
         request.state.client_id = None
         request.state.user_id = None
         request.state.token = None
-        if request.headers.get('X-Client-Id') and request.headers.get("X-Api-Key"):
+        if request.headers.get("X-Client-Id") and request.headers.get("X-Api-Key"):
             if request.headers.get("X-Api-Key") == get_settings().PRICING_API_SECRET:
                 request.state.client_id = request.headers.get("X-Client-Id")
                 return await call_next(request)
-        if request.headers.get('X-Client-Id') == 'website' and request.headers.get("Authorization"):
+        if request.headers.get("X-Client-Id") == "website" and request.headers.get("Authorization"):
             authenticate_user(request)
         elif request.cookies.get("access_token"):
             authenticate_user(request)

nlbone/interfaces/api/pagination/offset_base.py

@@ -26,7 +26,7 @@ class PaginateRequest:
         self.filters = self._parse_filters(filters or "")
         self.include = []
         try:
-            self.include = [{item.split(':')[0]: item.split(':')[1]} for item in include.split(",")]
+            self.include = [{item.split(":")[0]: item.split(":")[1]} for item in include.split(",")]
         except:
             pass
         self.include_ids: List[int] = ([int(x) for x in include.split(",") if x.strip().isdigit()] if include else [])[

nlbone/interfaces/api/schema/base_response_model.py

@@ -1,16 +1,19 @@
 from typing import Any
+
 from pydantic import BaseModel, ConfigDict, model_serializer
 
 from nlbone.core.domain.base import BaseId
 
 EXCLUDE_NONE = "exclude_none"
 
+
 def convert_decimal_to_string(v: Any) -> Any:
     """Converts a value to string if it's a large integer (over the safe limit)."""
     if isinstance(v, int) and v > 9007199254740991:
         return str(v)
     return v
 
+
 class BaseResponseModel(BaseModel):
     model_config = ConfigDict(
         from_attributes=True,

nlbone/interfaces/cli/ticket.py

@@ -1,29 +1,32 @@
 import asyncio
+
 import typer
 
-from nlbone.adapters.ticketing.client import TicketingClient, CreateTicketIn
+from nlbone.adapters.ticketing.client import CreateTicketIn, TicketingClient
 
 app = typer.Typer(add_completion=False)
 
+
 @app.command("create")
 def send_sample():
     payload = CreateTicketIn(
-        assignee_id= "153",
-        category_id= 2,
-        channel= "site_chat",
-        direction= "incoming",
-        entity_id= "153",
-        entity_type= "user",
-        message= "سلام خوبی",
-        priority= "medium",
-        product_id= 0,
-        status= "open",
-        title= "پشتیبانی فنی (ثبت نام و لاگین)",
-        user_id= 153,
+        assignee_id="153",
+        category_id=2,
+        channel="site_chat",
+        direction="incoming",
+        entity_id="153",
+        entity_type="user",
+        message="سلام خوبی",
+        priority="medium",
+        product_id=0,
+        status="open",
+        title="پشتیبانی فنی (ثبت نام و لاگین)",
+        user_id=153,
     )
     client = TicketingClient()
     asyncio.run(client.create_ticket(payload, created_by_id=995836))
     print("Ticket message published (or logged if Noop).")
 
+
 if __name__ == "__main__":
     app()

nlbone/utils/context.py

@@ -6,6 +6,7 @@ request_id_ctx: ContextVar[str | None] = ContextVar("request_id", default=None)
 user_id_ctx: ContextVar[str | None] = ContextVar("user_id", default=None)
 ip_ctx: ContextVar[str | None] = ContextVar("ip", default=None)
 user_agent_ctx: ContextVar[str | None] = ContextVar("user_agent", default=None)
+_current_locale: ContextVar[str] = ContextVar("current_locale", default="en")
 
 
 def bind_context(
@@ -15,6 +16,7 @@ def bind_context(
     user_id: str | None = None,
     ip: str | None = None,
     user_agent: str | None = None,
+    locale: str | None = None,
 ) -> dict[ContextVar, Any]:
     tokens: dict[ContextVar, Any] = {}
     if request is not None:
@@ -27,6 +29,8 @@ def bind_context(
         tokens[ip_ctx] = ip_ctx.set(ip)
     if user_agent is not None:
         tokens[user_agent_ctx] = user_agent_ctx.set(user_agent)
+    if locale is not None:
+        tokens[_current_locale] = _current_locale.set(locale)
     return tokens
 
 
@@ -50,3 +54,7 @@ def current_context_dict() -> dict[str, Any]:
         "ip": ip_ctx.get(),
         "user_agent": user_agent_ctx.get(),
     }
+
+
+def get_locale():
+    return _current_locale.get()

nlbone/utils/flatten_sqlalchemy_result.py

@@ -0,0 +1,26 @@
+from typing import List, Any
+from sqlalchemy import Row
+
+
+def flatten_sqlalchemy_result(items: List[Any]) -> List[Any]:
+    """
+    Converts a list of SQLAlchemy Rows (tuples) into a flat list of entities
+    with extra fields injected as attributes.
+    """
+    if not items:
+        return []
+
+    if not isinstance(items[0], Row):
+        return items
+
+    normalized = []
+    for row in items:
+        entity = row[0]
+
+        for key, value in row._mapping.items():
+            if not isinstance(value, type(entity)):
+                setattr(entity, key, value)
+
+        normalized.append(entity)
+
+    return normalized

nlbone/utils/http.py

@@ -12,7 +12,7 @@ def auth_headers(token: str | None) -> dict[str, str]:
 
 
 def build_list_query(
-        limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
+    limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
 ) -> dict[str, Any]:
     q: dict[str, Any] = {"limit": limit, "offset": offset}
     if filters:

{nlbone-0.7.22.dist-info → nlbone-0.7.24.dist-info}/METADATA

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