nlbone 0.1.33__tar.gz → 0.1.35__tar.gz

{nlbone-0.1.33 → nlbone-0.1.35}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.1.33
+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.33 → nlbone-0.1.35}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.1.33"
+version = "0.1.35"
 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.33 → nlbone-0.1.35}/src/nlbone/adapters/http_clients/uploadchi.py

@@ -1,27 +1,35 @@
 from __future__ import annotations
 import json
 from typing import Any, Optional
+from urllib.parse import urlparse, urlunparse
+
 import httpx
+import requests
 
 from nlbone.core.ports.files import FileServicePort
 from nlbone.config.settings import get_settings
 
+
 class UploadchiError(RuntimeError):
     def __init__(self, status: int, detail: Any | None = None):
         super().__init__(f"Uploadchi HTTP {status}: {detail}")
         self.status = status
         self.detail = detail
 
+
 def _resolve_token(explicit: str | None) -> str | None:
     if explicit is not None:
         return explicit
     s = get_settings()
     return s.UPLOADCHI_TOKEN.get_secret_value() if s.UPLOADCHI_TOKEN else None
 
+
 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)
@@ -29,6 +37,7 @@ def _build_list_query(limit: int, offset: int, filters: dict[str, Any] | None, s
         q["sort"] = ",".join([f"{f}:{o}" for f, o in sort])
     return q
 
+
 def _filename_from_cd(cd: str | None, fallback: str) -> str:
     if not cd:
         return fallback
@@ -36,49 +45,62 @@ def _filename_from_cd(cd: str | None, fallback: str) -> str:
         return cd.split("filename=", 1)[1].strip("\"'")
     return fallback
 
+
+def _normalize_https_base(url: str) -> str:
+    p = urlparse(url.strip())
+    p = p._replace(scheme="https")  # enforce https
+    if p.path.endswith("/"):
+        p = p._replace(path=p.path.rstrip("/"))
+    return str(urlunparse(p))
+
+
 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 = base_url or str(s.UPLOADCHI_BASE_URL)
+        self._base_url = _normalize_https_base(base_url or str(s.UPLOADCHI_BASE_URL))
         self._timeout = timeout_seconds or float(s.HTTP_TIMEOUT_SECONDS)
-        self._client = client or httpx.Client(base_url=self._base_url, timeout=self._timeout, follow_redirects=True)
+        self._client = client or requests.session()
 
     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()
-        r = self._client.post("", files=files, data=data, headers=_auth_headers(tok))
+        r = self._client.post(self._base_url, files=files, data=data, headers=_auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = self._client.post(f"/{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("", params=q, headers=_auth_headers(tok))
+        r = self._client.get(self._base_url, params=q, headers=_auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def get_file(self, file_id: int, token: str | None = None) -> dict:
         tok = _resolve_token(token)
-        r = self._client.get(f"/{file_id}", headers=_auth_headers(tok))
+        r = self._client.get(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
     def download_file(self, file_id: int, token: str | None = None) -> tuple[bytes, str, str]:
         tok = _resolve_token(token)
-        r = self._client.get(f"/{file_id}/download", headers=_auth_headers(tok))
+        r = self._client.get(f"{self._base_url}/{file_id}/download", headers=_auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, r.text)
         filename = _filename_from_cd(r.headers.get("content-disposition"), fallback=f"file-{file_id}")
@@ -87,6 +109,6 @@ class UploadchiClient(FileServicePort):
 
     def delete_file(self, file_id: int, token: str | None = None) -> None:
         tok = _resolve_token(token)
-        r = self._client.delete(f"/{file_id}", headers=_auth_headers(tok))
+        r = self._client.delete(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
         if r.status_code not in (204, 200):
             raise UploadchiError(r.status_code, r.text)

nlbone-0.1.35/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.35/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.35/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.35/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.35/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.35/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.33/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()