nlbone 0.4.0__py3-none-any.whl → 0.4.2__py3-none-any.whl

nlbone/config/logging.py

@@ -1,43 +1,33 @@
-from __future__ import annotations
-
 import json
 import logging
 import sys
 from datetime import datetime, timezone
-from typing import Any, MutableMapping, Optional
-
-import contextvars
+from logging.config import dictConfig
+from typing import Any, MutableMapping
 
 from nlbone.config.settings import get_settings
+from nlbone.utils.context import current_context_dict
+from nlbone.utils.redactor import PiiRedactor
 
-# Context variable for request/correlation id
-_request_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
-    "request_id", default=None
-)
-
-
-def set_request_id(request_id: Optional[str]) -> None:
-    """
-    Set request id in context (e.g., per incoming HTTP request).
-    Example:
-        from nlbone.config.logging import set_request_id
-        set_request_id("abc-123")
-    """
-    _request_id_var.set(request_id)
-
-
-class RequestIdFilter(logging.Filter):
-    """Injects request_id from contextvars into record."""
+settings = get_settings()
 
+# ---------- Filters ----------
+class ContextFilter(logging.Filter):
     def filter(self, record: logging.LogRecord) -> bool:
-        rid = _request_id_var.get()
-        # attach as record attribute; formatters can use %(request_id)s
-        record.request_id = rid or "-"
+        ctx = current_context_dict()
+        record.request_id = ctx.get("request_id")
+        record.user_id = ctx.get("user_id")
+        record.ip = ctx.get("ip")
+        record.user_agent = ctx.get("user_agent")
         return True
 
-
+# ---------- Formatter ----------
 class JsonFormatter(logging.Formatter):
-    """Minimal JSON formatter with ISO8601 timestamps."""
+    RESERVED = {
+        "args","asctime","created","exc_info","exc_text","filename","funcName","levelname","levelno",
+        "lineno","module","msecs","message","msg","name","pathname","process","processName",
+        "relativeCreated","stack_info","thread","threadName",
+    }
 
     def format(self, record: logging.LogRecord) -> str:
         payload: MutableMapping[str, Any] = {
@@ -45,101 +35,77 @@ class JsonFormatter(logging.Formatter):
             "level": record.levelname,
             "logger": record.name,
             "msg": record.getMessage(),
-            "request_id": getattr(record, "request_id", "-"),
+            "request_id": getattr(record, "request_id", None),
+            "user_id": getattr(record, "user_id", None),
+            "ip": getattr(record, "ip", None),
+            "user_agent": getattr(record, "user_agent", None),
         }
 
-        # Add extras (fields set via logger.bind-like approach: logger.info("x", extra={"k": "v"}))
-        # Python's logging puts extras into record.__dict__ directly.
-        for key, value in record.__dict__.items():
-            if key in {
-                "args",
-                "asctime",
-                "created",
-                "exc_info",
-                "exc_text",
-                "filename",
-                "funcName",
-                "levelname",
-                "levelno",
-                "lineno",
-                "module",
-                "msecs",
-                "message",
-                "msg",
-                "name",
-                "pathname",
-                "process",
-                "processName",
-                "relativeCreated",
-                "stack_info",
-                "thread",
-                "threadName",
-            }:
+        for k, v in record.__dict__.items():
+            if k in self.RESERVED or k in payload:
                 continue
-            # Avoid overriding our top-level keys
-            if key in payload:
-                continue
-            payload[key] = value
+            payload[k] = v
 
-        # Attach exception info if present
         if record.exc_info:
-            payload["exc_type"] = record.exc_info[0].__name__ if record.exc_info[0] else None
+            etype = record.exc_info[0].__name__ if record.exc_info[0] else None
+            payload["exc_type"] = etype
             payload["exc"] = self.formatException(record.exc_info)
 
         return json.dumps(payload, ensure_ascii=False)
 
