contentgrid-extension-helpers 0.0.1__tar.gz → 0.0.2__tar.gz

{contentgrid_extension_helpers-0.0.1/src/contentgrid_extension_helpers.egg-info → contentgrid_extension_helpers-0.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: contentgrid-extension-helpers
-Version: 0.0.1
+Version: 0.0.2
 Summary: Helper functions for contentgrid extensions.
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions
@@ -26,6 +26,7 @@ Requires-Dist: requests<3,>=2.20.0
 Requires-Dist: uri-template<2
 Requires-Dist: fastapi>=0.111
 Requires-Dist: PyJWT>2
+Requires-Dist: contentgrid_hal_client>=0.0.10
 
 ### ContentGrid-Extension-Helpers
 

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2}/pyproject.toml

@@ -20,7 +20,8 @@ dependencies = [
     "requests >= 2.20.0, < 3",
     "uri-template < 2",
     "fastapi >= 0.111",
-    "PyJWT > 2"
+    "PyJWT > 2",
+    "contentgrid_hal_client >= 0.0.10",
 ]
 
 requires-python = ">=3.5"

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2}/requirements.txt

@@ -2,4 +2,5 @@ hyperlink==21.0.0
 Requests==2.31.0
 uri-template==1.3.0
 fastapi==0.111.1
-PyJWT==2.8.0
+PyJWT==2.8.0
+contentgrid_hal_client==0.0.12

contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers/__init__.py

@@ -0,0 +1,3 @@
+from .exceptions import LLMDenyException, ExtensionHelperException, IllegalActivityError, MissingInputError, InjectionError, MalformedInputError, NotRelatedError, SensitiveInformationError, SecurityError # noqa: F401
+from .middleware.exception_middleware import catch_exceptions_middleware # noqa: F401
+from .structured_output.model_deny import DenyReason, ModelDeny # noqa: F401

contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers/authentication/__init__.py

@@ -0,0 +1,2 @@
+from .oidc import create_current_user_dependency, decode_and_verify_token, create_oauth2_scheme, get_oauth_jwks_client, get_oidc_jwks_client # noqa: F401
+from .user import ContentGridUser # noqa: F401

contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers/exceptions.py

@@ -0,0 +1,48 @@
+
+class ExtensionHelperException(Exception):
+    """Base class for all custom exceptions in the extension helpers library."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class LLMDenyException(ExtensionHelperException):
+    """
+    Raised when the LLM denies a request based on its rules.
+    This is a base class for more specific denial reasons.
+    """
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class NotRelatedError(LLMDenyException):
+    """Raised when the input is unrelated to the required extraction."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class MissingInputError(LLMDenyException):
+    """Raised when required input is missing or empty."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class MalformedInputError(LLMDenyException):
+    """Raised when input is present but malformed or contains only strange characters."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class IllegalActivityError(LLMDenyException):
+    """Raised when the input describes illegal activities."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class SensitiveInformationError(LLMDenyException):
+    """Raised when the input contains sensitive information."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class SecurityError(LLMDenyException):
+    """Raised when the input attempts to compromise system security."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)
+
+class InjectionError(SecurityError):
+    """Raised when the input is a prompt injection attack."""
+    def __init__(self, *args: object) -> None:
+        super().__init__(*args)

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2}/src/contentgrid_extension_helpers/logging/__init__.py

@@ -1 +1 @@
-from .json_logging import setup_json_logging, XenitJsonFormatter
+from .json_logging import setup_json_logging, XenitJsonFormatter # noqa: F401

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2}/src/contentgrid_extension_helpers/logging/json_logging.py

@@ -2,7 +2,7 @@ import datetime
 import json
 import logging
 import time
-from typing import List, Optional, Any, Dict
+from typing import Optional, Any, Dict
 
 class XenitJsonFormatter(logging.Formatter):
     def __init__(
@@ -54,7 +54,7 @@ class XenitJsonFormatter(logging.Formatter):
 
 def setup_json_logging(
     component: str = "cg-extension", 
-    additional_keys: dict[str, str] = [], 
+    additional_keys: dict[str,str] = {}, 
     log_level: int = logging.DEBUG
 ) -> logging.Logger:
     """

contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers/middleware/exception_middleware.py

