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

nlbone/adapters/auth/keycloak.py

@@ -1,7 +1,7 @@
 from keycloak import KeycloakOpenID
 from keycloak.exceptions import KeycloakAuthenticationError
 
-from nlbone.config.settings import Settings, get_settings
+from nlbone.config.settings import Settings, get_settings, is_production_env
 from nlbone.core.ports.auth import AuthService
 
 
@@ -14,8 +14,12 @@ class KeycloakAuthService(AuthService):
             realm_name=s.KEYCLOAK_REALM_NAME,
             client_secret_key=s.KEYCLOAK_CLIENT_SECRET.get_secret_value().strip(),
         )
+        self.bypass = not is_production_env()
 
     def has_access(self, token, permissions):
+        if self.bypass:
+            return True
+
         try:
             result = self.keycloak_openid.has_uma_access(token, permissions=permissions)
             return result.is_authorized
@@ -71,4 +75,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/auth/token_provider.py

@@ -0,0 +1,40 @@
+import threading
+import time
+from typing import Optional, Dict, Any
+
+from nlbone.adapters.auth.keycloak import KeycloakAuthService
+
+
+class ClientTokenProvider:
+    """Caches Keycloak client-credentials token and refreshes before expiry."""
+
+    def __init__(self, auth: KeycloakAuthService, *, skew_seconds: int = 30) -> None:
+        self._auth = auth
+        self._skew = skew_seconds
+        self._lock = threading.Lock()
+        self._token: Optional[str] = None  # access_token
+        self._expires_at: float = 0.0  # epoch seconds
+
+    def _needs_refresh(self) -> bool:
+        return not self._token or time.time() >= (self._expires_at - self._skew)
+
+    def get_access_token(self) -> str:
+        """Return a valid access token; refresh if needed."""
+        if not self._needs_refresh():
+            return self._token
+
+        with self._lock:
+            if not self._needs_refresh():
+                return self._token
+
+            data: Dict[str, Any] = self._auth.get_client_token()
+            access_token = data.get("access_token")
+            if not access_token:
+                raise RuntimeError("Keycloak: missing access_token")
+            expires_in = int(data.get("expires_in", 60))
+            self._token = access_token
+            self._expires_at = time.time() + max(1, expires_in)
+            return self._token
+
+    def get_auth_header(self) -> str:
+        return f"Bearer {self.get_access_token()}"

nlbone/adapters/db/__init__.py

@@ -1,3 +1,4 @@
-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
+from .postgres import apply_pagination, get_paginated_response
+from .postgres.base import Base
+from .postgres.engine import async_ping, async_session, init_async_engine, init_sync_engine, sync_ping, sync_session
+import nlbone.adapters.db.postgres.audit

nlbone/adapters/db/postgres/audit.py

@@ -0,0 +1,150 @@
+import uuid
+from datetime import date, datetime
+from typing import Any
+from sqlalchemy import event, inspect as sa_inspect
+from sqlalchemy.orm import Session as SASession
+from enum import Enum as _Enum
+from decimal import Decimal
+
+from nlbone.core.domain.models import AuditLog
+from nlbone.utils.context import current_context_dict
+
+DEFAULT_EXCLUDE = {"updated_at", "created_at"}
+DEFAULT_ENABLED = False
+DEFAULT_OPS = {"INSERT", "UPDATE", "DELETE"}
+
+
+def _get_ops_for(obj) -> set[str]:
+    ops = getattr(obj, "__audit_ops__", None)
+    if ops is None:
+        return set(DEFAULT_OPS)
+    return {str(op).upper() for op in ops}
+
+
+def _is_audit_disabled(obj) -> bool:
+    if not DEFAULT_ENABLED:
+        return True
+    if getattr(obj, "__audit_disable__", False):
+        return True
+    if hasattr(obj, "__audit_enable__") and not getattr(obj, "__audit_enable__"):
+        return True
+    return False
+
+
+def _is_op_enabled(obj, op: str) -> bool:
+    if _is_audit_disabled(obj):
+        return False
+    return op.upper() in _get_ops_for(obj)
+
+
+def _ser(val):
+    if isinstance(val, (date, datetime)):
+        return val.isoformat()
+    # UUID
+    if isinstance(val, uuid.UUID):
+        return str(val)
+    # Enum
+    if isinstance(val, _Enum):
+        return val.value
+    if isinstance(val, Decimal):
+        return str(val)
+    if isinstance(val, set):
+        return list(val)
+    return val
+
+
+def _entity_name(obj: Any) -> str:
+    return getattr(getattr(obj, "__table__", None), "name", None) or getattr(obj, "__tablename__",
+                                                                             None) or obj.__class__.__name__
+
+
+def _entity_id(obj: Any) -> str:
+    insp = sa_inspect(obj)
+    if insp.identity and len(insp.identity) == 1:
+        return _ser(insp.identity[0])
+    for pk in insp.mapper.primary_key:
+        v = getattr(obj, pk.key)
+        if v is not None:
+            return _ser(v)
+    return _ser(getattr(obj, "id", "?"))
+
+
+def _changes_for_update(obj: any) -> dict[str, dict[str, any]]:
+    changes = {}
+    insp = sa_inspect(obj)
+    exclude = set(getattr(obj, "__audit_exclude__", set())) | DEFAULT_EXCLUDE
+
+    for col in insp.mapper.column_attrs:
+        key = col.key
+        if key in exclude:
+            continue
+
+        try:
+            state = insp.attrs[key]
+        except KeyError:
+            continue
+
+        hist = state.history                 # History object
+        if hist.has_changes():
+            old = hist.deleted[0] if hist.deleted else None
+            new = hist.added[0] if hist.added else None
+            if old != new:
+                changes[key] = {"old": _ser(old), "new": _ser(new)}
+    return changes
+@event.listens_for(SASession, "before_flush")
+def before_flush(session: SASession, flush_context, instances):
+    entries = session.info.setdefault("_audit_entries", [])
+
+    # INSERT
+    for obj in session.new:
+        if isinstance(obj, AuditLog) or not _is_op_enabled(obj, "INSERT"):
+            continue
+        insp = sa_inspect(obj)
+        exclude = set(getattr(obj, "__audit_exclude__", set())) | DEFAULT_EXCLUDE
+        row = {}
+        for col_attr in insp.mapper.column_attrs:
+            key = col_attr.key
+            if key in exclude:
+                continue
+            row[key] = _ser(getattr(obj, key, None))
+        entries.append({
+            "obj": obj,
+            "op": "INSERT",
+            "changes": {k: {"old": None, "new": v} for k, v in row.items()}
+        })
+
+    # UPDATE
+    for obj in session.dirty:
+        if isinstance(obj, AuditLog) or not _is_op_enabled(obj, "UPDATE"):
+            continue
+        if session.is_modified(obj, include_collections=False):
+            ch = _changes_for_update(obj)
+            if ch:
+                entries.append({"obj": obj, "op": "UPDATE", "changes": ch})
+
+    # DELETE
+    for obj in session.deleted:
+        if isinstance(obj, AuditLog) or not _is_op_enabled(obj, "DELETE"):
+            continue
+        entries.append({"obj": obj, "op": "DELETE", "changes": None})
+
+
+@event.listens_for(SASession, "after_flush_postexec")
+def after_flush_postexec(session: SASession, flush_context):
+    entries = session.info.pop("_audit_entries", [])
+    if not entries:
+        return
+    ctx = current_context_dict()
+    for e in entries:
+        obj = e["obj"]
+        al = AuditLog(
+            entity=_entity_name(obj),
+            entity_id=str(_entity_id(obj)),
+            operation=e["op"],
+            changes=e.get("changes"),
+            actor_id=ctx.get("user_id"),
+            request_id=ctx.get("request_id"),
+            ip=ctx.get("ip"),
+            user_agent=ctx.get("user_agent"),
+        )
+        session.add(al)

