django-ninja-problems 0.1.0__py3-none-any.whl

django_ninja_problems/__init__.py

@@ -0,0 +1,26 @@
+from .exceptions import (
+    BadRequestProblem,
+    ConflictProblem,
+    ForbiddenProblem,
+    NotFoundProblem,
+    ProblemException,
+    UnauthorizedProblem,
+    UnprocessableEntityProblem,
+)
+from .handlers import create_problem_response
+from .registrar import register_problem_handlers
+from .schemas import ErrorItem, ProblemDetails
+
+__all__ = [
+    "BadRequestProblem",
+    "ConflictProblem",
+    "ErrorItem",
+    "ForbiddenProblem",
+    "NotFoundProblem",
+    "ProblemDetails",
+    "ProblemException",
+    "UnauthorizedProblem",
+    "UnprocessableEntityProblem",
+    "create_problem_response",
+    "register_problem_handlers",
+]

django_ninja_problems/exceptions.py

@@ -0,0 +1,113 @@
+from typing import Any
+from .schemas import ErrorItem
+
+
+class ProblemException(Exception):
+    def __init__(
+        self,
+        status: int = 500,
+        title: str = "Internal Server Error",
+        detail: str | None = None,
+        type: str = "about:blank",
+        instance: str | None = None,
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        self.status = status
+        self.title = title
+        self.detail = detail
+        self.type = type
+        self.instance = instance
+        self.errors = errors
+        self.extra = extra
+        super().__init__(detail or title)
+
+
+class BadRequestProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = None,
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=400,
+            title="Bad Request",
+            detail=detail,
+            errors=errors,
+            **extra,
+        )
+
+
+class UnauthorizedProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "Authentication credentials were not provided or are invalid.",
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=401,
+            title="Unauthorized",
+            detail=detail,
+            **extra,
+        )
+
+
+class ForbiddenProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "You do not have permission to perform this action.",
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=403,
+            title="Forbidden",
+            detail=detail,
+            **extra,
+        )
+
+
+class NotFoundProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "The requested resource was not found.",
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=404,
+            title="Not Found",
+            detail=detail,
+            **extra,
+        )
+
+
+class ConflictProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "A conflict occurred with the current state of the resource.",
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=409,
+            title="Conflict",
+            detail=detail,
+            errors=errors,
+            **extra,
+        )
+
+
+class UnprocessableEntityProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "Unable to process the contained instructions.",
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=422,
+            title="Unprocessable Entity",
+            detail=detail,
+            errors=errors,
+            **extra,
+        )

django_ninja_problems/formatters.py