-
-def _build_stream_handler(json_enabled: bool, level: int) -> logging.Handler:
-    handler = logging.StreamHandler(stream=sys.stdout)
-    handler.setLevel(level)
-    handler.addFilter(RequestIdFilter())
-    if json_enabled:
-        handler.setFormatter(JsonFormatter())
-    else:
-        # human-friendly text format
-        fmt = (
-            "%(asctime)s | %(levelname)s | %(name)s | rid=%(request_id)s | %(message)s"
+class PlainFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__(
+            fmt="%(asctime)s | %(levelname)s | %(name)s | "
+                "req=%(request_id)s user=%(user_id)s ip=%(ip)s | %(message)s",
+            datefmt="%Y-%m-%dT%H:%M:%S%z",
         )
-        datefmt = "%Y-%m-%dT%H:%M:%S%z"
-        handler.setFormatter(logging.Formatter(fmt=fmt, datefmt=datefmt))
-    return handler
-
-
-def setup_logging(
-    level: Optional[int] = None,
-    json_enabled: Optional[bool] = None,
-    silence_uvicorn_access: bool = True,
-) -> None:
-    """
-    Configure root logging once at app start.
-    Idempotent: safe to call multiple times.
-
-    Example:
-        from nlbone.config.logging import setup_logging
-        setup_logging()
-    """
-    settings = get_settings()
-    lvl = level if level is not None else getattr(logging, settings.LOG_LEVEL, logging.INFO)
-    json_logs = settings.LOG_JSON if json_enabled is None else json_enabled
 
-    # Clear existing handlers
-    root = logging.getLogger()
-    for h in list(root.handlers):
-        root.removeHandler(h)
-
-    root.setLevel(lvl)
-    root.addHandler(_build_stream_handler(json_logs, lvl))
+# ---------- Setup ----------
+def setup_logging(*, log_json: bool=settings.LOG_JSON, log_level: str =settings.LOG_LEVEL,
+                  log_file: str | None = None, silence_uvicorn_access: bool = True):
+    handlers = {
+        "console": {
+            "class": "logging.StreamHandler",
+            "stream": sys.stdout,
+            "filters": ["ctx", "pii"],
+            "formatter": "json" if log_json else "plain",
+        }
+    }
+    if log_file:
+        handlers["file"] = {
+            "class": "logging.handlers.RotatingFileHandler",
+            "filename": log_file,
+            "maxBytes": 10 * 1024 * 1024,
+            "backupCount": 5,
+            "filters": ["ctx", "pii"],
+            "formatter": "json" if log_json else "plain",
+        }
 
-    # Common noisy loggers (optional tweaks)
-    for noisy in ("asyncio", "httpx"):
-        logging.getLogger(noisy).setLevel(logging.WARNING)
+    dictConfig({
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "ctx": {"()": ContextFilter},
+            "pii": {"()": PiiRedactor},
+        },
+        "formatters": {
+            "json": {"()": JsonFormatter},
+            "plain": {"()": PlainFormatter},
+        },
+        "handlers": handlers,
+        "root": {
+            "level": log_level,
+            "handlers": list(handlers.keys()),
+        },
+    })
+
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
 
-    # Uvicorn / FastAPI compatibility (if used later)
-    # - application logs go through root
-    # - format access logs separately or silence them
     uvicorn_error = logging.getLogger("uvicorn.error")
     uvicorn_error.handlers = []
-    uvicorn_error.propagate = True  # bubble up to root
+    uvicorn_error.propagate = True
 
     uvicorn_access = logging.getLogger("uvicorn.access")
     if silence_uvicorn_access:
@@ -149,12 +115,5 @@ def setup_logging(
         uvicorn_access.handlers = []
         uvicorn_access.propagate = True
 
-
-def get_logger(name: str) -> logging.Logger:
-    """
-    Helper to get a configured logger.
-    Example:
-        logger = get_logger(__name__)
-        logger.info("hello", extra={"user_id": "42"})
-    """
-    return logging.getLogger(name)
+def get_logger(name: str | None = None) -> logging.Logger:
+    return logging.getLogger(name or "app")

nlbone/config/settings.py

@@ -2,7 +2,8 @@ import os
 from functools import lru_cache
 from pathlib import Path
 from typing import Literal
-from pydantic import AnyHttpUrl, Field, SecretStr, AliasChoices
+
+from pydantic import AnyHttpUrl, Field, SecretStr
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
@@ -22,7 +23,7 @@ def _guess_env_file() -> str | None:
             return str(f)
 
 
-def _is_production_env() -> bool:
+def is_production_env() -> bool:
     raw = os.getenv("NLBONE_ENV") or os.getenv("ENV") or os.getenv("ENVIRONMENT")
     if not raw:
         return False
@@ -34,9 +35,7 @@ class Settings(BaseSettings):
     # App
     # ---------------------------
     PORT: int = 8000
-    ENV: Literal["local", "dev", "staging", "prod"] = Field(default="local",
-                                                            validation_alias=AliasChoices("NLBONE_ENV", "ENV",
-                                                                                          "ENVIRONMENT"))
+    ENV: Literal["local", "dev", "staging", "prod"] = Field(default="local")
     DEBUG: bool = Field(default=False)
     LOG_LEVEL: Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"] = Field(default="INFO")
     LOG_JSON: bool = Field(default=True)
@@ -49,23 +48,15 @@ class Settings(BaseSettings):
     # ---------------------------
     # Keycloak / Auth
     # ---------------------------
-    KEYCLOAK_SERVER_URL: AnyHttpUrl = Field(default="https://keycloak.local/auth",
-                                            validation_alias=AliasChoices("NLBONE_KEYCLOAK_SERVER_URL",
-                                                                          "KEYCLOAK_SERVER_URL"))
-    KEYCLOAK_REALM_NAME: str = Field(default="numberland",
-                                     validation_alias=AliasChoices("NLBONE_KEYCLOAK_REALM_NAME", "KEYCLOAK_REALM_NAME"))
-    KEYCLOAK_CLIENT_ID: str = Field(default="nlbone",
-                                    validation_alias=AliasChoices("NLBONE_KEYCLOAK_CLIENT_ID", "KEYCLOAK_CLIENT_ID"))
-    KEYCLOAK_CLIENT_SECRET: SecretStr = Field(default=SecretStr("dev-secret"),
-                                              validation_alias=AliasChoices("NLBONE_KEYCLOAK_CLIENT_SECRET",
-                                                                            "KEYCLOAK_CLIENT_SECRET"))
+    KEYCLOAK_SERVER_URL: AnyHttpUrl = Field(default="https://keycloak.local/auth")
+    KEYCLOAK_REALM_NAME: str = Field(default="numberland")
+    KEYCLOAK_CLIENT_ID: str = Field(default="nlbone")
+    KEYCLOAK_CLIENT_SECRET: SecretStr = Field(default=SecretStr("dev-secret"))
 
     # ---------------------------
     # Database
     # ---------------------------
-    POSTGRES_DB_DSN: str = Field(default="postgresql+asyncpg://user:pass@localhost:5432/nlbone",
-                                 validation_alias=AliasChoices("NLBONE_POSTGRES_DB_DSN",
-                                                               "POSTGRES_DB_DSN", "DATABASE_URL", "DB_DSN"))
+    POSTGRES_DB_DSN: str = Field(default="postgresql+asyncpg://user:pass@localhost:5432/nlbone")
     DB_ECHO: bool = Field(default=False)
     DB_POOL_SIZE: int = Field(default=5)
     DB_MAX_OVERFLOW: int = Field(default=10)
@@ -74,6 +65,7 @@ class Settings(BaseSettings):
     # Messaging / Cache
     # ---------------------------
     REDIS_URL: str = Field(default="redis://localhost:6379/0")
+
     # --- Event bus / Outbox ---
     EVENT_BUS_BACKEND: Literal["inmemory"] = Field(default="inmemory")
     OUTBOX_ENABLED: bool = Field(default=False)
@@ -83,13 +75,17 @@ class Settings(BaseSettings):
     # UPLOADCHI
     # ---------------------------
     UPLOADCHI_BASE_URL: AnyHttpUrl = Field(default="https://uploadchi.numberland.ir/v1/files")
-    UPLOADCHI_TOKEN: SecretStr | None = Field(
-        default=None,
-        validation_alias=AliasChoices("NLBONE_UPLOADCHI_TOKEN", "UPLOADCHI_TOKEN"),
-    )
+    UPLOADCHI_TOKEN: SecretStr = Field(default="")
+
+    # ---------------------------
+    # PERCOLATE
+    # ---------------------------
+    ELASTIC_PERCOLATE_URL: str =  Field(default="http://localhost:9200")
+    ELASTIC_PERCOLATE_USER: str = Field(default="")
+    ELASTIC_PERCOLATE_PASS: SecretStr = Field(default="")
 
     model_config = SettingsConfigDict(
-        env_prefix="NLBONE_",
+        env_prefix="",
         env_file=None,
         env_file_encoding="utf-8",
         extra="ignore",
@@ -97,7 +93,7 @@ class Settings(BaseSettings):
 
     @classmethod
     def load(cls, env_file: str | None = None) -> "Settings":
-        if _is_production_env():
+        if is_production_env():
             return cls()
         return cls(_env_file=env_file or _guess_env_file())
 

nlbone/container.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
+
 from typing import Any, Mapping, Optional
 
 from dependency_injector import containers, providers
 
-from nlbone.adapters.db.sqlalchemy import SqlAlchemyUnitOfWork, AsyncUnitOfWork
-from nlbone.adapters.db.sqlalchemy.engine import get_sync_session_factory, get_async_session_factory
+from nlbone.adapters.auth.keycloak import KeycloakAuthService
+from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork
+from nlbone.adapters.db.postgres.engine import get_async_session_factory, get_sync_session_factory
 from nlbone.adapters.http_clients.uploadchi import UploadchiClient
 from nlbone.adapters.http_clients.uploadchi_async import UploadchiAsyncClient
-from nlbone.adapters.auth.keycloak import KeycloakAuthService
 from nlbone.adapters.messaging import InMemoryEventBus
 from nlbone.core.ports import EventBusPort
-from nlbone.core.ports.files import FileServicePort, AsyncFileServicePort
+from nlbone.core.ports.files import AsyncFileServicePort, FileServicePort
 
 
 class Container(containers.DeclarativeContainer):
@@ -21,7 +22,7 @@ class Container(containers.DeclarativeContainer):
 
     # --- UoW ---
     uow = providers.Factory(SqlAlchemyUnitOfWork, session_factory=sync_session_factory)
-    async_uow = providers.Factory(AsyncUnitOfWork, session_factory=async_session_factory)
+    async_uow = providers.Factory(AsyncSqlAlchemyUnitOfWork, session_factory=async_session_factory)
 
     # --- Event bus ---
     event_bus: providers.Singleton[EventBusPort] = providers.Singleton(InMemoryEventBus)

nlbone/core/application/base_worker.py

@@ -0,0 +1,36 @@
+import asyncio
+from abc import ABC, abstractmethod
+from typing import Any
+
+from nlbone.utils.time import TimeUtility
+
+
+class BaseWorker(ABC):
+    def __init__(self, name, interval):
+        self.name = name
+        self.interval = interval
+
+    async def run(self, *args, **kwargs):
+        while True:
+            try:
+                print(f"[>>] {self.name} is running. Current time: {TimeUtility.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+
+                await self.process(*args, **kwargs)
+
+                print(
+                    f"[>>] {self.name} is sleeping. Current time: {TimeUtility.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+                )
+                await asyncio.sleep(self.interval)
+
+            except asyncio.CancelledError:
+                print(f"[!!] {self.name} task was cancelled. Shutting down gracefully.\n")
+                break
+
+            except Exception as e:
+                print(f"[!!]An error occurred in {self.name}:\n{str(e)}\n")
+                print(f"[!!] Retrying in {self.interval / 2} seconds...\n")
+                await asyncio.sleep(self.interval / 2)
+
+    @abstractmethod
+    async def process(self, *args, **kwargs) -> Any:
+        pass

nlbone/core/application/events.py

@@ -1,7 +1,9 @@
 from typing import Iterable, Sequence
+
 from nlbone.core.domain.base import AggregateRoot, DomainEvent
 from nlbone.core.ports.event_bus import EventBusPort
 
+
 def collect_events(*aggregates: Iterable[AggregateRoot]) -> list[DomainEvent]:
     events: list[DomainEvent] = []
     for agg in aggregates:
@@ -12,5 +14,7 @@ def collect_events(*aggregates: Iterable[AggregateRoot]) -> list[DomainEvent]:
                 events.extend(a.pull_events())
     return events
 
+
 def publish_events(bus: EventBusPort, events: Sequence[DomainEvent]) -> None:
-    if events: bus.publish(events)
+    if events:
+        bus.publish(events)

nlbone/core/application/use_case.py

@@ -1,10 +1,12 @@
 from typing import Protocol, TypeVar
 
+InT = TypeVar("InT")
+OutT = TypeVar("OutT")
 
-InT = TypeVar("InT"); OutT = TypeVar("OutT")
 
 class UseCase(Protocol):
     def __call__(self, command: InT) -> OutT: ...
 
+
 class AsyncUseCase(Protocol):
     async def __call__(self, command: InT) -> OutT: ...

nlbone/core/domain/base.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from typing import Any, Generic, List, TypeVar
@@ -13,6 +14,7 @@ class DomainError(Exception):
 @dataclass(frozen=True)
 class DomainEvent:
     """Immutable domain event."""
+
     occurred_at: datetime = datetime.now(timezone.utc)
 
     @property
@@ -22,6 +24,7 @@ class DomainEvent:
 
 class ValueObject:
     """Base for value objects (immutable in practice)."""
+
     def __eq__(self, other: Any) -> bool:
         return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 
@@ -35,6 +38,7 @@ class Entity(Generic[TId]):
 
 class AggregateRoot(Entity[TId]):
     """Aggregate root with domain event collection."""
+
     def __init__(self, *args, **kwargs) -> None:
         self._domain_events: List[DomainEvent] = []
 

nlbone/core/domain/models.py

@@ -0,0 +1,38 @@
+import uuid
+from datetime import datetime
+from sqlalchemy import String, DateTime, Index, Text
+from sqlalchemy import JSON as SA_JSON
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.sql import func
+
+from nlbone.adapters.db import Base
+
+try:
+    from sqlalchemy.dialects.postgresql import JSONB, UUID
+    JSONType = JSONB
+    UUIDType = UUID(as_uuid=True)
+except Exception:
+    JSONType = SA_JSON
+    UUIDType = String(36)
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_logs"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUIDType, primary_key=True, default=uuid.uuid4)
+    entity: Mapped[str] = mapped_column(String(100), nullable=False)
+    entity_id: Mapped[str] = mapped_column(String(64), nullable=False)
+    operation: Mapped[str] = mapped_column(String(10), nullable=False)  # INSERT/UPDATE/DELETE
+    changes: Mapped[dict | None] = mapped_column(JSONType, nullable=True)
+
+    actor_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    request_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    ip: Mapped[str | None] = mapped_column(String(45), nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+
+    __table_args__ = (
+        Index("ix_audit_entity_entityid", "entity", "entity_id"),
+        Index("ix_audit_created_at", "created_at"),
+    )

nlbone/core/ports/__init__.py

@@ -1,5 +1,5 @@
 from .auth import AuthService
-from .repo import Repository, AsyncRepository
-from .files import FileServicePort, AsyncFileServicePort
-from .uow import UnitOfWork, AsyncUnitOfWork
 from .event_bus import EventBusPort
+from .files import AsyncFileServicePort, FileServicePort
+from .repo import AsyncRepository, Repository
+from .uow import AsyncUnitOfWork, UnitOfWork

nlbone/core/ports/auth.py

@@ -1,5 +1,6 @@
 from typing import Protocol, runtime_checkable
 
+
 @runtime_checkable
 class AuthService(Protocol):
     def has_access(self, token: str, permissions: list[str]) -> bool: ...

nlbone/core/ports/event_bus.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
+
 from typing import Callable, Iterable, Protocol
+
 from nlbone.core.domain.base import DomainEvent
 
+
 class EventBusPort(Protocol):
     def publish(self, events: Iterable[DomainEvent]) -> None: ...
     def subscribe(self, event_name: str, handler: Callable[[DomainEvent], None]) -> None: ...

nlbone/core/ports/files.py

@@ -1,20 +1,41 @@
 from __future__ import annotations
-from typing import Protocol, runtime_checkable, AsyncIterator, Any
+
+from typing import Any, AsyncIterator, Protocol, runtime_checkable
+
 
 @runtime_checkable
 class FileServicePort(Protocol):
-    def upload_file(self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None) -> dict: ...
+    def upload_file(
+        self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None
+    ) -> dict: ...
     def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None: ...
-    def list_files(self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None, sort: list[tuple[str, str]] | None = None, token: str | None = None) -> dict: ...
+    def list_files(
+        self,
+        limit: int = 10,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        sort: list[tuple[str, str]] | None = None,
+        token: str | None = None,
+    ) -> dict: ...
     def get_file(self, file_id: int, token: str | None = None) -> dict: ...
     def download_file(self, file_id: int, token: str | None = None) -> tuple[bytes, str, str]: ...
     def delete_file(self, file_id: int, token: str | None = None) -> None: ...
 
+
 @runtime_checkable
 class AsyncFileServicePort(Protocol):
-    async def upload_file(self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None) -> dict: ...
+    async def upload_file(
+        self, file_bytes: bytes, filename: str, params: dict[str, Any] | None = None, token: str | None = None
+    ) -> dict: ...
     async def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None: ...
-    async def list_files(self, limit: int = 10, offset: int = 0, filters: dict[str, Any] | None = None, sort: list[tuple[str, str]] | None = None, token: str | None = None) -> dict: ...
+    async def list_files(
+        self,
+        limit: int = 10,
+        offset: int = 0,
+        filters: dict[str, Any] | None = None,
+        sort: list[tuple[str, str]] | None = None,
+        token: str | None = None,
+    ) -> dict: ...
     async def get_file(self, file_id: int, token: str | None = None) -> dict: ...
     async def download_file(self, file_id: int, token: str | None = None) -> tuple[AsyncIterator[bytes], str, str]: ...
     async def delete_file(self, file_id: int, token: str | None = None) -> None: ...

nlbone/core/ports/repo.py

@@ -1,16 +1,19 @@
 from __future__ import annotations
-from typing import Iterable, Optional, Protocol, TypeVar, List
+
+from typing import Iterable, List, Optional, Protocol, TypeVar
 
 T = TypeVar("T")
 
+
 class Repository(Protocol[T]):  # ← نه Protocol, Generic[T]
     def get(self, id) -> Optional[T]: ...
     def add(self, obj: T) -> None: ...
     def remove(self, obj: T) -> None: ...
     def list(self, *, limit: int | None = None, offset: int = 0) -> Iterable[T]: ...
 
+
 class AsyncRepository(Protocol[T]):
     async def get(self, id) -> Optional[T]: ...
     def add(self, obj: T) -> None: ...
     async def remove(self, obj: T) -> None: ...
-    async def list(self, *, limit: int | None = None, offset: int = 0) -> List[T]: ...
+    async def list(self, *, limit: int | None = None, offset: int = 0) -> List[T]: ...

nlbone/core/ports/uow.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
+
 from typing import Protocol, runtime_checkable
 
+
 @runtime_checkable
 class UnitOfWork(Protocol):
     def __enter__(self) -> "UnitOfWork": ...
@@ -8,6 +10,7 @@ class UnitOfWork(Protocol):
     def commit(self) -> None: ...
     def rollback(self) -> None: ...
 
+
 @runtime_checkable
 class AsyncUnitOfWork(Protocol):
     async def __aenter__(self) -> "AsyncUnitOfWork": ...

nlbone/interfaces/api/dependencies/__init__.py

@@ -1,3 +1,11 @@
-from .db import get_session, get_async_session
-from .auth import has_access, client_has_access, current_client_id, current_user_id, current_request, user_authenticated
-from .uow import get_uow, get_async_uow
+from .async_auth import client_has_access, current_request, current_user_id, has_access, user_authenticated
+from .auth import (  # noqa: F811
+    client_has_access,
+    current_client_id,
+    current_request,
+    current_user_id,
+    has_access,
+    user_authenticated,
+)
+from .db import get_async_session, get_session
+from .uow import get_async_uow, get_uow