@@ -0,0 +1,124 @@
+from fastapi import Request, status
+import logging
+from contentgrid_extension_helpers.problem_response import ProblemResponse
+from contentgrid_hal_client.exceptions import (
+    NotFound,
+    Unauthorized,
+    BadRequest,
+    IncorrectAttributeType,
+    NonExistantAttribute,
+    MissingRequiredAttribute,
+    MissingHALTemplate,
+)
+from requests.exceptions import HTTPError
+from contentgrid_extension_helpers.exceptions import LLMDenyException
+
+async def catch_exceptions_middleware(request: Request, call_next, problem_base_url: str = "https://docs.contentgrid.com"):
+    """
+    Catches exceptions and returns ProblemResponse objects.
+
+    Args:
+        request: The incoming request.
+        call_next: The next middleware or route handler.
+        problem_base_url: The base URL for problem type URIs.
+    """
+
+    def format_type(type_name: str) -> str:
+        """Formats problem type URIs."""
+        return f"{problem_base_url}/{type_name}"
+    
+    cors_headers = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "*",
+        "Access-Control-Allow-Headers": "*, Authorization",
+    }
+    
+    try:
+        return await call_next(request)
+    except LLMDenyException as e:
+        logging.error(f"LLM denied request: {e}")
+        return ProblemResponse(
+            title="Request Denied",
+            problem_type=format_type("request-denied"),
+            detail=str(e),
+            status=status.HTTP_400_BAD_REQUEST,
+            headers=cors_headers,
+        )
+    except NotFound:
+        return ProblemResponse(
+            title="Not found",
+            problem_type=format_type("not-found"),
+            detail="Resource not found",
+            status=status.HTTP_404_NOT_FOUND,
+            headers=cors_headers,
+        )
+    except Unauthorized:
+        return ProblemResponse(
+            title="Unauthorized",
+            problem_type=format_type("unauthorized"),
+            detail="user is not authorized for requested resource",
+            status=status.HTTP_401_UNAUTHORIZED,
+            headers=cors_headers,
+        )
+    except BadRequest:
+        return ProblemResponse(
+            title="Bad Request",
+            problem_type=format_type("bad-request"),
+            detail="The request was malformed or invalid.",
+            status=status.HTTP_400_BAD_REQUEST,
+            headers=cors_headers,
+        )
+    except IncorrectAttributeType as e:
+        return ProblemResponse(
+            title="Incorrect Attribute Type",
+            problem_type=format_type("incorrect-attribute-type"),
+            detail=str(e),
+            status=status.HTTP_400_BAD_REQUEST,
+            headers=cors_headers,
+        )
+    except NonExistantAttribute as e:
+        return ProblemResponse(
+            title="Non-Existent Attribute",
+            problem_type=format_type("non-existent-attribute"),
+            detail=str(e),
+            status=status.HTTP_404_NOT_FOUND,
+            headers=cors_headers,
+        )
+    except MissingRequiredAttribute as e:
+        return ProblemResponse(
+            title="Missing Required Attribute",
+            problem_type=format_type("missing-required-attribute"),
+            detail=str(e),
+            status=status.HTTP_400_BAD_REQUEST,
+            headers=cors_headers,
+        )
+    except MissingHALTemplate as e:
+        return ProblemResponse(
+            title="Missing HAL Template",
+            problem_type=format_type("missing-hal-template"),
+            detail=str(e),
+            status=status.HTTP_404_NOT_FOUND,
+            headers=cors_headers,
+        )
+    except HTTPError as e:
+        logging.exception(f"HTTP Error: {str(e)}", exc_info=True)
+        return ProblemResponse(
+            title="HTTP Error",
+            problem_type=format_type("http-error"),
+            detail=f"An HTTP error occurred: {str(e)}",
+            status=e.response.status_code if e.response else status.HTTP_500_INTERNAL_SERVER_ERROR,
+            headers=cors_headers,
+        )
+    except Exception as e:
+        logging.exception(
+            f"Untyped exception caught in backend request...: {str(e)}",
+            exc_info=True,
+            stack_info=True,
+        )
+        return ProblemResponse(
+            title="Internal server error",
+            problem_type=format_type("unknown"),
+            detail=f"An unexpected error occurred: {str(e)}",
+            status=status.HTTP_500_INTERNAL_SERVER_ERROR,
+            headers=cors_headers,
+        )

contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers/problem_response.py

