nlbone 0.1.34__tar.gz → 0.1.36__tar.gz

{nlbone-0.1.34 → nlbone-0.1.36}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.1.34
+Version: 0.1.36
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4.0
+Requires-Dist: dependency-injector>=4.48.1
 Requires-Dist: fastapi>=0.116
 Requires-Dist: httpx>=0.27
 Requires-Dist: psycopg>=3.2.9

{nlbone-0.1.34 → nlbone-0.1.36}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.1.34"
+version = "0.1.36"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,7 +21,8 @@ dependencies = [
     "starlette>=0.47",
     "uvicorn>=0.35",
     "sqlalchemy>=2.0",
-    "psycopg>=3.2.9"
+    "psycopg>=3.2.9",
+    "dependency-injector>=4.48.1"
 ]
 
 [project.optional-dependencies]

nlbone-0.1.36/src/nlbone/container.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from typing import Any, Mapping, Optional
+
+from dependency_injector import containers, providers
+
+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.core.ports.files import FileServicePort, AsyncFileServicePort
+
+
+class Container(containers.DeclarativeContainer):
+    config = providers.Configuration(strict=False)
+
+    auth: providers.Singleton[KeycloakAuthService] = providers.Singleton(KeycloakAuthService, settings=config)
+    file_service: providers.Singleton[FileServicePort] = providers.Singleton(UploadchiClient)
+    afiles_service: providers.Singleton[AsyncFileServicePort] = providers.Singleton(UploadchiAsyncClient)
+
+
+def create_container(settings: Optional[Any] = None) -> Container:
+    c = Container()
+    if settings is not None:
+        if hasattr(settings, "model_dump"):
+            c.config.from_dict(settings.model_dump())  # Pydantic v2
+        elif hasattr(settings, "dict"):
+            c.config.from_dict(settings.dict())  # Pydantic v1
+        elif isinstance(settings, Mapping):
+            c.config.from_dict(dict(settings))
+        else:
+            c.config.override(settings)
+    return c

nlbone-0.1.36/src/nlbone/interfaces/api/middleware/__init__.py

@@ -0,0 +1,3 @@
+from .authentication import AuthenticationMiddleware
+from .add_request_context import AddRequestContextMiddleware
+from .access_log import AccessLogMiddleware

nlbone-0.1.36/src/nlbone/interfaces/api/middleware/access_log.py

@@ -0,0 +1,30 @@
+import time
+from typing import Callable
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+from nlbone.config.logging import get_logger
+
+logger = get_logger(__name__)
+
+class AccessLogMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: Callable):
+        start = time.perf_counter()
+        status_code = None
+        try:
+            response = await call_next(request)
+            status_code = getattr(response, "status_code", None)
+            return response
+        except Exception:
+            status_code = 500
+            raise
+        finally:
+            dur_ms = int((time.perf_counter() - start) * 1000)
+            logger.info({
+                "event": "access",
+                "method": request.method,
+                "path": request.url.path,
+                "status": status_code,
+                "duration_ms": dur_ms,
+                "query": request.url.query,
+            })

nlbone-0.1.36/src/nlbone/interfaces/api/middleware/add_request_context.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+from typing import Optional
+from uuid import uuid4
+
+from starlette.datastructures import Headers
+from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
+from starlette.requests import Request
+
+from nlbone import config
+from nlbone.utils.context import request_ctx, request_id_ctx, bind_context, reset_context
+
+
+def mock_request(user=None, token: Optional[str] = None):
+    request = Request({
+        "type": "http",
+        "headers": Headers({"User-Agent": "Testing-Agent"}).raw,
+        "client": {"host": "192.168.1.1", "port": 80},
+        "method": "GET",
+        "path": "/__test__",
+    })
+    request.state.user = user
+    request.state.token = token
+    return request
+
+
+def current_request() -> Optional[Request]:
+    req = request_ctx.get()
+    if config.ENV == 'test' and req is None:
+        return mock_request()
+    return req
+
+
+def current_request_id() -> Optional[str]:
+    return request_id_ctx.get()
+
+
+class AddRequestContextMiddleware(BaseHTTPMiddleware):
+    async def dispatch(self, request: Request, call_next: RequestResponseEndpoint):
+        incoming_req_id = request.headers.get("X-Request-ID")
+        req_id = incoming_req_id or str(uuid4())
+
+        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")
+
+        tokens = bind_context(request=request, request_id=req_id, user_id=user_id, ip=ip, user_agent=ua)
+        try:
+            response = await call_next(request)
+            response.headers.setdefault("X-Request-ID", req_id)
+            return response
+        finally:
+            reset_context(tokens)

