nlbone 0.7.31__tar.gz → 0.8.0__tar.gz

{nlbone-0.7.31 → nlbone-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nlbone
-Version: 0.7.31
+Version: 0.8.0
 Summary: Backbone package for interfaces and infrastructure in Python projects
 Author-email: Amir Hosein Kahkbazzadeh <a.khakbazzadeh@gmail.com>
 License: MIT

{nlbone-0.7.31 → nlbone-0.8.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nlbone"
-version = "0.7.31"
+version = "0.8.0"
 description = "Backbone package for interfaces and infrastructure in Python projects"
 readme = "README.md"
 requires-python = ">=3.10"

nlbone-0.8.0/src/nlbone/adapters/i18n/engine.py

@@ -0,0 +1,40 @@
+import logging
+from typing import Dict, Optional
+
+from nlbone.adapters.i18n.loaders import BaseLoader
+
+from nlbone.core.ports.translation import TranslationPort
+
+logger = logging.getLogger(__name__)
+
+
+class I18nAdapter(TranslationPort):
+    def __init__(self, loader: BaseLoader, default_locale: str = "fa-IR"):
+        self.default_locale = default_locale
+        self.loader = loader
+        self._translations: Optional[Dict[str, Dict[str, str]]] = None
+
+    def _ensure_loaded(self):
+        if self._translations is None:
+            self._translations = self.loader.load()
+
+    def translate(self, key: str, locale: Optional[str] = None, **kwargs) -> str:
+        target_locale = locale or self.default_locale
+        try:
+            self._ensure_loaded()
+
+            locale_data = self._translations.get(target_locale, {})
+            text = locale_data.get(key)
+
+            if text is None:
+                text = self._translations.get(self.default_locale, {}).get(key, key)
+
+            if kwargs:
+                try:
+                    return text.format(**kwargs)
+                except KeyError:
+                    pass
+            return text
+        except:
+            logger.exception("Failed to translate key '{}' to locale '{}'".format(key, target_locale))
+            return key

nlbone-0.8.0/src/nlbone/adapters/i18n/locales/fa-IR.json

@@ -0,0 +1,5 @@
+{
+  "auth": {
+    "otp_sent": "کد تایید برای {mobile} ارسال شد."
+  }
+}

nlbone-0.8.0/src/nlbone/interfaces/api/exception_handlers.py

@@ -0,0 +1,166 @@
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, List
+from uuid import uuid4
+
+from fastapi import FastAPI, Request
+from fastapi import HTTPException as FastAPIHTTPException
+from fastapi.exceptions import RequestValidationError
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, ValidationError
+from starlette.exceptions import HTTPException as StarletteHTTPException
+from starlette.status import HTTP_500_INTERNAL_SERVER_ERROR, HTTP_422_UNPROCESSABLE_ENTITY
+
+from nlbone.adapters.i18n import translator as _
+from .exceptions import BaseHttpException, ErrorDetail, UnprocessableEntityException
+
+
+class ErrorResponse(BaseModel):
+    message: str
+    errors: List[ErrorDetail]
+
+
+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,
+        content: Any,
+        trace_id: Optional[str] = None,
+        headers: Optional[Mapping[str, str]] = None,
+) -> JSONResponse:
+    tid = trace_id or _ensure_trace_id(request)
+
+    if isinstance(content, dict):
+        payload = content
+    else:
+        payload = content.model_dump(exclude_none=True) if hasattr(content, "model_dump") else content
+
+    payload["trace_id"] = tid
+
+    base_headers = {"X-Trace-Id": tid}
+    if headers:
+        base_headers.update(headers)
+
+    return JSONResponse(
+        status_code=status_code,
+        content=payload,
+        headers=base_headers
+    )
+
+
+def install_exception_handlers(
+        app: FastAPI,
+        *,
+        logger: Any = None,
+        expose_server_errors: bool = False,
+) -> None:
+    async def _log_exception(
+            request: Request,
+            exc: Exception,
+            level: str = "warning",
+            extra: Optional[dict] = None
+    ):
+        if not logger:
+            return
+
+        log_payload = {
+            "path": request.url.path,
+            "method": request.method,
+            **extra
+        } if extra else {"path": request.url.path}
+
+        log_method = getattr(logger, level, logger.warning)
+        log_method(str(exc), extra=log_payload)
+
+    @app.exception_handler(BaseHttpException)
+    async def _handle_base_http_exception(request: Request, exc: BaseHttpException):
+        await _log_exception(request, exc, extra={"status": exc.status_code, "detail": exc.message})
+
+        locale = getattr(request.state, "locale", None)
+
+        main_message = _(exc.message, locale=locale)
+
+        translated_errors = []
+        if exc.errors:
+            for err in exc.errors:
+                err_copy = err.model_copy()
+                if err_copy.message:
+                    err_copy.message = _(err_copy.message, locale=locale)
+                translated_errors.append(err_copy)
+
+        response_model = ErrorResponse(
+            message=main_message,
+            errors=translated_errors
+        )
+
+        return _json_response(request, exc.status_code, content=response_model)
+
+    @app.exception_handler(RequestValidationError)
+    async def _handle_request_validation_error(request: Request, exc: RequestValidationError):
+        await _log_exception(request, exc, level="info", extra={"errors": exc.errors()})
+
+        normalized_exception = UnprocessableEntityException(
+            detail="Validation Error",
+            validation_errors=exc.errors()
+        )
+        return await _handle_base_http_exception(request, normalized_exception)
+
+    @app.exception_handler(ValidationError)
+    async def _handle_pydantic_validation_error(request: Request, exc: ValidationError):
+        await _log_exception(request, exc, level="info", extra={"errors": exc.errors()})
+
+        normalized_exception = UnprocessableEntityException(
+            detail="Validation Error",
+            validation_errors=exc.errors()
+        )
+        return await _handle_base_http_exception(request, normalized_exception)
+
+    @app.exception_handler(StarletteHTTPException)
+    async def _handle_starlette_http_exception(request: Request, exc: StarletteHTTPException):
+        await _log_exception(request, exc, extra={"status": exc.status_code})
+
+        locale = getattr(request.state, "locale", None)
+        message_str = str(exc.detail) if exc.detail else "HTTP Error"
+        translated_message = _(message_str, locale=locale)
+
+        error_detail = ErrorDetail(
+            code=exc.status_code,
+            message=translated_message
+        )
+
+        response_model = ErrorResponse(
+            message=translated_message,
+            errors=[error_detail]
+        )
+
+        return _json_response(request, exc.status_code, content=response_model)
+
+    @app.exception_handler(Exception)
+    async def _handle_unexpected_exception(request: Request, exc: Exception):
+        tid = _ensure_trace_id(request)
+        await _log_exception(request, exc, level="exception", extra={"trace_id": tid})
+
+        raw_detail = str(exc) if expose_server_errors else "Internal Server Error"
+        locale = getattr(request.state, "locale", None)
+        translated_detail = _(raw_detail, locale=locale)
+
+        error_detail = ErrorDetail(
+            code=HTTP_500_INTERNAL_SERVER_ERROR,
+            message=translated_detail
+        )
+
+        response_model = ErrorResponse(
+            message=translated_detail,
+            errors=[error_detail]
+        )
+
+        return _json_response(
+            request,
+            HTTP_500_INTERNAL_SERVER_ERROR,
+            content=response_model,
+            trace_id=tid
+        )

nlbone-0.8.0/src/nlbone/interfaces/api/exceptions.py

@@ -0,0 +1,153 @@
+from http import HTTPStatus
+from typing import Any, Dict, List, Optional, Union
+
+from fastapi import HTTPException
+from pydantic import BaseModel, Field
+
+
+class ErrorDetail(BaseModel):
+    code: int | str = 0
+    message: Optional[str] = None
+    fields: Optional[Union[List[Union[str, int]], str]] = None
+    data: Optional[Union[List[Dict], Dict]] = None
+
+
+class BaseHttpException(HTTPException):
+    def __init__(
+            self,
+            status_code: int,
+            detail: Optional[str] = None,
+            errors: Optional[List[ErrorDetail]] = None,
+            fields: Optional[Union[List[Union[str, int]], str]] = None,
+            data: Optional[Dict] = None,
+            code: Optional[str] = None,
+    ):
+        if errors is None:
+            message = detail or HTTPStatus(status_code).phrase
+
+            if not code:
+                code = HTTPStatus(status_code).phrase.lower().replace(" ", "_")
+
+            errors = [
+                ErrorDetail(
+                    code=code,
+                    message=message,
+                    fields=fields,
+                    data=data
+                )
+            ]
+
+        self.errors = errors
+        super().__init__(status_code=status_code, detail=self.message)
+
+    @property
+    def message(self) -> str:
+        if self.errors and self.errors[0].message:
+            return self.errors[0].message
+        return HTTPStatus(self.status_code).phrase
+
+
+class UnprocessableEntityException(BaseHttpException):
+    def __init__(
+            self,
+            detail: str = None,
+            fields: Optional[Union[List[Union[str, int]], str]] = None,
+            validation_errors: Optional[List[Dict[str, Any]]] = None
+    ):
+        errors = None
+
+        if validation_errors:
+            errors = []
+            for error in validation_errors:
+                err_type = error.get("type")
+                loc = error.get("loc")
+                msg = error.get("msg")
+                inp = error.get("input")
+
+                if err_type == "json_invalid":
+                    loc = ["body"]
+                    msg = "Invalid JSON format. Please check your syntax (e.g., convert '۱' to '1')."
+
+                elif isinstance(loc, tuple):
+                    loc = list(loc)
+
+                error_data = {}
+                if inp is not None and not (isinstance(inp, dict) and not inp):
+                    error_data["input"] = inp
+
+                errors.append(
+                    ErrorDetail(
+                        code=err_type or "validation_error",
+                        message=msg,
+                        fields=loc,
+                        data=error_data if error_data else None
+                    )
+                )
+
+        super().__init__(
+            status_code=HTTPStatus.UNPROCESSABLE_ENTITY,
+            detail=detail,
+            fields=fields,
+            errors=errors
+        )
+
+
+class BadRequestException(BaseHttpException):
+    def __init__(self, detail: str = None, code: int = 0):
+        super().__init__(status_code=HTTPStatus.BAD_REQUEST, detail=detail, code=code)
+
+
+class UnauthorizedException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.UNAUTHORIZED, detail=detail)
+
+
+class ForbiddenException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.FORBIDDEN, detail=detail)
+
+
+class NotFoundException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.NOT_FOUND, detail=detail)
+
+
+class ConflictException(BaseHttpException):
+    def __init__(self, detail: str = None, data: Optional[Union[List[Dict], Dict]] = None):
+        super().__init__(status_code=HTTPStatus.CONFLICT, detail=detail, data=data)
+
+
+class NotSupportedException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.NOT_IMPLEMENTED, detail=detail)
+
+
+class InternalServerException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.INTERNAL_SERVER_ERROR, detail=detail)
+
+
+class LogicalValidationException(UnprocessableEntityException):
+    def __init__(self, detail: str = None,
+                 fields: Optional[Union[List[str], str]] = None,
+                 validation_errors: Optional[List[Dict[str, Any]]] = None):
+        super().__init__(
+            detail=detail,
+            fields=fields,
+            validation_errors=validation_errors
+        )
+
+
+class GoneException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.GONE, detail=detail)
+
+
+class TooManyRequestsException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.TOO_MANY_REQUESTS, detail=detail)
+
+
+class NotAcceptableException(BaseHttpException):
+    def __init__(self, detail: str = None):
+        super().__init__(status_code=HTTPStatus.NOT_ACCEPTABLE, detail=detail)