@@ -0,0 +1,45 @@
+from typing import Any, Dict, Mapping
+from fastapi.responses import JSONResponse
+
+
+def get_problem_dict(title: str | None, problem_type: str | None, status: int | None, detail: str | None, instance: str | None, **kwargs) -> Dict[str, Any]:
+    result: Dict[str, Any] = dict()
+    if title is not None:
+        result["title"] = title
+    if problem_type is not None:
+        result["type"] = problem_type
+    if status is not None:
+        result["status"] = status
+    if detail is not None:
+        result["detail"] = detail
+    if instance is not None:
+        result["instance"] = instance
+
+    for key, value in kwargs.items():
+        if key == "type":
+            raise ValueError(f"{key} is a reserved property name!")
+        result[key] = value
+
+    return result
+
+
+class ProblemResponse(JSONResponse):
+    def __init__(
+            self,
+            title: str | None = None,
+            problem_type: str | None = "about:blank",  # not 'type' because it is a built-in function
+            status: int = 400,
+            detail: str | None = None,
+            instance: str | None = None,
+            headers: Mapping[str, str] | None = None,
+            media_type: str | None = "application/problem+json",
+            background: Any | None = None,
+            **kwargs
+    ):
+        super().__init__(
+            get_problem_dict(title, problem_type, status, detail, instance, **kwargs),
+            status_code=status,
+            headers=headers,
+            media_type=media_type,
+            background=background
+        )

contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers/structured_output/model_deny.py

@@ -0,0 +1,45 @@
+from enum import Enum
+from pydantic import BaseModel, Field
+
+from contentgrid_extension_helpers import exceptions
+
+
+class DenyReason(Enum):
+    NOT_RELATED = "not_related"
+    MISSING_INPUT = "missing_input"
+    MALFORMED_INPUT = "malformed_input"
+    ILLEGAL_ACTIVITY = "illegal_activity"
+    SENSITIVE_INFORMATION = "sensitive_information"
+    SECURITY_ERROR = "security_error"
+    INJECTION_ATTEMPT = "injection_attempt"
+
+    def to_exception(self) -> type[exceptions.LLMDenyException]:
+        """Maps a DenyReason to its corresponding exception class."""
+        match self:
+            case DenyReason.NOT_RELATED:
+                return exceptions.NotRelatedError
+            case DenyReason.MISSING_INPUT:
+                return exceptions.MissingInputError
+            case DenyReason.MALFORMED_INPUT:
+                return exceptions.MalformedInputError
+            case DenyReason.ILLEGAL_ACTIVITY:
+                return exceptions.IllegalActivityError
+            case DenyReason.SENSITIVE_INFORMATION:
+                return exceptions.SensitiveInformationError
+            case DenyReason.SECURITY_ERROR:
+                return exceptions.SecurityError
+            case DenyReason.INJECTION_ATTEMPT:
+                return exceptions.InjectionError
+
+
+class ModelDeny(BaseModel):
+    deny_type: DenyReason = Field(description="Type of denial")
+    reason: str = Field(
+        description="Reason for denying the request. Should be a short sentence that can be shown to the user. Not longer than two lines"
+    )
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        # Raise the corresponding exception immediately
+        exception_class = self.deny_type.to_exception()
+        raise exception_class(self.reason)

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2/src/contentgrid_extension_helpers.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: contentgrid-extension-helpers
-Version: 0.0.1
+Version: 0.0.2
 Summary: Helper functions for contentgrid extensions.
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions
@@ -26,6 +26,7 @@ Requires-Dist: requests<3,>=2.20.0
 Requires-Dist: uri-template<2
 Requires-Dist: fastapi>=0.111
 Requires-Dist: PyJWT>2
+Requires-Dist: contentgrid_hal_client>=0.0.10
 
 ### ContentGrid-Extension-Helpers
 

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2}/src/contentgrid_extension_helpers.egg-info/SOURCES.txt

@@ -5,6 +5,8 @@ pytest.ini
 requirements.txt
 setup.py
 src/contentgrid_extension_helpers/__init__.py
+src/contentgrid_extension_helpers/exceptions.py
+src/contentgrid_extension_helpers/problem_response.py
 src/contentgrid_extension_helpers.egg-info/PKG-INFO
 src/contentgrid_extension_helpers.egg-info/SOURCES.txt
 src/contentgrid_extension_helpers.egg-info/dependency_links.txt