nlbone/adapters/db/{sqlalchemy → postgres}/schema.py

@@ -1,8 +1,8 @@
 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
+from nlbone.adapters.db.postgres.base import Base
+from nlbone.adapters.db.postgres.engine import init_async_engine, init_sync_engine
 
 DEFAULT_MODEL_MODULES: Sequence[str] = ()
 

nlbone/adapters/db/redis/client.py

@@ -0,0 +1,22 @@
+import redis
+
+from nlbone.config.settings import get_settings
+
+
+class RedisClient:
+    _client: redis.Redis | None = None
+
+    @classmethod
+    def get_client(cls) -> redis.Redis:
+        if cls._client is None:
+            cls._client = redis.from_url(
+                get_settings().REDIS_URL,
+                decode_responses=True
+            )
+        return cls._client
+
+    @classmethod
+    def close(cls):
+        if cls._client is not None:
+            cls._client.close()
+            cls._client = None

nlbone/adapters/http_clients/uploadchi.py

@@ -7,6 +7,7 @@ from urllib.parse import urlparse, urlunparse
 import httpx
 import requests
 
+from nlbone.adapters.auth.token_provider import ClientTokenProvider
 from nlbone.config.settings import get_settings
 from nlbone.core.ports.files import FileServicePort
 
@@ -30,7 +31,7 @@ def _auth_headers(token: str | None) -> dict[str, str]:
 
 
 def _build_list_query(
-    limit: int, offset: int, filters: dict[str, Any] | None, sort: list[tuple[str, str]] | None
+        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:
@@ -58,21 +59,23 @@ 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,
+            self,
+            token_provider: ClientTokenProvider | None = None,
+            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)
         self._client = client or requests.session()
+        self._token_provider = token_provider
 
     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
+            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)}
@@ -82,23 +85,35 @@ class UploadchiClient(FileServicePort):
             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:
+    def commit_file(self, file_id: str, token: str | None = None) -> None:
+        if not token and not self._token_provider:
+            raise UploadchiError(detail="token_provider is not provided", status=400)
         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,
+        )
+        if r.status_code not in (204, 200):
+            raise UploadchiError(r.status_code, r.text)
+
+    def rollback(self, file_id: str, token: str | None = None) -> None:
+        if not token and not self._token_provider:
+            raise UploadchiError(detail="token_provider is not provided", status=400)
+        tok = _resolve_token(token)
+        r = self._client.post(
+            f"{self._base_url}/{file_id}/rollback",
+            headers=_auth_headers(tok),
         )
         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,
+            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)
@@ -107,14 +122,14 @@ class UploadchiClient(FileServicePort):
             raise UploadchiError(r.status_code, r.text)
         return r.json()
 
-    def get_file(self, file_id: int, token: str | None = None) -> dict:
+    def get_file(self, file_id: str, token: str | None = None) -> dict:
         tok = _resolve_token(token)
         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]:
+    def download_file(self, file_id: str, token: str | None = None) -> tuple[bytes, str, str]:
         tok = _resolve_token(token)
         r = self._client.get(f"{self._base_url}/{file_id}/download", headers=_auth_headers(tok))
         if r.status_code >= 400:
@@ -123,7 +138,7 @@ class UploadchiClient(FileServicePort):
         media_type = r.headers.get("content-type", "application/octet-stream")
         return r.content, filename, media_type
 
-    def delete_file(self, file_id: int, token: str | None = None) -> None:
+    def delete_file(self, file_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
         r = self._client.delete(f"{self._base_url}/{file_id}", headers=_auth_headers(tok))
         if r.status_code not in (204, 200):

nlbone/adapters/http_clients/uploadchi_async.py

@@ -8,14 +8,16 @@ 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
+from ..auth.token_provider import ClientTokenProvider
 
 
 class UploadchiAsyncClient(AsyncFileServicePort):
     def __init__(
-        self,
-        base_url: Optional[str] = None,
-        timeout_seconds: Optional[float] = None,
-        client: httpx.AsyncClient | None = None,
+            self,
+            token_provider: ClientTokenProvider | None = None,
+            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)
@@ -23,12 +25,13 @@ class UploadchiAsyncClient(AsyncFileServicePort):
         self._client = client or httpx.AsyncClient(
             base_url=self._base_url, timeout=self._timeout, follow_redirects=True
         )
+        self._token_provider = token_provider
 
     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
+            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)}
@@ -38,21 +41,33 @@ class UploadchiAsyncClient(AsyncFileServicePort):
             raise UploadchiError(r.status_code, await r.aread())
         return r.json()
 
-    async def commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None:
+    async def commit_file(self, file_id: str, token: str | None = None) -> None:
+        if not token and not self._token_provider:
+            raise UploadchiError(detail="token_provider is not provided", status=400)
         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
+            f"/{file_id}/commit", headers=_auth_headers(tok)
+        )
+        if r.status_code not in (204, 200):
+            raise UploadchiError(r.status_code, await r.aread())
+
+    async def rollback(self, file_id: str, token: str | None = None) -> None:
+        if not token and not self._token_provider:
+            raise UploadchiError(detail="token_provider is not provided", status=400)
+        tok = _resolve_token(token)
+        r = await self._client.post(
+            f"/{file_id}/rollback", headers=_auth_headers(tok)
         )
         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,
+            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)
@@ -61,14 +76,14 @@ class UploadchiAsyncClient(AsyncFileServicePort):
             raise UploadchiError(r.status_code, await r.aread())
         return r.json()
 
-    async def get_file(self, file_id: int, token: str | None = None) -> dict:
+    async def get_file(self, file_id: str, token: str | None = None) -> dict:
         tok = _resolve_token(token)
         r = await self._client.get(f"/{file_id}", headers=_auth_headers(tok))
         if r.status_code >= 400:
             raise UploadchiError(r.status_code, await r.aread())
         return r.json()
 
-    async def download_file(self, file_id: int, token: str | None = None) -> tuple[AsyncIterator[bytes], str, str]:
+    async def download_file(self, file_id: str, token: str | None = None) -> tuple[AsyncIterator[bytes], str, str]:
         tok = _resolve_token(token)
         r = await self._client.get(f"/{file_id}/download", headers=_auth_headers(tok), stream=True)
         if r.status_code >= 400:
@@ -86,7 +101,7 @@ class UploadchiAsyncClient(AsyncFileServicePort):
 
         return _aiter(), filename, media_type
 
-    async def delete_file(self, file_id: int, token: str | None = None) -> None:
+    async def delete_file(self, file_id: str, token: str | None = None) -> None:
         tok = _resolve_token(token)
         r = await self._client.delete(f"/{file_id}", headers=_auth_headers(tok))
         if r.status_code not in (204, 200):

nlbone/adapters/percolation/__init__.py

@@ -0,0 +1 @@
+from .connection import get_es_client

nlbone/adapters/percolation/connection.py

@@ -0,0 +1,12 @@
+from elasticsearch import Elasticsearch
+
+from nlbone.config.settings import get_settings
+
+setting = get_settings()
+
+def get_es_client():
+    es = Elasticsearch(
+        setting.ELASTIC_PERCOLATE_URL,
+        basic_auth=(setting.ELASTIC_PERCOLATE_USER, setting.ELASTIC_PERCOLATE_PASS.get_secret_value().strip())
+    )
+    return es

nlbone/config/logging.py

@@ -1,40 +1,33 @@
-from __future__ import annotations
-
-import contextvars
 import json
 import logging
 import sys
 from datetime import datetime, timezone
-from typing import Any, MutableMapping, Optional
+from logging.config import dictConfig
+from typing import Any, MutableMapping
 
 from nlbone.config.settings import get_settings
+from nlbone.utils.context import current_context_dict
+from nlbone.utils.redactor import PiiRedactor
 
-# Context variable for request/correlation id
-_request_id_var: contextvars.ContextVar[Optional[str]] = contextvars.ContextVar("request_id", default=None)
-
-
-def set_request_id(request_id: Optional[str]) -> None:
-    """
-    Set request id in context (e.g., per incoming HTTP request).
-    Example:
-        from nlbone.config.logging import set_request_id
-        set_request_id("abc-123")
-    """
-    _request_id_var.set(request_id)
-
-
-class RequestIdFilter(logging.Filter):
-    """Injects request_id from contextvars into record."""
+settings = get_settings()
 
+# ---------- Filters ----------
+class ContextFilter(logging.Filter):
     def filter(self, record: logging.LogRecord) -> bool:
-        rid = _request_id_var.get()
-        # attach as record attribute; formatters can use %(request_id)s
-        record.request_id = rid or "-"
+        ctx = current_context_dict()
+        record.request_id = ctx.get("request_id")
+        record.user_id = ctx.get("user_id")
+        record.ip = ctx.get("ip")
+        record.user_agent = ctx.get("user_agent")
         return True
 
-
+# ---------- Formatter ----------
 class JsonFormatter(logging.Formatter):
-    """Minimal JSON formatter with ISO8601 timestamps."""
+    RESERVED = {
+        "args","asctime","created","exc_info","exc_text","filename","funcName","levelname","levelno",
+        "lineno","module","msecs","message","msg","name","pathname","process","processName",
+        "relativeCreated","stack_info","thread","threadName",
+    }
 
     def format(self, record: logging.LogRecord) -> str:
         payload: MutableMapping[str, Any] = {
@@ -42,99 +35,77 @@ class JsonFormatter(logging.Formatter):
             "level": record.levelname,
             "logger": record.name,
             "msg": record.getMessage(),
-            "request_id": getattr(record, "request_id", "-"),
+            "request_id": getattr(record, "request_id", None),
+            "user_id": getattr(record, "user_id", None),
+            "ip": getattr(record, "ip", None),
+            "user_agent": getattr(record, "user_agent", None),
         }
 
-        # Add extras (fields set via logger.bind-like approach: logger.info("x", extra={"k": "v"}))
-        # Python's logging puts extras into record.__dict__ directly.
-        for key, value in record.__dict__.items():
-            if key in {
-                "args",
-                "asctime",
-                "created",
-                "exc_info",
-                "exc_text",
-                "filename",
-                "funcName",
-                "levelname",
-                "levelno",
-                "lineno",
-                "module",
-                "msecs",
-                "message",
-                "msg",
-                "name",
-                "pathname",
-                "process",
-                "processName",
-                "relativeCreated",
-                "stack_info",
-                "thread",
-                "threadName",
-            }:
-                continue
-            # Avoid overriding our top-level keys
-            if key in payload:
+        for k, v in record.__dict__.items():
+            if k in self.RESERVED or k in payload:
                 continue
-            payload[key] = value
+            payload[k] = v
 
-        # Attach exception info if present
         if record.exc_info:
-            payload["exc_type"] = record.exc_info[0].__name__ if record.exc_info[0] else None
+            etype = record.exc_info[0].__name__ if record.exc_info[0] else None
+            payload["exc_type"] = etype
             payload["exc"] = self.formatException(record.exc_info)
 
         return json.dumps(payload, ensure_ascii=False)
 
+class PlainFormatter(logging.Formatter):
+    def __init__(self):
+        super().__init__(
+            fmt="%(asctime)s | %(levelname)s | %(name)s | "
+                "req=%(request_id)s user=%(user_id)s ip=%(ip)s | %(message)s",
+            datefmt="%Y-%m-%dT%H:%M:%S%z",
+        )
+
+# ---------- Setup ----------
+def setup_logging(*, log_json: bool=settings.LOG_JSON, log_level: str =settings.LOG_LEVEL,
+                  log_file: str | None = None, silence_uvicorn_access: bool = True):
+    handlers = {
+        "console": {
+            "class": "logging.StreamHandler",
+            "stream": sys.stdout,
+            "filters": ["ctx", "pii"],
+            "formatter": "json" if log_json else "plain",
+        }
+    }
+    if log_file:
+        handlers["file"] = {
+            "class": "logging.handlers.RotatingFileHandler",
+            "filename": log_file,
+            "maxBytes": 10 * 1024 * 1024,
+            "backupCount": 5,
+            "filters": ["ctx", "pii"],
+            "formatter": "json" if log_json else "plain",
+        }
 
-def _build_stream_handler(json_enabled: bool, level: int) -> logging.Handler:
-    handler = logging.StreamHandler(stream=sys.stdout)
-    handler.setLevel(level)
-    handler.addFilter(RequestIdFilter())
-    if json_enabled:
-        handler.setFormatter(JsonFormatter())
-    else:
-        # human-friendly text format
-        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
-
-
-def setup_logging(
-    level: Optional[int] = None,
-    json_enabled: Optional[bool] = None,
-    silence_uvicorn_access: bool = True,
-) -> None:
-    """
-    Configure root logging once at app start.
-    Idempotent: safe to call multiple times.
-
-    Example:
-        from nlbone.config.logging import setup_logging
-        setup_logging()
-    """
-    settings = get_settings()
-    lvl = level if level is not None else getattr(logging, settings.LOG_LEVEL, logging.INFO)
-    json_logs = settings.LOG_JSON if json_enabled is None else json_enabled
-
-    # Clear existing handlers
-    root = logging.getLogger()
-    for h in list(root.handlers):
-        root.removeHandler(h)
-
-    root.setLevel(lvl)
-    root.addHandler(_build_stream_handler(json_logs, lvl))
-
-    # Common noisy loggers (optional tweaks)
-    for noisy in ("asyncio", "httpx"):
-        logging.getLogger(noisy).setLevel(logging.WARNING)
+    dictConfig({
+        "version": 1,
+        "disable_existing_loggers": False,
+        "filters": {
+            "ctx": {"()": ContextFilter},
+            "pii": {"()": PiiRedactor},
+        },
+        "formatters": {
+            "json": {"()": JsonFormatter},
+            "plain": {"()": PlainFormatter},
+        },
+        "handlers": handlers,
+        "root": {
+            "level": log_level,
+            "handlers": list(handlers.keys()),
+        },
+    })
+
+    logging.getLogger("asyncio").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
 