{nlbone-0.7.31 → nlbone-0.8.0}/src/nlbone/interfaces/api/schemas.py

@@ -3,3 +3,4 @@ from nlbone.interfaces.api.schema import BaseResponseModel
 
 class FileOut(BaseResponseModel):
     url: str
+    id: int | str = None

nlbone-0.8.0/src/nlbone/utils/flatten_dict.py

@@ -0,0 +1,9 @@
+def flatten_dict(d, parent_key='', sep='.'):
+    items = {}
+    for k, v in d.items():
+        new_key = f"{parent_key}{sep}{k}" if parent_key else k
+        if isinstance(v, dict):
+            items.update(flatten_dict(v, new_key, sep))
+        else:
+            items[new_key] = v
+    return items

nlbone-0.7.31/src/nlbone/adapters/i18n/engine.py

@@ -1,35 +0,0 @@
-from typing import Dict, Optional
-
-from nlbone.core.ports.translation import TranslationPort
-from nlbone.utils.context import get_locale
-
-from .loaders import BaseLoader
-
-
-class I18nAdapter(TranslationPort):
-    def __init__(self, loader: BaseLoader, default_locale: str = "fa-IR"):
-        self.default_locale = default_locale
-        self.loader = loader
-        self._translations: Optional[Dict[str, Dict[str, str]]] = None
-
-    def _ensure_loaded(self):
-        if self._translations is None:
-            self._translations = self.loader.load()
-
-    def translate(self, key: str, locale: Optional[str] = None, **kwargs) -> str:
-        self._ensure_loaded()
-
-        target_locale = locale or self.default_locale
-
-        locale_data = self._translations.get(target_locale, {})
-        text = locale_data.get(key)
-
-        if text is None:
-            text = self._translations.get(self.default_locale, {}).get(key, key)
-
-        if kwargs:
-            try:
-                return text.format(**kwargs)
-            except KeyError:
-                pass
-        return text

