nlbone 0.4.1__tar.gz → 0.4.2__tar.gz

{nlbone-0.4.1 → nlbone-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.4.1
+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,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
 

{nlbone-0.4.1 → nlbone-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.4.1"
+version = "0.4.2"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -22,7 +22,11 @@ dependencies = [
     "uvicorn>=0.35",
     "sqlalchemy>=2.0",
     "psycopg>=3.2.9",
-    "dependency-injector>=4.48.1"
+    "dependency-injector>=4.48.1",
+    "elasticsearch==8.14.0",
+    "redis~=6.4.0",
+    "python-dateutil~=2.9.0.post0",
+    "typer>=0.17.4"
 ]
 
 [tool.ruff]
@@ -56,3 +60,6 @@ dev = [
     "pytest>=8.4.2",
     "ruff>=0.12.12",
 ]
+
+[project.scripts]
+nlbone = "nlbone.interfaces.cli.main:main"

{nlbone-0.4.1 → nlbone-0.4.2}/src/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-0.4.2/src/nlbone/adapters/db/__init__.py

@@ -0,0 +1,4 @@
+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-0.4.2/src/nlbone/adapters/db/postgres/audit.py

@@ -0,0 +1,148 @@
+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 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-0.4.1/src/nlbone/adapters/db/sqlalchemy → nlbone-0.4.2/src/nlbone/adapters/db/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-0.4.2/src/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-0.4.2/src/nlbone/adapters/percolation/__init__.py

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

nlbone-0.4.2/src/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-0.4.2/src/nlbone/config/logging.py

@@ -0,0 +1,119 @@
+import json
+import logging
+import sys
+from datetime import datetime, timezone
+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
+
+settings = get_settings()
+
+# ---------- Filters ----------
+class ContextFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        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):
+    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] = {
+            "ts": datetime.fromtimestamp(record.created, timezone.utc).isoformat(),
+            "level": record.levelname,
+            "logger": record.name,
+            "msg": record.getMessage(),
+            "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),
+        }
+
+        for k, v in record.__dict__.items():
+            if k in self.RESERVED or k in payload:
+                continue
+            payload[k] = v
+
+        if record.exc_info:
+            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",
+        }
+
+    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_error = logging.getLogger("uvicorn.error")
+    uvicorn_error.handlers = []
+    uvicorn_error.propagate = True
+
+    uvicorn_access = logging.getLogger("uvicorn.access")
+    if silence_uvicorn_access:
+        uvicorn_access.handlers = []
+        uvicorn_access.propagate = False
+    else:
+        uvicorn_access.handlers = []
+        uvicorn_access.propagate = True
+
+def get_logger(name: str | None = None) -> logging.Logger:
+    return logging.getLogger(name or "app")

{nlbone-0.4.1 → nlbone-0.4.2}/src/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-0.4.1 → nlbone-0.4.2}/src/nlbone/container.py

@@ -5,8 +5,8 @@ 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.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

nlbone-0.4.2/src/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-0.4.2/src/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-0.4.1 → nlbone-0.4.2}/src/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-0.4.1 → nlbone-0.4.2}/src/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-0.4.2/src/nlbone/interfaces/cli/init_db.py

@@ -0,0 +1,28 @@
+import typer
+
+from nlbone.adapters.db import init_sync_engine, Base, sync_ping
+
+init_db_command = typer.Typer(help="Database utilities")
+
+
+@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-0.4.2/src/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-0.4.2/src/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-0.4.2/src/nlbone/utils/time.py

@@ -0,0 +1,44 @@
+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/src/nlbone/adapters/db/__init__.py

@@ -1,3 +0,0 @@
-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

nlbone-0.4.1/src/nlbone/config/logging.py

@@ -1,155 +0,0 @@
-from __future__ import annotations
-
-import contextvars
-import json
-import logging
-import sys
-from datetime import datetime, timezone
-from typing import Any, MutableMapping, Optional
-
-from nlbone.config.settings import get_settings
-
-# 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."""
-
-    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 "-"
-        return True
-
-
-class JsonFormatter(logging.Formatter):
-    """Minimal JSON formatter with ISO8601 timestamps."""
-
-    def format(self, record: logging.LogRecord) -> str:
-        payload: MutableMapping[str, Any] = {
-            "ts": datetime.fromtimestamp(record.created, timezone.utc).isoformat(),
-            "level": record.levelname,
-            "logger": record.name,
-            "msg": record.getMessage(),
-            "request_id": getattr(record, "request_id", "-"),
-        }
-
-        # 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:
-                continue
-            payload[key] = value
-
-        # Attach exception info if present
-        if record.exc_info:
-            payload["exc_type"] = record.exc_info[0].__name__ if record.exc_info[0] else None
-            payload["exc"] = self.formatException(record.exc_info)
-
-        return json.dumps(payload, ensure_ascii=False)
-
-
-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)
-
-    # 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_access = logging.getLogger("uvicorn.access")
-    if silence_uvicorn_access:
-        uvicorn_access.handlers = []
-        uvicorn_access.propagate = False
-    else:
-        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)

nlbone-0.4.1/src/nlbone/interfaces/cli/init_db.py

@@ -1,20 +0,0 @@
-import argparse
-
-import anyio
-
-from nlbone.adapters.db.sqlalchemy.schema import init_db_async, init_db_sync
-
-
-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()
-
-    if args.use_async:
-        anyio.run(init_db_async)
-    else:
-        init_db_sync()
-
-
-if __name__ == "__main__":
-    main()

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

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