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

nlbone/interfaces/api/dependencies/async_auth.py

@@ -0,0 +1,61 @@
+import functools
+
+from nlbone.adapters.auth import KeycloakAuthService
+from nlbone.interfaces.api.exceptions import ForbiddenException, UnauthorizedException
+from nlbone.utils.context import current_request
+
+
+async def current_user_id() -> int:
+    user_id = current_request().state.user_id
+    if user_id is not None:
+        return int(user_id)
+    raise UnauthorizedException()
+
+
+async def current_client_id() -> str:
+    request = current_request()
+    if client_id := KeycloakAuthService().get_client_id(request.state.token):
+        return str(client_id)
+    raise UnauthorizedException()
+
+
+def client_has_access(*, permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            request = current_request()
+            if not KeycloakAuthService().client_has_access(request.state.token, permissions=permissions):
+                raise ForbiddenException(f"Forbidden {permissions}")
+
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator
+
+
+def user_authenticated(func):
+    @functools.wraps(func)
+    async def wrapper(*args, **kwargs):
+        if not await current_user_id():
+            raise UnauthorizedException()
+        return await func(*args, **kwargs)
+
+    return wrapper
+
+
+def has_access(*, permissions=None):
+    def decorator(func):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            request = current_request()
+            if not await current_user_id():
+                raise UnauthorizedException()
+            if not KeycloakAuthService().has_access(request.state.token, permissions=permissions):
+                raise ForbiddenException(f"Forbidden {permissions}")
+
+            return await func(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

nlbone/interfaces/api/dependencies/auth.py

@@ -30,15 +30,16 @@ def client_has_access(*, permissions=None):
             return func(*args, **kwargs)
 
         return wrapper
+
     return decorator
 
 
 def user_authenticated(func):
     @functools.wraps(func)
-    async def wrapper(*args, **kwargs):
+    def wrapper(*args, **kwargs):
         if not current_user_id():
             raise UnauthorizedException()
-        return await func(*args, **kwargs)
+        return func(*args, **kwargs)
 
     return wrapper
 
@@ -56,4 +57,5 @@ def has_access(*, permissions=None):
             return func(*args, **kwargs)
 
         return wrapper
-    return decorator
+
+    return decorator

nlbone/interfaces/api/dependencies/db.py

@@ -1,16 +1,18 @@
 from __future__ import annotations
+
 from typing import AsyncGenerator, Generator
 
-from sqlalchemy.orm import Session
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Session
 
-from nlbone.adapters.db.sqlalchemy.engine import async_session, sync_session
+from nlbone.adapters.db.postgres.engine import async_session, sync_session
 
 
 async def get_async_session() -> AsyncGenerator[AsyncSession, None]:
     async with async_session() as s:
         yield s
 
+
 def get_session() -> Generator[Session, None, None]:
     with sync_session() as s:
-        yield s
+        yield s

nlbone/interfaces/api/dependencies/uow.py

@@ -1,11 +1,12 @@
 from __future__ import annotations
+
 from collections.abc import Iterator
 from typing import AsyncIterator
 
 from fastapi import Request
 
-from nlbone.adapters.db.sqlalchemy import AsyncSqlAlchemyUnitOfWork
-from nlbone.core.ports.uow import UnitOfWork, AsyncUnitOfWork
+from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork
+from nlbone.core.ports.uow import AsyncUnitOfWork, UnitOfWork
 
 
 def get_uow(request: Request) -> Iterator[UnitOfWork]:

nlbone/interfaces/api/exception_handlers.py

@@ -1,32 +1,33 @@
 from __future__ import annotations
-from typing import Any, Optional, Mapping
+
+from typing import Any, Mapping, Optional
 from uuid import uuid4
 
 from fastapi import FastAPI, Request
-from fastapi.responses import JSONResponse
+from fastapi import HTTPException as FastAPIHTTPException
 from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
 from pydantic import ValidationError
-from fastapi import HTTPException as FastAPIHTTPException
 from starlette.exceptions import HTTPException as StarletteHTTPException
 
 from .exceptions import BaseHttpException
 
-
 # ---- Helpers ---------------------------------------------------------------
 
+
 def _ensure_trace_id(request: Request) -> str:
     rid = request.headers.get("X-Request-Id") or request.headers.get("X-Trace-Id")
     return rid or str(uuid4())
 
 
 def _json_response(
-        request: Request,
-        status_code: int,
-        *,
-        detail: Any,
-        headers: Optional[Mapping[str, str]] = None,
-        trace_id: Optional[str] = None,
-        extra: Optional[Mapping[str, Any]] = None,
+    request: Request,
+    status_code: int,
+    *,
+    detail: Any,
+    headers: Optional[Mapping[str, str]] = None,
+    trace_id: Optional[str] = None,
+    extra: Optional[Mapping[str, Any]] = None,
 ) -> JSONResponse:
     payload: dict[str, Any] = {"detail": detail}
     if extra:
@@ -44,11 +45,12 @@ def _json_response(
 
 # ---- Public Installer ------------------------------------------------------
 
+
 def install_exception_handlers(
-        app: FastAPI,
-        *,
-        logger: Any = None,
-        expose_server_errors: bool = False,
+    app: FastAPI,
+    *,
+    logger: Any = None,
+    expose_server_errors: bool = False,
 ) -> None:
     @app.exception_handler(BaseHttpException)
     async def _handle_base_http_exception(request: Request, exc: BaseHttpException):

nlbone/interfaces/api/exceptions.py

@@ -1,4 +1,5 @@
 from typing import Any, Iterable
+
 from fastapi import HTTPException, status
 
 
@@ -77,5 +78,3 @@ class UnprocessableEntityException(BaseHttpException):
 class LogicalValidationException(UnprocessableEntityException):
     def __init__(self, detail: str, loc: Iterable[Any] | None = None, type_: str = "logical_error"):
         super().__init__(detail=detail, loc=loc, type_=type_)
-
-

nlbone/interfaces/api/middleware/__init__.py

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

nlbone/interfaces/api/middleware/access_log.py

@@ -1,5 +1,6 @@
 import time
 from typing import Callable
+
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 
@@ -7,6 +8,7 @@ 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()
@@ -20,11 +22,13 @@ class AccessLogMiddleware(BaseHTTPMiddleware):
             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,
-            })
+            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

@@ -1,52 +1,55 @@
-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)
+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.config.settings import get_settings
+from nlbone.utils.context import bind_context, request_ctx, request_id_ctx, 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 get_settings().ENV == "local" 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