nlbone-0.7.31/src/nlbone/adapters/i18n/locales/fa-IR.json

@@ -1,10 +0,0 @@
-{
-  "auth": {
-    "otp_sent": "کد تایید برای {mobile} ارسال شد."
-  },
-  "order": {
-    "remove": {
-      "forbidden": "شما مجاز به حذف این سفارش نیستید"
-    }
-  }
-}

nlbone-0.7.31/src/nlbone/interfaces/api/exception_handlers.py

@@ -1,114 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Mapping, Optional
-from uuid import uuid4
-
-from fastapi import FastAPI, Request
-from fastapi import HTTPException as FastAPIHTTPException
-from fastapi.exceptions import RequestValidationError
-from fastapi.responses import JSONResponse
-from pydantic import ValidationError
-from starlette.exceptions import HTTPException as StarletteHTTPException
-
-from .exceptions import BaseHttpException
-
-from nlbone.adapters.i18n import translator as _
-# ---- 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,
-) -> JSONResponse:
-    payload: dict[str, Any] = {"detail": detail}
-    if extra:
-        payload.update(extra)
-    tid = trace_id or _ensure_trace_id(request)
-
-    payload.setdefault("trace_id", tid)
-
-    base_headers = {"X-Trace-Id": tid}
-    if headers:
-        base_headers.update(headers)
-
-    return JSONResponse(status_code=status_code, content=payload, headers=base_headers)
-
-
-# ---- Public Installer ------------------------------------------------------
-
-
-def install_exception_handlers(
-    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):
-        if logger:
-            logger.warning(
-                "http_error",
-                extra={"status": exc.status_code, "detail": exc.detail, "path": request.url.path},
-            )
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, exc.status_code, detail=_(exc.detail, locale=locale))
-
-    @app.exception_handler(FastAPIHTTPException)
-    async def _handle_fastapi_http_exception(request: Request, exc: FastAPIHTTPException):
-        if logger:
-            logger.warning(
-                "fastapi_http_error",
-                extra={"status": exc.status_code, "detail": exc.detail, "path": request.url.path},
-            )
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, exc.status_code, detail=_(exc.detail, locale=locale))
-
-    @app.exception_handler(StarletteHTTPException)
-    async def _handle_starlette_http_exception(request: Request, exc: StarletteHTTPException):
-        if logger:
-            logger.warning(
-                "starlette_http_error",
-                extra={"status": exc.status_code, "detail": exc.detail, "path": request.url.path},
-            )
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, exc.status_code, detail=_(exc.detail, locale=locale))
-
-    # 3) خطاهای اعتبارسنجی FastAPI (request body/query/path)
-    @app.exception_handler(RequestValidationError)
-    async def _handle_request_validation_error(request: Request, exc: RequestValidationError):
-        errors = exc.errors()
-        if logger:
-            logger.info(
-                "request_validation_error",
-                extra={"errors": errors, "path": request.url.path},
-            )
-        return _json_response(request, 422, detail=errors)
-
-    @app.exception_handler(ValidationError)
-    async def _handle_pydantic_validation_error(request: Request, exc: ValidationError):
-        errors = exc.errors()
-        if logger:
-            logger.info(
-                "pydantic_validation_error",
-                extra={"errors": errors, "path": request.url.path},
-            )
-        return _json_response(request, 422, detail=errors)
-
-    @app.exception_handler(Exception)
-    async def _handle_unexpected_exception(request: Request, exc: Exception):
-        tid = _ensure_trace_id(request)
-        if logger:
-            logger.exception("unhandled_exception", extra={"trace_id": tid, "path": request.url.path})
-        detail = str(exc) if expose_server_errors else "internal server error"
-        locale = locale = getattr(request.state, "locale", None)
-        return _json_response(request, 500, detail=_(detail, locale=locale), trace_id=tid)