-    # Uvicorn / FastAPI compatibility (if used later)
-    # - application logs go through root
-    # - format access logs separately or silence them
     uvicorn_error = logging.getLogger("uvicorn.error")
     uvicorn_error.handlers = []
-    uvicorn_error.propagate = True  # bubble up to root
+    uvicorn_error.propagate = True
 
     uvicorn_access = logging.getLogger("uvicorn.access")
     if silence_uvicorn_access:
@@ -144,12 +115,5 @@ def setup_logging(
         uvicorn_access.handlers = []
         uvicorn_access.propagate = True
 
-
-def get_logger(name: str) -> logging.Logger:
-    """
-    Helper to get a configured logger.
-    Example:
-        logger = get_logger(__name__)
-        logger.info("hello", extra={"user_id": "42"})
-    """
-    return logging.getLogger(name)
+def get_logger(name: str | None = None) -> logging.Logger:
+    return logging.getLogger(name or "app")

nlbone/config/settings.py

@@ -23,7 +23,7 @@ def _guess_env_file() -> str | None:
             return str(f)
 
 
-def _is_production_env() -> bool:
+def is_production_env() -> bool:
     raw = os.getenv("NLBONE_ENV") or os.getenv("ENV") or os.getenv("ENVIRONMENT")
     if not raw:
         return False
@@ -77,6 +77,13 @@ class Settings(BaseSettings):
     UPLOADCHI_BASE_URL: AnyHttpUrl = Field(default="https://uploadchi.numberland.ir/v1/files")
     UPLOADCHI_TOKEN: SecretStr = Field(default="")
 
+    # ---------------------------
+    # PERCOLATE
+    # ---------------------------
+    ELASTIC_PERCOLATE_URL: str =  Field(default="http://localhost:9200")
+    ELASTIC_PERCOLATE_USER: str = Field(default="")
+    ELASTIC_PERCOLATE_PASS: SecretStr = Field(default="")
+
     model_config = SettingsConfigDict(
         env_prefix="",
         env_file=None,
@@ -86,7 +93,7 @@ class Settings(BaseSettings):
 
     @classmethod
     def load(cls, env_file: str | None = None) -> "Settings":
-        if _is_production_env():
+        if is_production_env():
             return cls()
         return cls(_env_file=env_file or _guess_env_file())
 

nlbone/container.py

@@ -5,8 +5,9 @@ from typing import Any, Mapping, Optional
 from dependency_injector import containers, providers
 
 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.auth.token_provider import ClientTokenProvider
+from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork, SqlAlchemyUnitOfWork
+from nlbone.adapters.db.postgres.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.messaging import InMemoryEventBus
@@ -29,8 +30,11 @@ class Container(containers.DeclarativeContainer):
 
     # --- Services ---
     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)
+    token_provider = providers.Singleton(ClientTokenProvider, auth=auth, skew_seconds=30)
+    file_service: providers.Singleton[FileServicePort] = providers.Singleton(UploadchiClient,
+                                                                             token_provider=token_provider)
+    afiles_service: providers.Singleton[AsyncFileServicePort] = providers.Singleton(UploadchiAsyncClient,
+                                                                                    token_provider=token_provider)
 
 
 def create_container(settings: Optional[Any] = None) -> Container:

nlbone/core/application/base_worker.py

@@ -0,0 +1,36 @@
+import asyncio
+from abc import ABC, abstractmethod
+from typing import Any
+
+from nlbone.utils.time import TimeUtility
+
+
+class BaseWorker(ABC):
+    def __init__(self, name, interval):
+        self.name = name
+        self.interval = interval
+
+    async def run(self, *args, **kwargs):
+        while True:
+            try:
+                print(f"[>>] {self.name} is running. Current time: {TimeUtility.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+
+                await self.process(*args, **kwargs)
+
+                print(
+                    f"[>>] {self.name} is sleeping. Current time: {TimeUtility.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+                )
+                await asyncio.sleep(self.interval)
+
+            except asyncio.CancelledError:
+                print(f"[!!] {self.name} task was cancelled. Shutting down gracefully.\n")
+                break
+
+            except Exception as e:
+                print(f"[!!]An error occurred in {self.name}:\n{str(e)}\n")
+                print(f"[!!] Retrying in {self.interval / 2} seconds...\n")
+                await asyncio.sleep(self.interval / 2)
+
+    @abstractmethod
+    async def process(self, *args, **kwargs) -> Any:
+        pass

nlbone/core/domain/models.py

@@ -0,0 +1,38 @@
+import uuid
+from datetime import datetime
+from sqlalchemy import String, DateTime, Index, Text
+from sqlalchemy import JSON as SA_JSON
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy.sql import func
+
+from nlbone.adapters.db import Base
+
+try:
+    from sqlalchemy.dialects.postgresql import JSONB, UUID
+    JSONType = JSONB
+    UUIDType = UUID(as_uuid=True)
+except Exception:
+    JSONType = SA_JSON
+    UUIDType = String(36)
+
+
+class AuditLog(Base):
+    __tablename__ = "audit_logs"
+
+    id: Mapped[uuid.UUID] = mapped_column(UUIDType, primary_key=True, default=uuid.uuid4)
+    entity: Mapped[str] = mapped_column(String(100), nullable=False)
+    entity_id: Mapped[str] = mapped_column(String(64), nullable=False)
+    operation: Mapped[str] = mapped_column(String(10), nullable=False)  # INSERT/UPDATE/DELETE
+    changes: Mapped[dict | None] = mapped_column(JSONType, nullable=True)
+
+    actor_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    request_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    ip: Mapped[str | None] = mapped_column(String(45), nullable=True)
+    user_agent: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    created_at: Mapped[datetime] = mapped_column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+
+    __table_args__ = (
+        Index("ix_audit_entity_entityid", "entity", "entity_id"),
+        Index("ix_audit_created_at", "created_at"),
+    )

nlbone/core/ports/files.py

@@ -8,7 +8,8 @@ class FileServicePort(Protocol):
     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 commit_file(self, file_id: str, token: str | None = None) -> None: ...
+    def rollback(self, file_id: str, token: str | None = None) -> None: ...
     def list_files(
         self,
         limit: int = 10,
@@ -17,9 +18,9 @@ class FileServicePort(Protocol):
         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: ...
+    def get_file(self, file_id: str, token: str | None = None) -> dict: ...
+    def download_file(self, file_id: str, token: str | None = None) -> tuple[bytes, str, str]: ...
+    def delete_file(self, file_id: str, token: str | None = None) -> None: ...
 
 
 @runtime_checkable
@@ -27,7 +28,8 @@ 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 commit_file(self, file_id: int, client_id: str, token: str | None = None) -> None: ...
+    async def commit_file(self, file_id: str, token: str | None = None) -> None: ...
+    async def rollback(self, file_id: str, token: str | None = None) -> None: ...
     async def list_files(
         self,
         limit: int = 10,
@@ -36,6 +38,6 @@ class AsyncFileServicePort(Protocol):
         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: ...
+    async def get_file(self, file_id: str, token: str | None = None) -> dict: ...
+    async def download_file(self, file_id: str, token: str | None = None) -> tuple[AsyncIterator[bytes], str, str]: ...
+    async def delete_file(self, file_id: str, token: str | None = None) -> None: ...

nlbone/interfaces/api/dependencies/db.py

@@ -5,7 +5,7 @@ from typing import AsyncGenerator, Generator
 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]:

nlbone/interfaces/api/dependencies/uow.py

@@ -5,7 +5,7 @@ from typing import AsyncIterator
 
 from fastapi import Request
 
-from nlbone.adapters.db.sqlalchemy import AsyncSqlAlchemyUnitOfWork
+from nlbone.adapters.db.postgres import AsyncSqlAlchemyUnitOfWork
 from nlbone.core.ports.uow import AsyncUnitOfWork, UnitOfWork
 
 

nlbone/interfaces/cli/init_db.py

@@ -1,20 +1,28 @@
-import argparse
+import typer
 
-import anyio
+from nlbone.adapters.db import init_sync_engine, Base, sync_ping
 
-from nlbone.adapters.db.sqlalchemy.schema import init_db_async, init_db_sync
+init_db_command = typer.Typer(help="Database utilities")
 
 
-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.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.")
 
-    if args.use_async:
-        anyio.run(init_db_async)
-    else:
-        init_db_sync()
 
+@init_db_command.command("ping")
+def ping():
+    """Health check."""
+    sync_ping()
+    typer.echo("✅ DB connection OK")
 
-if __name__ == "__main__":
-    main()
+
+@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/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)
+
+
+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.1.dist-info → nlbone-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.4.1
+Version: 0.4.3
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT
@@ -8,14 +8,18 @@ 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
 Description-Content-Type: text/markdown
 
@@ -75,4 +79,8 @@ async def main():
 
 
 anyio.run(main)
-```
+```
+
+## 📦 Used In
+- **Explore**
+- **Pricing**

{nlbone-0.4.1.dist-info → nlbone-0.4.3.dist-info}/RECORD

@@ -1,31 +1,36 @@
 nlbone/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/container.py,sha256=TrjMmUNXfwW4R4dRftK1GOpYu3wqfhixtnwuZkxVWvI,2104
+nlbone/container.py,sha256=wmamsFU0Be6DlEqhLW30J2w4zVCwNlcZDd7HxkzWil0,2481
 nlbone/types.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/auth/__init__.py,sha256=hkDHvsFhw_UiOHG9ZSMqjiAhK4wumEforitveSZswVw,42
-nlbone/adapters/auth/keycloak.py,sha256=adZ9r-IPybSzWEQCRlPcxeDjPf8rKVf1xq3zgpMTqrY,2616
-nlbone/adapters/db/__init__.py,sha256=A8O5Vk2o71HumV7pQBXOszWSzOfLVn5FqbHOAUCWugk,218
-nlbone/adapters/db/memory.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/db/postgres.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/db/sqlalchemy/__init__.py,sha256=6JYJH0xZs3aR-zuyMpRhsdzFugmqz8nprwTQLprqhZc,313
-nlbone/adapters/db/sqlalchemy/base.py,sha256=kha9xmklzhuQAK8QEkNBn-mAHq8dUKbOM-3abaBpWmQ,71
-nlbone/adapters/db/sqlalchemy/engine.py,sha256=UCegauVB1gvo42ThytYnn5VIcQBwR-5xhcXYFApRFNk,3448
-nlbone/adapters/db/sqlalchemy/query_builder.py,sha256=U5pqpCfJKuMIxIEHyodoHuPgE8jf53slC1ScKZR5xa4,8653
-nlbone/adapters/db/sqlalchemy/repository.py,sha256=J_DBE73JhHPYCk90c5-O7lQtZbxDgqjjN9OcWy4Omvs,1660
-nlbone/adapters/db/sqlalchemy/schema.py,sha256=7ELexoAnbSjEJ3JYDNRSKOuraS51DupZ6H8QIkuGcsM,1043
-nlbone/adapters/db/sqlalchemy/uow.py,sha256=nRxNpY-WoWHpym-XeZ8VHm0MYvtB9wuopOeNdV_ebk8,2088
+nlbone/adapters/auth/keycloak.py,sha256=dfAxODiARfR8y3FKoWNo9fjfb6QyWd_Qr7AbJ0E78AM,2729
+nlbone/adapters/auth/token_provider.py,sha256=NhqjqTUsoZO4gbK-cybs0OkKydFN7CPTxAiypEw081o,1433
+nlbone/adapters/db/__init__.py,sha256=saW-wN4E0NZ2_ldi-nrm5AgsH7EULNSa62lYMwfy1oo,252
+nlbone/adapters/db/postgres/__init__.py,sha256=6JYJH0xZs3aR-zuyMpRhsdzFugmqz8nprwTQLprqhZc,313
+nlbone/adapters/db/postgres/audit.py,sha256=zFzL-pXmfjcp5YLx6vBYczprsJjEPxSYKhQNR3WjKL0,4675
+nlbone/adapters/db/postgres/base.py,sha256=kha9xmklzhuQAK8QEkNBn-mAHq8dUKbOM-3abaBpWmQ,71
+nlbone/adapters/db/postgres/engine.py,sha256=UCegauVB1gvo42ThytYnn5VIcQBwR-5xhcXYFApRFNk,3448
+nlbone/adapters/db/postgres/query_builder.py,sha256=U5pqpCfJKuMIxIEHyodoHuPgE8jf53slC1ScKZR5xa4,8653
+nlbone/adapters/db/postgres/repository.py,sha256=J_DBE73JhHPYCk90c5-O7lQtZbxDgqjjN9OcWy4Omvs,1660
+nlbone/adapters/db/postgres/schema.py,sha256=NlE7Rr8uXypsw4oWkdZhZwcIBHQEPIpoHLxcUo98i6s,1039
+nlbone/adapters/db/postgres/uow.py,sha256=nRxNpY-WoWHpym-XeZ8VHm0MYvtB9wuopOeNdV_ebk8,2088
+nlbone/adapters/db/redis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/adapters/db/redis/client.py,sha256=XAKcmU0lpPvWPMS0fChVQ3iSJfHV1g4bMOCgJaj2bCI,512
 nlbone/adapters/http_clients/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/adapters/http_clients/email_gateway.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/adapters/http_clients/uploadchi.py,sha256=BGdGC-p8EmXYn29da577Kas2CzZVDAb9XJ9xx2LJioY,4713
-nlbone/adapters/http_clients/uploadchi_async.py,sha256=hBx0jzYYZAX1DCkImZ98zdUob8D9PQH7jykDXIjwG9I,3866
+nlbone/adapters/http_clients/uploadchi.py,sha256=iMLbXUXqi60gQMEI7wfaqWG0G7p9fQN7otT9c8npnLQ,5470
+nlbone/adapters/http_clients/uploadchi_async.py,sha256=wmb2XIUNkowh48GJwttNZ_STgsFQdGKKRZc_luYNCu8,4609
 nlbone/adapters/messaging/__init__.py,sha256=UDAwu3s-JQmOZjWz2Nu0SgHhnkbeOhKDH_zLD75oWMY,40
 nlbone/adapters/messaging/event_bus.py,sha256=w-NPwDiPMLFPU_enRQCtfQXOALsXfg31u57R8sG_-1U,781
 nlbone/adapters/messaging/redis.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/adapters/percolation/__init__.py,sha256=viq5WZqcSLlRBF5JwuyTD_IZaNWfpKzGJIECgKOWgOw,37
+nlbone/adapters/percolation/connection.py,sha256=xZ-OtQVbyQYH83TUizS0UWI85Iic-AhUjiuyzO0e46s,331
 nlbone/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/config/logging.py,sha256=T7Wm61Bu6QqhmnGKdWRQBqnVYKOwaFguiNs2CbJwYfE,5010
-nlbone/config/settings.py,sha256=7DoouDUrWN_fZmo1NngoFFNRMY6kNVq4VGpocnYVeQ4,3208
+nlbone/config/logging.py,sha256=rGQz9W5ZgUFXBK74TFmTuwx_WMJhD8zPN39zfKVxwnI,4115
+nlbone/config/settings.py,sha256=xxdZQDQJ7wSEGODKljtQWcfITXbSHoqAXOlQ9vhNSe4,3474
 nlbone/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/core/application/base_worker.py,sha256=uHqglsd33jXl_0kmkFlB4KQ5NdI1wArcOeQmdcifPQc,1192
 nlbone/core/application/events.py,sha256=eQGLE0aZHuWJsy9J-qRse4CMXOtweH9-2rQ7AIPRMEQ,614
 nlbone/core/application/services.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/application/use_case.py,sha256=3GMQZ3CFK5cbLoBNBgohPft6GBq2j9_wr8iKRq_osQA,247
@@ -33,11 +38,11 @@ nlbone/core/application/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRk
 nlbone/core/domain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/domain/base.py,sha256=5oUfbpaI8juJ28Api8J9IXOSm55VI2bp4QNhA0U8h2Y,1251
 nlbone/core/domain/events.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/core/domain/models.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/core/domain/models.py,sha256=e2ig7PMBBpmc8pdHLNMnXhucMXr9OUq-G7bKGTq9Qj0,1458
 nlbone/core/ports/__init__.py,sha256=gx-Ubj7h-1vvnu56sNnRqmer7HHfW3rX2WLl-0AX5U0,214
 nlbone/core/ports/auth.py,sha256=Gh0yQsxx2OD6pDH2_p-khsA-bVoypP1juuqMoSfjZUo,493
 nlbone/core/ports/event_bus.py,sha256=_Om1GOOT-F325oV6_LJXtLdx4vu5i7KrpTDD3qPJXU0,325
-nlbone/core/ports/files.py,sha256=1k-Vm0ld89EnFK2wybSXIJm5gQNpeuO92PD7d4VMh8s,1737
+nlbone/core/ports/files.py,sha256=7Ov2ITYRpPwwDTZGCeNVISg8e3A9l08jbOgpTImgfK8,1863
 nlbone/core/ports/messaging.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nlbone/core/ports/repo.py,sha256=zOw8CTMAu5DKKy2wZpT3_6JWWjaJCDt7q4dOiJYrCOQ,651
 nlbone/core/ports/uow.py,sha256=SmBdRf0NvSdIjQ3Le1QGz8kNGBk7jgNHtNguvXRwmgs,557
@@ -50,8 +55,8 @@ nlbone/interfaces/api/schemas.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 nlbone/interfaces/api/dependencies/__init__.py,sha256=rnYRrFVZCfICQrp_PVFlzNg3BeC57yM08wn2DbOHCfk,359
 nlbone/interfaces/api/dependencies/async_auth.py,sha256=bfxgBXhp29WqevjTG4jrdPNR-75APm4jKyHdOOtxnp4,1825
 nlbone/interfaces/api/dependencies/auth.py,sha256=VcWnEipQr4dqhzGbP0G9a5nJdplnpFG3wm_NlDCb8z4,1765
-nlbone/interfaces/api/dependencies/db.py,sha256=DGX_hGVrPRnRIuhMnirJZvKNyj1OLC_hQSIrA9NVnNw,468
-nlbone/interfaces/api/dependencies/uow.py,sha256=crV9mu4LlmJ0JI1uzNYkZX2VJUjQ6hWvxyXqleZL_ak,1183
+nlbone/interfaces/api/dependencies/db.py,sha256=-UD39J_86UU7ZJs2ZncpdND0yhAG0NeeeALrgSDuuFw,466
+nlbone/interfaces/api/dependencies/uow.py,sha256=QfLEvLYLNWZJQN1k-0q0hBVtUld3D75P4j39q_RjcnE,1181
 nlbone/interfaces/api/middleware/__init__.py,sha256=zbX2vaEAfxRMIYwO2MVY_2O6bqG5H9o7HqGpX14U3Is,158
 nlbone/interfaces/api/middleware/access_log.py,sha256=vIkxxxfy2HcjqqKb8XCfGCcSrivAC8u6ie75FMq5x-U,1032
 nlbone/interfaces/api/middleware/add_request_context.py,sha256=av-qs0biOYuF9R6RJOo2eYsFqDL9WRYWcjVakFhbt-w,1834
@@ -59,14 +64,16 @@ nlbone/interfaces/api/middleware/authentication.py,sha256=ze7vCm492QsX9nPL6A-PqZ
 nlbone/interfaces/api/pagination/__init__.py,sha256=sWKKQFa2Z-1SlprQOqImOa2c9exq4wueKpUL_9QM7wc,417
 nlbone/interfaces/api/pagination/offset_base.py,sha256=B6rHxzDsxQbm-d2snM6tjgnhWyZw7zvs7fcehV0gpa0,3621
 nlbone/interfaces/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone/interfaces/cli/init_db.py,sha256=EehZEsMeyR6vA4WvM6sAZ-IRhyiJZdrWBaYiptkJVdc,482
-nlbone/interfaces/cli/main.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone/interfaces/cli/init_db.py,sha256=49TmA-LwUsqGVttjU-w2EzZ-vzQCULNlhKP_0sfl1_Y,790
+nlbone/interfaces/cli/main.py,sha256=65XXNmH0dX9Lib_yW5iQXo7wp_GRFwx9xXDYgy2LJtY,704
 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/context.py,sha256=MmclJ24BG2uvSTg1IK7J-Da9BhVFDQ5ag4Ggs2FF1_w,1600
-nlbone/utils/time.py,sha256=0v7TpTglIo1BfwErceXbnFOu6XExNqTQELDXzxLdnAg,103
-nlbone-0.4.1.dist-info/METADATA,sha256=byHqPsOWgE3I5pn0hJjszvG2KSCZFVfAxk7ZuM_4rAE,1979
-nlbone-0.4.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-nlbone-0.4.1.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nlbone-0.4.1.dist-info/RECORD,,
+nlbone/utils/redactor.py,sha256=JbbPs2Qtnz0zHN85BGPYQNWwBigXMSzmMEmmZZOTs_U,1277
+nlbone/utils/time.py,sha256=6e0A4_hG1rYDCrWoOklEGVJstBf8j9XSSTT7VNV2K9Y,1272
+nlbone-0.4.3.dist-info/METADATA,sha256=dKKof0RuBfc3ONT-R1n5qD_oJXaE4BIhqcezwx8NH8Q,2163
+nlbone-0.4.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+nlbone-0.4.3.dist-info/entry_points.txt,sha256=CpIL45t5nbhl1dGQPhfIIDfqqak3teK0SxPGBBr7YCk,59
+nlbone-0.4.3.dist-info/licenses/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nlbone-0.4.3.dist-info/RECORD,,

nlbone-0.4.3.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+nlbone = nlbone.interfaces.cli.main:main