@@ -15,4 +17,7 @@ src/contentgrid_extension_helpers/authentication/oidc.py
 src/contentgrid_extension_helpers/authentication/user.py
 src/contentgrid_extension_helpers/logging/__init__.py
 src/contentgrid_extension_helpers/logging/json_logging.py
+src/contentgrid_extension_helpers/middleware/exception_middleware.py
+src/contentgrid_extension_helpers/structured_output/model_deny.py
+tests/test_exception_middleware.py
 tests/test_logging.py

{contentgrid_extension_helpers-0.0.1 → contentgrid_extension_helpers-0.0.2}/src/contentgrid_extension_helpers.egg-info/requires.txt

@@ -2,3 +2,4 @@ requests<3,>=2.20.0
 uri-template<2
 fastapi>=0.111
 PyJWT>2
+contentgrid_hal_client>=0.0.10

contentgrid_extension_helpers-0.0.2/tests/test_exception_middleware.py

@@ -0,0 +1,225 @@
+from fastapi import FastAPI, Request, status
+from fastapi.testclient import TestClient
+import pytest
+from unittest.mock import MagicMock
+
+from contentgrid_extension_helpers.middleware.exception_middleware import (
+    catch_exceptions_middleware,
+)
+from contentgrid_hal_client.exceptions import (
+    NotFound,
+    Unauthorized,
+    BadRequest,
+    IncorrectAttributeType,
+    NonExistantAttribute,
+    MissingRequiredAttribute,
+    MissingHALTemplate,
+)
+from requests.exceptions import HTTPError
+from contentgrid_extension_helpers.exceptions import LLMDenyException
+from contentgrid_extension_helpers.problem_response import ProblemResponse
+
+
+@pytest.fixture
+def app():
+    """Creates a FastAPI app with the exception middleware."""
+    app = FastAPI()
+
+    @app.middleware("http")
+    async def add_exception_middleware(request: Request, call_next):
+        return await catch_exceptions_middleware(request, call_next, "https://test.example.com")
+
+    return app
+
+
+@pytest.fixture
+def client(app):
+    """Provides a TestClient for the test app."""
+    return TestClient(app)
+
+
+def test_no_exception(client: TestClient):
+    """Tests the middleware when no exception is raised."""
+
+    @client.app.get("/no-error")
+    async def no_error():
+        return {"message": "OK"}
+
+    response = client.get("/no-error")
+    assert response.status_code == 200
+    assert response.json() == {"message": "OK"}
+
+
+def test_no_exception_with_origin(client: TestClient):
+    """Tests the middleware when no exception is raised and origin is present."""
+
+    @client.app.get("/no-error")
+    async def no_error():
+        return {"message": "OK"}
+
+    response = client.get("/no-error", headers={"Origin": "https://example.com"})
+    assert response.status_code == 200
+    assert response.json() == {"message": "OK"}
+
+
+def test_not_found_exception(client: TestClient):
+    """Tests the NotFound exception handling."""
+
+    @client.app.get("/not-found")
+    async def not_found():
+        raise NotFound()
+
+    response = client.get("/not-found")
+    assert response.status_code == 404
+    problem = response.json()
+    assert problem["title"] == "Not found"
+    assert problem["type"] == "https://test.example.com/not-found"
+
+
+def test_unauthorized_exception(client: TestClient):
+    """Tests the Unauthorized exception handling."""
+
+    @client.app.get("/unauthorized")
+    async def unauthorized():
+        raise Unauthorized()
+
+    response = client.get("/unauthorized", headers={"Origin": "https://example.com"})
+    assert response.status_code == 401
+    problem = response.json()
+    assert problem["title"] == "Unauthorized"
+    assert problem["type"] == "https://test.example.com/unauthorized"
+
+
+def test_bad_request_exception(client: TestClient):
+    """Tests the BadRequest exception handling."""
+
+    @client.app.get("/bad-request")
+    async def bad_request():
+        raise BadRequest()
+
+    response = client.get("/bad-request")
+    assert response.status_code == 400
+    problem = response.json()
+    assert problem["title"] == "Bad Request"
+    assert problem["type"] == "https://test.example.com/bad-request"
+
+
+def test_incorrect_attribute_type_exception(client: TestClient):
+    """Tests the IncorrectAttributeType exception handling."""
+
+    @client.app.get("/incorrect-attribute")
+    async def incorrect_attribute():
+        raise IncorrectAttributeType("Incorrect type")
+
+    response = client.get("/incorrect-attribute", headers={"Origin": "https://different.com"})
+    assert response.status_code == 400
+    problem = response.json()
+    assert problem["title"] == "Incorrect Attribute Type"
+    assert problem["type"] == "https://test.example.com/incorrect-attribute-type"
+    assert problem["detail"] == "Incorrect type"
+
+
+def test_non_existent_attribute_exception(client: TestClient):
+    """Tests the NonExistantAttribute exception handling."""
+
+    @client.app.get("/non-existent-attribute")
+    async def non_existent_attribute():
+        raise NonExistantAttribute("Attribute does not exist")
+
+    response = client.get("/non-existent-attribute")
+    assert response.status_code == 404
+    problem = response.json()
+    assert problem["title"] == "Non-Existent Attribute"
+    assert problem["type"] == "https://test.example.com/non-existent-attribute"
+    assert problem["detail"] == "Attribute does not exist"
+
+
+def test_missing_required_attribute_exception(client: TestClient):
+    """Tests the MissingRequiredAttribute exception handling."""
+
+    @client.app.get("/missing-required-attribute")
+    async def missing_required_attribute():
+        raise MissingRequiredAttribute("Missing attribute")
+
+    response = client.get("/missing-required-attribute")
+    assert response.status_code == 400
+    problem = response.json()
+    assert problem["title"] == "Missing Required Attribute"
+    assert problem["type"] == "https://test.example.com/missing-required-attribute"
+    assert problem["detail"] == "Missing attribute"
+
+
+def test_missing_hal_template_exception(client: TestClient):
+    """Tests the MissingHALTemplate exception handling."""
+
+    @client.app.get("/missing-hal-template")
+    async def missing_hal_template():
+        raise MissingHALTemplate("HAL template missing")
+
+    response = client.get("/missing-hal-template")
+    assert response.status_code == 404
+    problem = response.json()
+    assert problem["title"] == "Missing HAL Template"
+    assert problem["type"] == "https://test.example.com/missing-hal-template"
+    assert problem["detail"] == "HAL template missing"
+
+
+def test_http_error_exception(client: TestClient):
+    """Tests the HTTPError exception handling."""
+
+    @client.app.get("/http-error")
+    async def http_error():
+        response = MagicMock()
+        response.status_code = 418  # I'm a teapot!
+        raise HTTPError("Teapot error", response=response)
+
+    response = client.get("/http-error")
+    assert response.status_code == 418
+    problem = response.json()
+    assert problem["title"] == "HTTP Error"
+    assert problem["type"] == "https://test.example.com/http-error"
+    assert problem["detail"] == "An HTTP error occurred: Teapot error"
+
+
+def test_llm_deny_exception(client: TestClient):
+    """Tests the LLMDenyException exception handling."""
+
+    @client.app.get("/llm-deny")
+    async def llm_deny():
+        raise LLMDenyException("LLM denied")
+
+    response = client.get("/llm-deny")
+    assert response.status_code == 400
+    problem = response.json()
+    assert problem["title"] == "Request Denied"
+    assert problem["type"] == "https://test.example.com/request-denied"
+    assert problem["detail"] == "LLM denied"
+
+
+def test_generic_exception(client: TestClient):
+    """Tests the generic Exception handling."""
+
+    @client.app.get("/generic-exception")
+    async def generic_exception():
+        raise Exception("Something went wrong")
+
+    response = client.get("/generic-exception")
+    assert response.status_code == 500
+    problem = response.json()
+    assert problem["title"] == "Internal server error"
+    assert problem["type"] == "https://test.example.com/unknown"
+    assert problem["detail"] == "An unexpected error occurred: Something went wrong"
+
+
+def test_http_error_no_response(client: TestClient):
+    """Tests HTTPError when e.response is None"""
+    @client.app.get("/http-error-no-response")
+    async def http_error_no_response():
+        raise HTTPError("Generic HTTP Error")
+
+    response = client.get("/http-error-no-response")
+    assert response.status_code == 500
+    problem = response.json()
+    assert problem["title"] == "HTTP Error"
+    assert problem["type"] == "https://test.example.com/http-error"
+

contentgrid_extension_helpers-0.0.1/src/contentgrid_extension_helpers/authentication/__init__.py

@@ -1,2 +0,0 @@
-from .oidc import create_current_user_dependency, decode_and_verify_token, create_oauth2_scheme, get_jwks_client
-from .user import ContentGridUser