nlbone-0.7.31/src/nlbone/interfaces/api/exceptions.py

@@ -1,108 +0,0 @@
-from typing import Any, Iterable, Dict, List
-
-from fastapi import HTTPException, status
-
-
-def _error_entry(loc: Iterable[Any] | None, detail: str, type_: str) -> dict:
-    return {
-        "loc": list(loc) if loc else [],
-        "msg": detail,
-        "type": type_,
-    }
-
-
-def _errors(loc: Iterable[Any] | None, detail: str, type_: str) -> list[dict]:
-    return [_error_entry(loc, detail, type_)]
-
-
-class BaseHttpException(HTTPException):
-    pass
-
-
-class BadRequestException(BaseHttpException):
-    def __init__(self, detail: str):
-        super().__init__(
-            status_code=status.HTTP_400_BAD_REQUEST,
-            detail=detail,
-        )
-
-
-class UnauthorizedException(BaseHttpException):
-    def __init__(self, detail: str = "unauthorized"):
-        super().__init__(
-            status_code=status.HTTP_401_UNAUTHORIZED,
-            detail=detail,
-        )
-
-
-class ForbiddenException(BaseHttpException):
-    def __init__(self, detail: str = "forbidden"):
-        super().__init__(
-            status_code=status.HTTP_403_FORBIDDEN,
-            detail=detail,
-        )
-
-
-class NotFoundException(BaseHttpException):
-    def __init__(self, detail: str = "not found"):
-        super().__init__(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=detail,
-        )
-
-
-class ConflictException(BaseHttpException):
-    def __init__(self, detail: str = "conflict"):
-        super().__init__(
-            status_code=status.HTTP_409_CONFLICT,
-            detail=detail,
-        )
-
-
-class NotSupportedException(BaseHttpException):
-    def __init__(self, detail: str = "NotSupported"):
-        super().__init__(
-            status_code=status.HTTP_501_NOT_IMPLEMENTED,
-            detail=detail,
-        )
-
-
-class InternalServerException(BaseHttpException):
-    def __init__(self, detail: str = "internal_server_error"):
-        super().__init__(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=detail,
-        )
-
-
-class UnprocessableEntityException(BaseHttpException):
-    def __init__(self, detail: str, loc: Iterable[Any] | None = None, type_: str = "unprocessable_entity"):
-        super().__init__(
-            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
-            detail=_errors(loc, detail, type_),
-        )
-
-
-class LogicalValidationException(HTTPException):
-    def __init__(self, detail: str = None, loc: Iterable[Any] | None = None, type_: str = "logical_error",
-                 errors: List[Dict[str, Any]] = None):
-        self.errors = errors
-        if errors:
-            super().__init__(detail=errors, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,)
-        else:
-            super().__init__(detail=_errors(loc, detail, type_), status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
-
-
-class GoneException(BaseHttpException):
-    def __init__(self, detail: str = "Gone"):
-        super().__init__(
-            status_code=status.HTTP_410_GONE,
-            detail=detail,
-        )
-
-class TooManyRequestsException(BaseHttpException):
-    def __init__(self, detail: str = "TooManyRequests"):
-        super().__init__(
-            status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-            detail=detail,
-        )