@@ -0,0 +1,94 @@
+import re
+from typing import Any
+from django.core.exceptions import ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from .schemas import ErrorItem
+
+
+def format_pydantic_location(location: tuple[Any, ...]) -> str:
+    parts = [str(item) for item in location if str(item) not in {"body", "query", "path", "header", "cookie"}]
+    return ".".join(parts) if parts else ".".join(str(item) for item in location)
+
+
+def format_pydantic_errors(errors: list[dict[str, Any]]) -> list[ErrorItem]:
+    formatted: list[ErrorItem] = []
+    for error in errors:
+        loc = error.get("loc", ())
+        field = format_pydantic_location(loc)
+        message = str(error.get("msg", "Invalid value"))
+        code = str(error.get("type", "value_error"))
+        formatted.append(ErrorItem(field=field, message=message, code=code))
+    return formatted
+
+
+def format_django_validation_error(exc: DjangoValidationError) -> list[ErrorItem]:
+    formatted: list[ErrorItem] = []
+    if hasattr(exc, "error_dict"):
+        for field, error_list in exc.error_dict.items():
+            for item in error_list:
+                formatted.append(
+                    ErrorItem(
+                        field=field,
+                        message=str(item.message if hasattr(item, "message") else item),
+                        code=getattr(item, "code", "invalid"),
+                    )
+                )
+        return formatted
+
+    if hasattr(exc, "error_list"):
+        for item in exc.error_list:
+            formatted.append(
+                ErrorItem(
+                    field=None,
+                    message=str(item.message if hasattr(item, "message") else item),
+                    code=getattr(item, "code", "invalid"),
+                )
+            )
+        return formatted
+
+    for message in exc.messages:
+        formatted.append(ErrorItem(field=None, message=str(message), code="invalid"))
+    return formatted
+
+
+def is_unique_constraint_violation(exc: Exception) -> bool:
+    if isinstance(exc, DjangoValidationError):
+        if hasattr(exc, "error_dict"):
+            for errors in exc.error_dict.values():
+                for error in errors:
+                    if getattr(error, "code", None) == "unique":
+                        return True
+        return False
+
+    if isinstance(exc, IntegrityError):
+        message = str(exc).lower()
+        unique_indicators = [
+            "unique constraint",
+            "duplicate key",
+            "already exists",
+            "unique_violation",
+        ]
+        return any(indicator in message for indicator in unique_indicators)
+
+    return False
+
+
+def format_integrity_error_detail(exc: IntegrityError) -> str:
+    message = str(exc)
+    lower_message = message.lower()
+
+    if "unique constraint" in lower_message or "duplicate key" in lower_message:
+        match = re.search(r"Key \((.*?)\)=\((.*?)\) already exists", message)
+        if match:
+            field_name, field_value = match.groups()
+            return f"A record with {field_name} '{field_value}' already exists."
+        match = re.search(r"UNIQUE constraint failed: (.*)", message)
+        if match:
+            column = match.group(1).split(".")[-1]
+            return f"A record with this {column} already exists."
+        return "A record with identical unique fields already exists."
+
+    if "foreign key constraint" in lower_message or "foreign_key_violation" in lower_message:
+        return "Referenced resource does not exist or cannot be modified due to dependent records."
+
+    return "A database integrity constraint was violated."

django_ninja_problems/handlers.py

