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

nlbone/adapters/auth/__init__.py

@@ -1 +1 @@
-from .keycloak import KeycloakAuthService
+from .keycloak import KeycloakAuthService

nlbone/adapters/auth/keycloak.py

@@ -1,7 +1,8 @@
 from keycloak import KeycloakOpenID
 from keycloak.exceptions import KeycloakAuthenticationError
-from nlbone.core.ports.auth import AuthService
+
 from nlbone.config.settings import Settings, get_settings
+from nlbone.core.ports.auth import AuthService
 
 
 class KeycloakAuthService(AuthService):
@@ -70,4 +71,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/db/__init__.py

@@ -1,3 +1,3 @@
-from .sqlalchemy.engine import init_async_engine, async_session, async_ping, init_sync_engine, sync_session, sync_ping
-from .sqlalchemy import get_paginated_response, apply_pagination
+from .sqlalchemy import apply_pagination, get_paginated_response
 from .sqlalchemy.base import Base
+from .sqlalchemy.engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session

nlbone/adapters/db/sqlalchemy/__init__.py

@@ -1,4 +1,4 @@
-from .query_builder import get_paginated_response, apply_pagination
-from .engine import init_sync_engine, init_async_engine, sync_ping, sync_session, async_ping, async_session
-from .repository import SqlAlchemyRepository, AsyncSqlAlchemyRepository
-from .uow import SqlAlchemyUnitOfWork, AsyncSqlAlchemyUnitOfWork
+from .engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session
+from .query_builder import apply_pagination, get_paginated_response
+from .repository import AsyncSqlAlchemyRepository, SqlAlchemyRepository
+from .uow import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork

nlbone/adapters/db/sqlalchemy/base.py

@@ -1,5 +1,3 @@
 from sqlalchemy.orm import declarative_base
 
 Base = declarative_base()
-
-

nlbone/adapters/db/sqlalchemy/engine.py

@@ -1,16 +1,15 @@
 from contextlib import asynccontextmanager, contextmanager
-from typing import Generator, Optional, Any, AsyncGenerator
+from typing import Any, AsyncGenerator, Generator, Optional
 
 from sqlalchemy import create_engine, text
 from sqlalchemy.engine import Engine
-from sqlalchemy.orm import Session, sessionmaker
-
 from sqlalchemy.ext.asyncio import (
     AsyncEngine,
     AsyncSession,
     async_sessionmaker,
     create_async_engine,
 )
+from sqlalchemy.orm import Session, sessionmaker
 
 from nlbone.config.settings import get_settings
 
@@ -117,12 +116,14 @@ def sync_ping() -> None:
     with eng.connect() as conn:
         conn.execute(text("SELECT 1"))
 
+
 def get_async_session_factory() -> async_sessionmaker[AsyncSession]:
     if _async_session_factory is None:
         init_async_engine()
     assert _async_session_factory is not None
     return _async_session_factory
 
+
 def get_sync_session_factory() -> sessionmaker[Session]:
     if _sync_session_factory is None:
         init_sync_engine()

nlbone/adapters/db/sqlalchemy/query_builder.py

@@ -1,12 +1,22 @@
-from typing import Union, Callable, Any, Optional, Type, Sequence
+from typing import Any, Callable, Optional, Sequence, Type, Union
 
 from sqlalchemy import asc, desc, or_
+from sqlalchemy.dialects.postgresql import ENUM as PGEnum
+from sqlalchemy.orm import Query, Session
 from sqlalchemy.orm.interfaces import LoaderOption
 from sqlalchemy.sql.sqltypes import (
-    String, Text, Integer, BigInteger, SmallInteger, Numeric, Float, Boolean, Enum as SAEnum
+    BigInteger,
+    Boolean,
+    Float,
+    Integer,
+    Numeric,
+    SmallInteger,
+    String,
+    Text,
+)
+from sqlalchemy.sql.sqltypes import (
+    Enum as SAEnum,
 )
-from sqlalchemy.orm import Session, Query
-from sqlalchemy.dialects.postgresql import ENUM as PGEnum
 
 from nlbone.interfaces.api.exceptions import UnprocessableEntityException
 from nlbone.interfaces.api.pagination import PaginateRequest, PaginateResponse
@@ -122,12 +132,16 @@ def _apply_filters(pagination, entity, query):
                 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, 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
+                    if vl in {"true", "1", "yes", "y", "t"}:
+                        return True
+                    if vl in {"false", "0", "no", "n", "f"}:
+                        return False
                 return None
             # fallback
             return v
@@ -215,7 +229,8 @@ def _serialize_item(item: Any, output_cls: OutputType) -> Any:
     try:
         obj = output_cls(item)  # type: ignore[call-arg]
         try:
-            from dataclasses import is_dataclass, asdict
+            from dataclasses import asdict, is_dataclass
+
             if is_dataclass(obj):
                 return asdict(obj)
         except Exception:
@@ -252,5 +267,6 @@ def get_paginated_response(
         data = [output_cls.model_validate(r, from_attributes=True).model_dump() for r in rows]
     else:
         data = rows
-    return PaginateResponse(total_count=total_count, data=data, limit=pagination.limit,
-                            offset=pagination.offset).to_dict()
+    return PaginateResponse(
+        total_count=total_count, data=data, limit=pagination.limit, offset=pagination.offset
+    ).to_dict()

nlbone/adapters/db/sqlalchemy/repository.py

@@ -1,10 +1,12 @@
 from __future__ import annotations
-from typing import Generic, Iterable, Optional, Type, TypeVar, List
+
+from typing import Generic, Iterable, List, Optional, Type, TypeVar
 
 from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
-from nlbone.core.ports.repo import Repository, AsyncRepository
+
+from nlbone.core.ports.repo import AsyncRepository, Repository
 
 T = TypeVar("T")
 

nlbone/adapters/db/sqlalchemy/schema.py

@@ -1,18 +1,17 @@
-
 import importlib
 from typing import Sequence
 
 from nlbone.adapters.db.sqlalchemy.base import Base
 from nlbone.adapters.db.sqlalchemy.engine import init_async_engine, init_sync_engine
 
+DEFAULT_MODEL_MODULES: Sequence[str] = ()
 
-DEFAULT_MODEL_MODULES: Sequence[str] = (
-)
 
 def import_model_modules(modules: Sequence[str] | None = None) -> None:
-    for m in (modules or DEFAULT_MODEL_MODULES):
+    for m in modules or DEFAULT_MODEL_MODULES:
         importlib.import_module(m)
 
+
 # --------- Async (SQLAlchemy 2.x) ----------
 async def init_db_async(model_modules: Sequence[str] | None = None) -> None:
     """Create tables using AsyncEngine (dev/test). Prefer Alembic in prod."""
@@ -21,9 +20,10 @@ async def init_db_async(model_modules: Sequence[str] | None = None) -> None:
     async with engine.begin() as conn:
         await conn.run_sync(Base.metadata.create_all)
 
+
 # --------- Sync ----------
 def init_db_sync(model_modules: Sequence[str] | None = None) -> None:
     """Create tables using Sync Engine (dev/test). Prefer Alembic in prod."""
     import_model_modules(model_modules)
     engine = init_sync_engine()
-    Base.metadata.create_all(bind=engine)
+    Base.metadata.create_all(bind=engine)

nlbone/adapters/db/sqlalchemy/uow.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from typing import Optional
 
-from sqlalchemy.ext.asyncio import async_sessionmaker, AsyncSession
+from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from sqlalchemy.orm import Session, sessionmaker
-from nlbone.core.ports.uow import UnitOfWork
+
 from nlbone.core.ports.uow import AsyncUnitOfWork as AsyncUnitOfWorkPort
+from nlbone.core.ports.uow import UnitOfWork
 
 
 class SqlAlchemyUnitOfWork(UnitOfWork):

nlbone/adapters/http_clients/uploadchi.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import json
 from typing import Any, Optional
 from urllib.parse import urlparse, urlunparse
@@ -6,8 +7,8 @@ from urllib.parse import urlparse, urlunparse
 import httpx
 import requests
 
-from nlbone.core.ports.files import FileServicePort
 from nlbone.config.settings import get_settings
+from nlbone.core.ports.files import FileServicePort
 
 
 class UploadchiError(RuntimeError):
@@ -28,8 +29,9 @@ def _auth_headers(token: str | None) -> dict[str, str]:
     return {"Authorization": f"Bearer {token}"} if token else {}
 
 
-def _build_list_query(limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None) -> \
-        dict[str, Any]:
+def _build_list_query(
+    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:
         q["filters"] = json.dumps(filters)
@@ -55,8 +57,12 @@ def _normalize_https_base(url: str) -> str:
 
 
 class UploadchiClient(FileServicePort):
-    def __init__(self, base_url: Optional[str] = None, timeout_seconds: Optional[float] = None,
-                 client: httpx.Client | None = None) -> None:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.Client | None = None,
+    ) -> None:
         s = get_settings()
         self._base_url = _normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
@@ -65,8 +71,9 @@ class UploadchiClient(FileServicePort):
     def close(self) -> None:
         self._client.close()
 
-    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:
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
@@ -77,13 +84,22 @@ class UploadchiClient(FileServicePort):
 
     def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = self._client.post(f"{self._base_url}/{file_id}/commit", headers=_auth_headers(tok),
-                              params={"client_id": client_id} if client_id else None)
+        r = self._client.post(
+            f"{self._base_url}/{file_id}/commit",
+            headers=_auth_headers(tok),
+            params={"client_id": client_id} if client_id else None,
+        )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)
 