@@ -1,9 +1,11 @@
-from typing import Optional, Callable, Union
+from typing import Callable, Optional, 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
@@ -14,6 +16,7 @@ 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:

nlbone/interfaces/api/pagination/__init__.py

@@ -1,13 +1,12 @@
 from typing import Generic, List, Optional, TypeVar
-from pydantic import BaseModel
+
 from fastapi import Depends
+from pydantic import BaseModel
 
-from .offset_base import PaginateResponse, PaginateRequest
+from .offset_base import PaginateRequest, PaginateResponse
 
 
-def get_pagination(
-        req: PaginateRequest = Depends(PaginateRequest)
-) -> PaginateRequest:
+def get_pagination(req: PaginateRequest = Depends(PaginateRequest)) -> PaginateRequest:
     return req
 
 

nlbone/interfaces/api/pagination/offset_base.py

@@ -3,7 +3,6 @@ from math import ceil
 from typing import Any, Optional
 
 from fastapi import Query
-from sqlalchemy import asc, desc
 
 
 class PaginateRequest:
@@ -76,7 +75,6 @@ class PaginateRequest:
         return filters_dict
 
 
-
 class PaginateResponse:
     """
     Lightweight response shaper. If total_count is None → returns just items.

nlbone/interfaces/cli/init_db.py

@@ -1,17 +1,28 @@
-import argparse
-import anyio
+import typer
 
-from nlbone.adapters.db.sqlalchemy.schema import init_db_async, init_db_sync
+from nlbone.adapters.db import init_sync_engine, Base, sync_ping
 
-def main() -> None:
-    parser = argparse.ArgumentParser(description="Initialize database schema (create_all).")
-    parser.add_argument("--async", dest="use_async", action="store_true", help="Use AsyncEngine")
-    args = parser.parse_args()
+init_db_command = typer.Typer(help="Database utilities")
 
-    if args.use_async:
-        anyio.run(init_db_async)
-    else:
-        init_db_sync()
 
-if __name__ == "__main__":
-    main()
+@init_db_command.command("init")
+def init_db(drop: bool = typer.Option(False, "--drop", help="Drop all tables before create")):
+    """Create (and optionally drop) DB schema."""
+    engine = init_sync_engine()
+    if drop:
+        Base.metadata.drop_all(bind=engine)
+    Base.metadata.create_all(bind=engine)
+    typer.echo("✅ DB schema initialized.")
+
+
+@init_db_command.command("ping")
+def ping():
+    """Health check."""
+    sync_ping()
+    typer.echo("✅ DB connection OK")
+
+
+@init_db_command.command("migrate")
+def migrate():
+    """Placeholder for migration trigger (Alembic, etc.)."""
+    typer.echo("ℹ️  Hook your migration tool here.")

nlbone/interfaces/cli/main.py

@@ -0,0 +1,29 @@
+import typer
+from typing import Optional
+
+from nlbone.adapters.db import init_sync_engine
+from nlbone.config.settings import get_settings
+from nlbone.interfaces.cli.init_db import init_db_command
+
+app = typer.Typer(help="NLBone CLI")
+
+app.add_typer(init_db_command, name="db")
+
+@app.callback()
+def common(
+    env_file: Optional[str] = typer.Option(
+        None, "--env-file", "-e",
+        help="Path to .env file. In prod omit this."
+    ),
+    debug: bool = typer.Option(False, "--debug", help="Enable debug logging"),
+):
+    settings = get_settings(env_file=env_file)
+    if debug:
+        pass
+    init_sync_engine(echo=settings.DEBUG)
+
+def main():
+    app()
+
+if __name__ == "__main__":
+    main()

nlbone/utils/context.py

@@ -7,9 +7,15 @@ 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]:
+
+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)
@@ -23,20 +29,24 @@ def bind_context(*, request: Any | None = None, request_id: str | None = 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/redactor.py

@@ -0,0 +1,32 @@
+import json
+import logging
+import re
+from typing import Any
+
+SENSITIVE_KEYS = {"password", "token", "access_token", "refresh_token", "secret", "card_number", "cvv", "pan"}
+
+class PiiRedactor(logging.Filter):
+    def _redact_in_obj(self, obj: Any):
+        if isinstance(obj, dict):
+            return {k: ("***" if k.lower() in SENSITIVE_KEYS else self._redact_in_obj(v)) for k, v in obj.items()}
+        if isinstance(obj, (list, tuple)):
+            return [self._redact_in_obj(v) for v in obj]
+        if isinstance(obj, str):
+            obj = re.sub(r"\b(\d{6})\d{6}(\d{4})\b", r"\1******\2", obj)
+        return obj
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        try:
+            if isinstance(record.args, dict):
+                record.args = self._redact_in_obj(record.args)
+            if isinstance(record.msg, dict):
+                record.msg = self._redact_in_obj(record.msg)
+            elif isinstance(record.msg, str):
+                try:
+                    data = json.loads(record.msg)
+                    record.msg = json.dumps(self._redact_in_obj(data), ensure_ascii=False)
+                except Exception:
+                    record.msg = self._redact_in_obj(record.msg)
+        except Exception:
+            pass
+        return True

nlbone/utils/time.py

@@ -1,5 +1,44 @@
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
+
+from dateutil import parser
 
 
 def now() -> datetime:
-    return datetime.now(timezone.utc)
+    return datetime.now(timezone.utc)
+
+
+class TimeUtility:
+    @classmethod
+    def now(cls) -> datetime:
+        return datetime.now(timezone.utc)
+
+    @classmethod
+    def minutes_left_from_now(cls, ts: str | datetime) -> int:
+        dt = parser.parse(ts) if isinstance(ts, str) else ts
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        now = datetime.now(timezone.utc)
+        delta_sec = (dt - now).total_seconds()
+        return int(delta_sec // 60)
+
+    @classmethod
+    def get_datetime(cls, ts: str | datetime) -> datetime:
+        dt = parser.parse(ts) if isinstance(ts, str) else ts
+        if dt.tzinfo is None:
+            dt = dt.replace(tzinfo=timezone.utc)
+        return dt
+
+    @classmethod
+    def get_past_datetime(
+            cls, days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0
+    ) -> datetime:
+        delta = timedelta(
+            days=days,
+            seconds=seconds,
+            microseconds=microseconds,
+            milliseconds=milliseconds,
+            minutes=minutes,
+            hours=hours,
+            weeks=weeks,
+        )
+        return cls.now() - delta

{nlbone-0.4.0.dist-info → nlbone-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.4.0
+Version: 0.4.2
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
@@ -8,23 +8,19 @@ License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: anyio>=4.0
 Requires-Dist: dependency-injector>=4.48.1
+Requires-Dist: elasticsearch==8.14.0
 Requires-Dist: fastapi>=0.116
 Requires-Dist: httpx>=0.27
 Requires-Dist: psycopg>=3.2.9
 Requires-Dist: pydantic-settings>=2.0
 Requires-Dist: pydantic>=2.0
+Requires-Dist: python-dateutil~=2.9.0.post0
 Requires-Dist: python-keycloak==5.8.1
+Requires-Dist: redis~=6.4.0
 Requires-Dist: sqlalchemy>=2.0
 Requires-Dist: starlette>=0.47
+Requires-Dist: typer>=0.17.4
 Requires-Dist: uvicorn>=0.35
-Provides-Extra: dev
-Requires-Dist: mypy>=1.10; extra == 'dev'
-Requires-Dist: pre-commit>=3.7; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.23; extra == 'dev'
-Requires-Dist: pytest>=8.0; extra == 'dev'
-Requires-Dist: ruff>=0.5; extra == 'dev'
-Requires-Dist: tomli; extra == 'dev'
-Requires-Dist: twine; extra == 'dev'
 Description-Content-Type: text/markdown
 
 # nlbone