@@ -0,0 +1,186 @@
+from http import HTTPStatus
+from typing import Any
+from django.core.exceptions import ObjectDoesNotExist, ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from django.http import Http404, HttpRequest, HttpResponse
+from ninja import NinjaAPI
+from ninja.errors import HttpError, ValidationError as NinjaValidationError
+from pydantic import ValidationError as PydanticValidationError
+
+from .exceptions import ProblemException
+from .formatters import (
+    format_django_validation_error,
+    format_integrity_error_detail,
+    format_pydantic_errors,
+    is_unique_constraint_violation,
+)
+from .schemas import ProblemDetails
+
+
+def resolve_http_title(status_code: int) -> str:
+    try:
+        return HTTPStatus(status_code).phrase
+    except ValueError:
+        return "HTTP Error"
+
+
+def create_problem_response(
+    api: NinjaAPI,
+    request: HttpRequest,
+    problem: ProblemDetails,
+) -> HttpResponse:
+    payload = problem.model_dump(exclude_none=True)
+    response = api.create_response(request, payload, status=problem.status)
+    response["Content-Type"] = "application/problem+json"
+    return response
+
+
+def handle_problem_exception(
+    request: HttpRequest,
+    exc: ProblemException,
+    api: NinjaAPI,
+) -> HttpResponse:
+    problem = ProblemDetails(
+        type=exc.type,
+        title=exc.title,
+        status=exc.status,
+        detail=exc.detail,
+        instance=exc.instance or request.path,
+        errors=exc.errors,
+        **exc.extra,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_http_error(
+    request: HttpRequest,
+    exc: HttpError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    status_code = exc.status_code
+    detail = None
+    title = resolve_http_title(status_code)
+
+    if isinstance(exc.message, str):
+        detail = exc.message
+    elif isinstance(exc.message, dict):
+        detail = exc.message.get("detail") or exc.message.get("texto") or str(exc.message)
+        title = exc.message.get("title") or exc.message.get("titulo") or title
+
+    problem = ProblemDetails(
+        title=title,
+        status=status_code,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_not_found(
+    request: HttpRequest,
+    exc: Http404 | ObjectDoesNotExist,
+    api: NinjaAPI,
+) -> HttpResponse:
+    detail_message = str(exc)
+    detail = detail_message if detail_message and not detail_message.startswith("<") else "The requested resource was not found."
+    problem = ProblemDetails(
+        title="Not Found",
+        status=404,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_ninja_validation_error(
+    request: HttpRequest,
+    exc: NinjaValidationError | PydanticValidationError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    raw_errors = exc.errors() if callable(getattr(exc, "errors", None)) else getattr(exc, "errors", [])
+    errors = format_pydantic_errors(raw_errors if isinstance(raw_errors, list) else [])
+    problem = ProblemDetails(
+        title="Unprocessable Entity",
+        status=422,
+        detail="The request body or parameters failed validation.",
+        instance=request.path,
+        errors=errors,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_django_validation_error(
+    request: HttpRequest,
+    exc: DjangoValidationError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    errors = format_django_validation_error(exc)
+    if is_unique_constraint_violation(exc):
+        problem = ProblemDetails(
+            title="Conflict",
+            status=409,
+            detail="A record with conflicting unique values already exists.",
+            instance=request.path,
+            errors=errors,
+        )
+        return create_problem_response(api, request, problem)
+
+    problem = ProblemDetails(
+        title="Bad Request",
+        status=400,
+        detail="The submitted data failed validation.",
+        instance=request.path,
+        errors=errors,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_integrity_error(
+    request: HttpRequest,
+    exc: IntegrityError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    detail = format_integrity_error_detail(exc)
+    problem = ProblemDetails(
+        title="Conflict",
+        status=409,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_authentication_error(
+    request: HttpRequest,
+    exc: Exception,
+    api: NinjaAPI,
+) -> HttpResponse:
+    if isinstance(exc, HttpError) and exc.message:
+        detail = exc.message if isinstance(exc.message, str) else str(exc.message)
+    elif str(exc):
+        detail = str(exc)
+    else:
+        detail = "Authentication credentials were not provided or are invalid."
+
+    problem = ProblemDetails(
+        title="Unauthorized",
+        status=401,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_unexpected_exception(
+    request: HttpRequest,
+    exc: Exception,
+    api: NinjaAPI,
+    debug: bool,
+) -> HttpResponse:
+    problem = ProblemDetails(
+        title="Internal Server Error",
+        status=500,
+        detail=f"{type(exc).__name__}: {exc}" if debug else "An unexpected error occurred while processing the request.",
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)

django_ninja_problems/registrar.py

@@ -0,0 +1,83 @@
+from typing import Any, Callable
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from django.http import Http404, HttpRequest, HttpResponse
+from ninja import NinjaAPI
+from ninja.errors import AuthenticationError, HttpError, ValidationError as NinjaValidationError
+from pydantic import ValidationError as PydanticValidationError
+
+from .exceptions import ProblemException
+from .handlers import (
+    handle_authentication_error,
+    handle_django_validation_error,
+    handle_http_error,
+    handle_integrity_error,
+    handle_ninja_validation_error,
+    handle_not_found,
+    handle_problem_exception,
+    handle_unexpected_exception,
+)
+
+
+def register_problem_handlers(
+    api: NinjaAPI,
+    *,
+    debug: bool | None = None,
+    auth_exceptions: tuple[type[Exception], ...] | None = None,
+    custom_handlers: dict[type[Exception], Callable[[HttpRequest, Any], HttpResponse]] | None = None,
+) -> None:
+    is_debug = getattr(settings, "DEBUG", False) if debug is None else debug
+
+    api.add_exception_handler(
+        ProblemException,
+        lambda request, exc: handle_problem_exception(request, exc, api),
+    )
+    api.add_exception_handler(
+        HttpError,
+        lambda request, exc: handle_http_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        Http404,
+        lambda request, exc: handle_not_found(request, exc, api),
+    )
+    api.add_exception_handler(
+        ObjectDoesNotExist,
+        lambda request, exc: handle_not_found(request, exc, api),
+    )
+    api.add_exception_handler(
+        NinjaValidationError,
+        lambda request, exc: handle_ninja_validation_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        PydanticValidationError,
+        lambda request, exc: handle_ninja_validation_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        DjangoValidationError,
+        lambda request, exc: handle_django_validation_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        IntegrityError,
+        lambda request, exc: handle_integrity_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        AuthenticationError,
+        lambda request, exc: handle_authentication_error(request, exc, api),
+    )
+
+    if auth_exceptions:
+        for auth_exc in auth_exceptions:
+            api.add_exception_handler(
+                auth_exc,
+                lambda request, exc: handle_authentication_error(request, exc, api),
+            )
+
+    if custom_handlers:
+        for exc_class, handler in custom_handlers.items():
+            api.add_exception_handler(exc_class, handler)
+
+    api.add_exception_handler(
+        Exception,
+        lambda request, exc: handle_unexpected_exception(request, exc, api, is_debug),
+    )

django_ninja_problems/schemas.py

@@ -0,0 +1,19 @@
+from typing import Any
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ErrorItem(BaseModel):
+    field: str | None = None
+    message: str
+    code: str | None = None
+
+
+class ProblemDetails(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    type: str = "about:blank"
+    title: str
+    status: int
+    detail: str | None = None
+    instance: str | None = None
+    errors: list[ErrorItem] | None = None

django_ninja_problems-0.1.0.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: django-ninja-problems
+Version: 0.1.0
+Summary: RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs
+Author: Jansem
+License-Expression: MIT
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: django-ninja>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-django>=4.8.0; extra == "dev"
+Dynamic: license-file
+
+# django-ninja-problems
+
+RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs.
+
+## Installation
+
+```bash
+pip install django-ninja-problems
+```
+
+## Quick Start
+
+```python
+from ninja import NinjaAPI
+from django_ninja_problems import register_problem_handlers
+
+api = NinjaAPI()
+register_problem_handlers(api)
+```
+
+## Supported Exceptions
+
+- `ninja.errors.HttpError`
+- `django.http.Http404` and `ObjectDoesNotExist`
+- `ninja.errors.ValidationError` and `pydantic.ValidationError` (HTTP 422)
+- `django.core.exceptions.ValidationError` (HTTP 400 or 409)
+- `django.db.IntegrityError` (HTTP 409)
+- Custom authentication exceptions (HTTP 401)
+- Unexpected `Exception` (HTTP 500 masked in production)

django_ninja_problems-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+django_ninja_problems/__init__.py,sha256=8aAVvbieG1HfGTn-3c_5_7l22VvX7E5c3-pONn6b32s,634
+django_ninja_problems/exceptions.py,sha256=UpqnY8Aoj0j_Xwn2bzmAkdrDqhuNFHYd4dYh9q2Kn8E,2840
+django_ninja_problems/formatters.py,sha256=GKWo0bFsIANcOg946woGQjFDITwyTor7on9TYzvp0bY,3595
+django_ninja_problems/handlers.py,sha256=bGq5FDY4Xw4PrFj_LqAiiSvWIg3MZc7wyKGAXfi2dVs,5509
+django_ninja_problems/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+django_ninja_problems/registrar.py,sha256=rJCQJx82s45JMcset0729Z35XEQkc9V-8lRZ8TOp__Q,2845
+django_ninja_problems/schemas.py,sha256=mahDc3JH6GGRi5xK7znhIa-1-pf67cKmpZiNquv81wA,423
+django_ninja_problems-0.1.0.dist-info/licenses/LICENSE,sha256=BmH9uq40Gg695-P1cfM64VP7cbaTEUuXFvyHa6esZpA,1063
+django_ninja_problems-0.1.0.dist-info/METADATA,sha256=q3x_drtKAjgHv4Dxeas3tXNW2OqMupFTGEqm4xz0_bg,1312
+django_ninja_problems-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+django_ninja_problems-0.1.0.dist-info/top_level.txt,sha256=pzrLek-hSNGIEIHUHLVVnGwMMToO-hwcIwYUaCsFx50,22
+django_ninja_problems-0.1.0.dist-info/RECORD,,

django_ninja_problems-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

django_ninja_problems-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jansem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_ninja_problems-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+django_ninja_problems