-    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:
         tok = _resolve_token(token)
         q = _build_list_query(limit, offset, filters, sort)
         r = self._client.get(self._base_url, params=q, headers=_auth_headers(tok))

nlbone/adapters/http_clients/uploadchi_async.py

@@ -1,22 +1,35 @@
 from __future__ import annotations
-from typing import Any, Optional, AsyncIterator
+
+from typing import Any, AsyncIterator, Optional
+
 import httpx
 
-from nlbone.core.ports.files import AsyncFileServicePort
 from nlbone.config.settings import get_settings
+from nlbone.core.ports.files import AsyncFileServicePort
+
 from .uploadchi import UploadchiError, _auth_headers, _build_list_query, _filename_from_cd, _resolve_token
 
+
 class UploadchiAsyncClient(AsyncFileServicePort):
-    def __init__(self, base_url: Optional[str] = None, timeout_seconds: Optional[float] = None, client: httpx.AsyncClient | None = None) -> None:
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        timeout_seconds: Optional[float] = None,
+        client: httpx.AsyncClient | None = None,
+    ) -> None:
         s = get_settings()
         self._base_url = base_url or str(s.UPLOADCHI_BASE_URL)
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
-        self._client = client or httpx.AsyncClient(base_url=self._base_url, timeout=self._timeout, follow_redirects=True)
+        self._client = client or httpx.AsyncClient(
+            base_url=self._base_url, timeout=self._timeout, follow_redirects=True
+        )
 
     async def aclose(self) -> None:
         await self._client.aclose()
 
-    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:
         tok = _resolve_token(token)
         files = {"file": (filename, file_bytes)}
         data = (params or {}).copy()
@@ -27,11 +40,20 @@ class UploadchiAsyncClient(AsyncFileServicePort):
 
     async def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = await self._client.post(f"/{file_id}/commit", headers=_auth_headers(tok), params={"client_id": client_id} if client_id else None)
+        r = await self._client.post(
+            f"/{file_id}/commit", headers=_auth_headers(tok), params={"client_id": client_id} if client_id else None
+        )
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, await r.aread())
 
-    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:
         tok = _resolve_token(token)
         q = _build_list_query(limit, offset, filters, sort)
         r = await self._client.get("", params=q, headers=_auth_headers(tok))

nlbone/adapters/messaging/event_bus.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
+
 from collections import defaultdict
 from typing import Callable, Dict, Iterable, List
+
 from nlbone.core.domain.base import DomainEvent
 from nlbone.core.ports.event_bus import EventBusPort
 
+
 class InMemoryEventBus(EventBusPort):
     def __init__(self) -> None:
         self._handlers: Dict[str, List[Callable[[DomainEvent], None]]] = defaultdict(list)

nlbone/config/logging.py

@@ -1,19 +1,16 @@
 from __future__ import annotations
 
+import contextvars
 import json
 import logging
 import sys
 from datetime import datetime, timezone
 from typing import Any, MutableMapping, Optional
 
-import contextvars
-
 from nlbone.config.settings import get_settings
 
 # Context variable for request/correlation id
-_request_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar(
-    "request_id", default=None
-)
+_request_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("request_id", default=None)
 
 
 def set_request_id(request_id: Optional[str]) -> None:
@@ -97,9 +94,7 @@ def _build_stream_handler(json_enabled: bool, level: int) -> logging.Handler:
         handler.setFormatter(JsonFormatter())
     else:
         # human-friendly text format
-        fmt = (
-            "%(asctime)s | %(levelname)s | %(name)s | rid=%(request_id)s | %(message)s"
-        )
+        fmt = "%(asctime)s | %(levelname)s | %(name)s | rid=%(request_id)s | %(message)s"
         datefmt = "%Y-%m-%dT%H:%M:%S%z"
         handler.setFormatter(logging.Formatter(fmt=fmt, datefmt=datefmt))
     return handler

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
 
 
@@ -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,10 @@ 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="")
 
     model_config = SettingsConfigDict(
-        env_prefix="NLBONE_",
+        env_prefix="",
         env_file=None,
         env_file_encoding="utf-8",
         extra="ignore",

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.sqlalchemy import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork
+from nlbone.adapters.db.sqlalchemy.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/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/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: ...