nlbone-0.1.36/src/nlbone/interfaces/api/middleware/authentication.py

@@ -0,0 +1,56 @@
+from typing import Optional, Callable, Union
+from fastapi import Request
+from starlette.middleware.base import BaseHTTPMiddleware
+
+try:
+    from dependency_injector import providers
+    ProviderType = providers.Provider  # type: ignore
+except Exception:
+    ProviderType = object
+
+from nlbone.core.ports.auth import AuthService
+
+
+def _to_factory(auth: Union[AuthService, Callable[[], AuthService], ProviderType]):
+    try:
+        from dependency_injector import providers as _p  # type: ignore
+        if isinstance(auth, _p.Provider):
+            return auth
+    except Exception:
+        pass
+    if callable(auth) and not hasattr(auth, "verify_token"):
+        return auth
+    return lambda: auth
+
+
+class AuthenticationMiddleware(BaseHTTPMiddleware):
+    def __init__(self, app, auth: Union[AuthService, Callable[[], AuthService], ProviderType]):
+        super().__init__(app)
+        self._get_auth = _to_factory(auth)
+
+    async def dispatch(self, request: Request, call_next):
+        request.state.client_id = request.headers.get("X-Client-Id")
+        request.state.user_id = None
+        request.state.token = None
+
+        token: Optional[str] = None
+        authz = request.headers.get("Authorization")
+        if authz:
+            try:
+                scheme, token = authz.split(" ", 1)
+                if scheme.lower() != "bearer":
+                    token = None
+            except ValueError:
+                token = None
+
+        if token:
+            request.state.token = token
+            try:
+                service: AuthService = self._get_auth()
+                data = service.verify_token(token)
+                if data:
+                    request.state.user_id = data.get("user_id")
+            except Exception:
+                pass
+
+        return await call_next(request)

nlbone-0.1.36/src/nlbone/utils/context.py

@@ -0,0 +1,42 @@
+from contextvars import ContextVar
+from typing import Any, Optional
+
+request_ctx: ContextVar[Any | None] = ContextVar("request", default=None)
+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)
+
+def bind_context(*, request: Any | None = None, request_id: str | None = None,
+                 user_id: str | None = None, ip: str | None = None,
+                 user_agent: str | None = None) -> dict[ContextVar, Any]:
+    tokens: dict[ContextVar, Any] = {}
+    if request is not None:
+        tokens[request_ctx] = request_ctx.set(request)
+    if request_id is not None:
+        tokens[request_id_ctx] = request_id_ctx.set(request_id)
+    if user_id is not None:
+        tokens[user_id_ctx] = user_id_ctx.set(user_id)
+    if ip is not None:
+        tokens[ip_ctx] = ip_ctx.set(ip)
+    if user_agent is not None:
+        tokens[user_agent_ctx] = user_agent_ctx.set(user_agent)
+    return tokens
+
+def reset_context(tokens: dict[ContextVar, Any]):
+    for var, token in tokens.items():
+        var.reset(token)
+
+def current_request():
+    return request_ctx.get()
+
+def current_request_id() -> Optional[str]:
+    return request_id_ctx.get()
+
+def current_context_dict() -> dict[str, Any]:
+    return {
+        "request_id": request_id_ctx.get(),
+        "user_id": user_id_ctx.get(),
+        "ip": ip_ctx.get(),
+        "user_agent": user_agent_ctx.get(),
+    }

nlbone-0.1.36/src/nlbone/utils/time.py

@@ -0,0 +1,5 @@
+from datetime import datetime, timezone
+
+
+def now() -> datetime:
+    return datetime.now(timezone.utc)

nlbone-0.1.34/src/nlbone/container.py

@@ -1,13 +0,0 @@
-from nlbone.adapters.http_clients.uploadchi import UploadchiClient
-from nlbone.adapters.http_clients.uploadchi_async import UploadchiAsyncClient
-from nlbone.config.settings import Settings
-from nlbone.adapters.auth.keycloak import KeycloakAuthService
-from nlbone.core.ports.files import FileServicePort, AsyncFileServicePort
-
-
-class Container:
-    def __init__(self, settings: Settings | None = None):
-        self.settings = settings or Settings()
-        self.auth: KeycloakAuthService = KeycloakAuthService(self.settings)
-        self.file_service: FileServicePort = UploadchiClient()
-        self.afiles_service: AsyncFileServicePort = UploadchiAsyncClient()