nlbone 0.1.34__py3-none-any.whl → 0.1.35__py3-none-any.whl

nlbone/container.py

@@ -1,13 +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.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()
+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/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/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/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/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/utils/time.py

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

{nlbone-0.1.34.dist-info → nlbone-0.1.35.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.1.34
+Version: 0.1.35
 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.dist-info → nlbone-0.1.35.dist-info}/RECORD

@@ -1,5 +1,5 @@
 nlbone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/container.py,sha256=JLEiJSh7vZAl7kBY6bwqtL3IzHFOxhrfreaZDU6K9n0,663
+nlbone/container.py,sha256=KO8y8hfEt0graWhUi-FU_rG-WPckl-uF7H9JGcwEu38,1321
 nlbone/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/auth/__init__.py,sha256=Eh9kWjY1I8vi17gK0oOzBLJwJX_GFuUcJIN7cLU6lJg,41
@@ -48,6 +48,10 @@ nlbone/interfaces/api/routers.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 nlbone/interfaces/api/schemas.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/api/dependencies/__init__.py,sha256=XrTGkHS8xqryfyr8XSm_s9sIzp4E0b44XQ40sVWcKMY,46
 nlbone/interfaces/api/dependencies/db.py,sha256=IqDVq1lcCCxd22FBUg523lVANM_j71BYAQtsbrHc4M8,465
+nlbone/interfaces/api/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/interfaces/api/middleware/access_log.py,sha256=dEjk_m4fyQ72S2xLzDydDoaw2F9Tvmfl_acat1YThE0,972
+nlbone/interfaces/api/middleware/add_request_context.py,sha256=i8EV4BvZyrBcNfU-uTkybr7J7ypYvJq8mXSntM6oel4,1816
+nlbone/interfaces/api/middleware/authentication.py,sha256=-jfV-Ry04qsFd1cJh7KGoGpfnUKIogPF2fK42ZTFgBk,1806
 nlbone/interfaces/api/pagination/__init__.py,sha256=fdTqy5efdYIcUWbK1mVPQMieGd3HV1lZ8vmIhhsuUKs,58
 nlbone/interfaces/api/pagination/offset_base.py,sha256=W0SJ0rHLMIqoyiPEAjnoKqY57LBXEyT5J-_5bS8r-NY,4535
 nlbone/interfaces/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -56,8 +60,9 @@ nlbone/interfaces/cli/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU
 nlbone/interfaces/jobs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/interfaces/jobs/sync_tokens.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/utils/time.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.1.34.dist-info/METADATA,sha256=5mgHF3w38N6ELApJK62fA5G_z_0eM_QSOwWpWkr-_vQ,2256
-nlbone-0.1.34.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nlbone-0.1.34.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.1.34.dist-info/RECORD,,
+nlbone/utils/context.py,sha256=AUiN1jM0ebNMopZQoJSqWTfUHuVrp-HV8x6g7QsbEJ8,1601
+nlbone/utils/time.py,sha256=dC0ucyAmHdNf3wpA_JPinl2VJRubWqx2vcRpJsT3-0k,102
+nlbone-0.1.35.dist-info/METADATA,sha256=7sgZBqyIdOjUc4Gq8LSP_-aZEwIPY9x0BlQinoZAuCo,2299
+nlbone-0.1.35.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nlbone-0.1.35.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.1.35.dist-info/RECORD,,