contentgrid-extension-helpers 0.0.1__py3-none-any.whl → 0.0.3__py3-none-any.whl

contentgrid_extension_helpers/dependencies/sqlalch/db/sqlite.py

@@ -0,0 +1,43 @@
+from typing import Dict, Any, Optional
+
+from pydantic import field_validator
+from .base_factory import DatabaseConfig, DatabaseSessionFactory
+
+
+class SQLiteConfig(DatabaseConfig):
+    sqlite_file_name: str = "database.db"
+
+    @field_validator("sqlite_file_name")
+    def validate_sqlite_file_name(cls, value: str) -> str:
+        if not value.endswith('.db'):
+            raise ValueError("SQLite file name must end with '.db'")
+        return value
+
+
+class SQLiteSessionFactory(DatabaseSessionFactory):
+    """Factory class to create SQLite database connections."""
+    
+    def __init__(self, debug: Optional[bool]= None, sqlite_file_name : Optional[str] = None):
+        config_dict = {}
+        if debug is not None:
+            config_dict['debug'] = debug
+        if sqlite_file_name is not None:
+            config_dict['sqlite_file_name'] = sqlite_file_name
+        
+        db_config = SQLiteConfig(**config_dict)
+        super().__init__(db_config)
+    
+    def create_connection_string(self) -> str:
+        """Create the SQLite connection string."""
+        config = self.db_config
+        if not isinstance(config, SQLiteConfig):
+            raise ValueError("SQLiteConfig is required for SQLiteSessionFactory")
+        return f"sqlite:///{config.sqlite_file_name}"
+    
+    def create_connect_args(self) -> Dict[str, Any]:
+        """Create SQLite connection arguments."""
+        return {"check_same_thread": False}
+    
+    def create_engine_kwargs(self) -> Dict[str, Any]:
+        """Create SQLite engine keyword arguments."""
+        return {}  # No pool config for SQLite

contentgrid_extension_helpers/dependencies/sqlalch/repositories/__init__.py

@@ -0,0 +1 @@
+from .base_repository import BaseRepository

contentgrid_extension_helpers/dependencies/sqlalch/repositories/base_repository.py

@@ -0,0 +1,52 @@
+from typing import Dict, Generic, List, Type, TypeVar
+from contentgrid_hal_client import NotFound
+from sqlmodel import SQLModel, Session, select
+
+
+T = TypeVar('T', bound=SQLModel)
+CreateT = TypeVar('CreateT', bound=SQLModel)
+UpdateT = TypeVar('UpdateT', bound=SQLModel)
+
+class BaseRepository(Generic[T, CreateT, UpdateT]):
+    """Generic base repository for database operations"""
+
+    def __init__(self, session: Session, model_class: Type[T]):
+        self.session = session
+        self.model_class = model_class
+
+    def create(self, create_model: CreateT) -> T:
+        """Create a new entity"""
+        db_entity = self.model_class.model_validate(create_model)
+        self.session.add(db_entity)
+        self.session.commit()
+        self.session.refresh(db_entity)
+        return db_entity
+
+    def get_by_id(self, entity_id: int) -> T:
+        """Get entity by ID"""
+        entity = self.session.get(self.model_class, entity_id)
+        if not entity:
+            raise NotFound(f"{self.model_class.__name__} with id {entity_id} not found")
+        return entity
+
+    def get_all(self, offset: int = 0, limit: int = 100) -> List[T]:
+        # user filter has to be pre query for no error pagination 
+        """Get all entities with pagination"""
+        return self.session.exec(select(self.model_class).offset(offset).limit(limit)).all()
+
+    def update(self, entity_id: int, update_model: UpdateT) -> T:
+        """Update entity by ID"""
+        db_entity = self.get_by_id(entity_id)
+        update_data = update_model.model_dump(exclude_unset=True)
+        db_entity.sqlmodel_update(update_data)
+        self.session.add(db_entity)
+        self.session.commit()
+        self.session.refresh(db_entity)
+        return db_entity
+
+    def delete(self, entity_id: int) -> Dict[str, bool]:
+        """Delete entity by ID"""
+        db_entity = self.get_by_id(entity_id)
+        self.session.delete(db_entity)
+        self.session.commit()
+        return {"ok": True}

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/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/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/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://problems.contentgrid.test"):
+    """
+    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/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/responses/hal.py

@@ -0,0 +1,212 @@
+from urllib.parse import urlencode
+from fastapi import FastAPI
+from fastapi.routing import APIRoute
+from pydantic import BaseModel, Field, field_serializer
+from fastapi._compat import ModelField
+from typing import Dict, Optional, Tuple, Type, Any, Union, List, Self, TypeVar, Generic, Callable, cast
+import logging
+from contentgrid_hal_client.hal import HALShape, HALLink
+from contentgrid_hal_client.hal_forms import HALFormsTemplate, HALFormsMethod, HALFormsPropertyType, HALFormsProperty
+import uri_template
+
+def get_route_from_app(app: FastAPI, endpoint_function: str) -> APIRoute:
+    for route in app.routes:
+        if isinstance(route, APIRoute) and route.name == endpoint_function:
+            return route
+    else:
+        error_message = f"No route found for endpoint {endpoint_function}"
+        raise ValueError(error_message)
+
+def _add_params(url : str, params: Optional[Dict[str, str]] = None) -> str:
+    if params:
+        url_postfix = "?" + urlencode(params)
+        url += url_postfix
+    return url
+
+def get_body_from_route(route : APIRoute) -> Tuple[Optional[BaseModel], dict]:
+    required_body = route.body_field
+    if not required_body:
+        return None, {}
+    pydantic_body, default_data = get_pydantic_base_model_from_model_field(required_body)
+    return pydantic_body, default_data
+    
+def get_pydantic_base_model_from_model_field(model_field : ModelField) -> Tuple[BaseModel, dict]:
+    default_data = model_field._type_adapter.get_default_value() or {}
+    pydantic_body = cast(BaseModel, model_field._type_adapter._type)
+    return pydantic_body, default_data
+
+def extract_hal_forms_properties_from_pydantic_base_model(
+    pydantic_base_model : BaseModel,
+    default_data : dict = {}
+) -> List[HALFormsProperty]:
+    properties : List[HALFormsProperty] = []
+    for field_name, field_info in pydantic_base_model.model_fields.items():
+        # Determine property type based on field type
+        property_type = HALFormsPropertyType.text
+        
+        # Convert field type to HALFormsPropertyType
+        if field_info.annotation is int or field_info.annotation is float:
+            property_type = HALFormsPropertyType.number
+        elif field_info.annotation is bool:
+            property_type = HALFormsPropertyType.checkbox
+        
+        # Get default value for this field if available
+        field_default = default_data.get(field_name) if default_data else None
+        
+        # Create HALFormsProperty
+        field_property = HALFormsProperty(
+            name=field_name,
+            prompt=field_info.description or field_name,
+            required=field_info.is_required(),
+            type=property_type,
+            value=field_default
+        )
+        properties.append(field_property)
+    return properties
+
+class LinkForType(BaseModel):
+    endpoint_function_name: str
+    templated: bool = False
+    path_params: Union[dict[str, str],  Callable[["FastAPIHALResponse"], dict[str, str]]] = Field(default_factory=dict)
+    params: Union[dict[str, Union[str, int, float]], Callable[["FastAPIHALResponse"], dict[str, Union[str, int, float]]]] = Field(default_factory=dict)
+    condition: Union[Callable[["FastAPIHALResponse"], bool], bool] = True
+
+
+class HALLinkFor(LinkForType):
+    pass
+
+class HALTemplateFor(LinkForType):
+    pass
+    
+    
+HALLinks = dict[str, Union[HALLink, HALLinkFor]]
+HALTemplates = dict[str, Union[HALFormsTemplate, HALTemplateFor]]
+
+# Type variable for generic embedded resources - must be a subclass of FastAPIHALResponse
+T = TypeVar('T', bound='FastAPIHALResponse')
+
+
+class FastAPIHALResponse(HALShape):    
+    links: dict[str, Union[HALLink, HALLinkFor]] = Field(alias="_links", exclude=False, default_factory=dict)
+    templates: dict[str, Union[HALFormsTemplate, HALTemplateFor]] | None = Field(default=None, alias="_templates")
+    
+    def __expand_link(self, link : HALLinkFor | HALLink) -> HALLink | None:
+        """
+            Expand the links based on server url and path and params.
+            This method should be called after the class is initialized.
+            Returns None if the link should be excluded based on condition.
+        """
+        if not hasattr(self.__class__, '_app'):
+            raise ValueError("App not initialized. Call init_app() before using this method.")
+        
+        if not isinstance(link, HALLinkFor):
+            return link
+        
+        # Check condition - if False, exclude the link
+        if isinstance(link.condition, bool):
+            if not link.condition:
+                return None
+        elif callable(link.condition):
+            if not link.condition(self):
+                return None
+        
+        if hasattr(self.__class__, '_app') and self.__class__._app:
+            route = get_route_from_app(self.__class__._app, link.endpoint_function_name)
+            
+            if hasattr(self.__class__, '_server_url'):
+                uri = f"{self.__class__._server_url}{route.path}"
+            else:
+                uri = route.path
+                
+            expanded_link = HALLink(uri=uri, templated=link.templated)
+            
+            if link.path_params:
+                # Handle callable params
+                if callable(link.path_params):
+                    resolved_path_params = link.path_params(self)
+                else:
+                    resolved_path_params = link.path_params
+                expanded_link.uri = uri_template.URITemplate(expanded_link.uri).expand(**resolved_path_params)
+            
+            if link.params:
+                # Handle callable params
+                if callable(link.params):
+                    resolved_params = link.params(self)
+                else:
+                    resolved_params = link.params
+                expanded_link.uri = _add_params(expanded_link.uri, resolved_params)
+            
+            return expanded_link
+
+    
+    @field_serializer('links')
+    def ser_links(self, value: dict[str, Union[HALLink, HALLinkFor]]) -> dict[str, HALLink]:
+        expanded_links = {}
+        for key, link_value in value.items():
+            expanded_link = self.__expand_link(link_value)
+            if expanded_link is not None:  # Only include if condition is met
+                expanded_links[key] = expanded_link
+        return expanded_links
+    
+    @field_serializer('templates')
+    def ser_templates(self, value: dict[str, Union[HALFormsTemplate, HALTemplateFor]] | None) -> dict[str, HALFormsTemplate]:
+        expanded_templates = {}
+        if value is None:
+            return expanded_templates
+        for key, template_value in value.items():
+            if isinstance(template_value, HALTemplateFor) and hasattr(self.__class__, '_app') and self.__class__._app:
+                try:
+                    hallink = self.__expand_link(HALLinkFor(
+                        **template_value.model_dump()
+                    ))
+                    
+                    if hallink is None:
+                        continue
+                    
+                    uri = hallink.uri
+                    route = get_route_from_app(self.__class__._app, template_value.endpoint_function_name)
+                    body_model, default_data = get_body_from_route(route=route)
+                    if body_model is None:
+                        properties = []
+                    else:
+                        properties = extract_hal_forms_properties_from_pydantic_base_model(pydantic_base_model=body_model, default_data=default_data)
+                            
+                    #TODO what should we do when there are multiple methods for the same function/endpoint?
+                    expanded_templates[key] = HALFormsTemplate(
+                        title=route.description if hasattr(route, 'description') and route.description else None,
+                        method=HALFormsMethod(list(route.methods)[0]) if hasattr(route, 'methods') and route.methods else HALFormsMethod.GET,
+                        target=uri,
+                        properties=properties
+                    )
+                except ValueError:
+                    logging.error(f"{self.__class__} hal template expansion failed: Route not found for template endpoint: {template_value.endpoint_function_name}")
+                    continue
+            else:
+                expanded_templates[key] = template_value
+        return expanded_templates
+        
+    
+    @classmethod
+    def init_app(cls: Type[Self], app: Any) -> None:
+        """
+        Bind a FastAPI app to other HyperModel base class.
+        This allows HyperModel to convert endpoint function names into
+        working URLs relative to the application root.
+
+        Args:
+            app (FastAPI): Application to generate URLs from
+        """
+        cls._app = app
+        
+    @classmethod
+    def add_server_url(cls: Type[Self], server_url: str) -> None:
+        """
+        Set the server URL for generating absolute URLs.
+
+        Args:
+            server_url (str): The base URL of the server.
+        """
+        cls._server_url = server_url
+        
+class FastAPIHALCollection(FastAPIHALResponse, Generic[T]):
+    embedded: dict[str, List[T]] | None = Field(default=None, alias="_embedded", description="Embedded resources")

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.dist-info → contentgrid_extension_helpers-0.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: contentgrid-extension-helpers
-Version: 0.0.1
+Version: 0.0.3
 Summary: Helper functions for contentgrid extensions.
 Author-email: Ranec Belpaire <ranec.belpaire@xenit.eu>
 License: Copyright 2024 Xenit Solutions
@@ -26,6 +26,12 @@ Requires-Dist: requests<3,>=2.20.0
 Requires-Dist: uri-template<2
 Requires-Dist: fastapi>=0.111
 Requires-Dist: PyJWT>2
+Requires-Dist: cryptography>45
+Requires-Dist: contentgrid_hal_client>=0.1
+Requires-Dist: contentgrid_application_client>=0.1
+Requires-Dist: contentgrid_management_client>=0.1
+Requires-Dist: pydantic<3,>=2
+Dynamic: license-file
 
 ### ContentGrid-Extension-Helpers
 

contentgrid_extension_helpers-0.0.3.dist-info/RECORD

@@ -0,0 +1,30 @@
+contentgrid_extension_helpers/__init__.py,sha256=Mw64JI29DW5HOzmL1UA8grdyrOqAQeHlllR_zxjagy8,380
+contentgrid_extension_helpers/config.py,sha256=V6IUE5bRyg0k5Gzbq8YdB2k_0OeEzHOI-_h4gaQJiPQ,1401
+contentgrid_extension_helpers/exceptions.py,sha256=GJOIwDC_51pyhiPaq6wRrkmS3X1aU_PQoEE4sPTgopQ,1812
+contentgrid_extension_helpers/problem_response.py,sha256=v2z_hx92pHWyqMZfnJDi6TaGVIeoGh2AXVr1F9VA00w,1542
+contentgrid_extension_helpers/authentication/__init__.py,sha256=XnupVcladC7H4LudetZ46da9IP69pWKhtRJvikhmIKM,200
+contentgrid_extension_helpers/authentication/oidc.py,sha256=14XEmp_WWDVygb3oBKB9S29UlgJV8wnm_1lw36U4xxc,9820
+contentgrid_extension_helpers/authentication/user.py,sha256=EwUjIczs3oFiM0TQK-eLixVNgeou4OY0zTwszFURmrc,1540
+contentgrid_extension_helpers/dependencies/authentication/user.py,sha256=c3Xgg3J4O_TqfdCIETg0VtNF1NUrzaB-gxCJaojrbv4,2817
+contentgrid_extension_helpers/dependencies/clients/contentgrid/__init__.py,sha256=J43Bq-VOCr3OZQA8QzofQXwhDbB2jI4qEPbSc6JI_oI,240
+contentgrid_extension_helpers/dependencies/clients/contentgrid/client_factory.py,sha256=7WL39-tsHZFve_35drrmwb2NczUxvLMiQQvXsdBguA4,2541
+contentgrid_extension_helpers/dependencies/clients/contentgrid/extension_flow_factory.py,sha256=AHgxq3WttAsW4BqbMrgo77BmX94OMJz_Yb1TrjyWcOs,4111
+contentgrid_extension_helpers/dependencies/clients/contentgrid/service_account_factory.py,sha256=BdUZxK2gU8TFZNWdkufm_73uKAkboyJd08-000kfwLc,3932
+contentgrid_extension_helpers/dependencies/sqlalch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contentgrid_extension_helpers/dependencies/sqlalch/db/__init__.py,sha256=7PntPSCwinwSk2il3_LWoSEHnCmx4bQvYLHPC7WJbDw,414
+contentgrid_extension_helpers/dependencies/sqlalch/db/base_factory.py,sha256=vXFQzot1aR__P1ZyMa7VE_JE1sixJjNkKlZBDppKowE,4263
+contentgrid_extension_helpers/dependencies/sqlalch/db/postgres.py,sha256=X2kWg3EBTNcXhQQxuym4pW0GqmZiLxQFi4tvZqiwl7o,4563
+contentgrid_extension_helpers/dependencies/sqlalch/db/sqlite.py,sha256=2FgAcLs8SqMWCUqlOa-rv_JWGLPVhDVt_eTiwWqWdZA,1592
+contentgrid_extension_helpers/dependencies/sqlalch/repositories/__init__.py,sha256=ApJOGKoqnxLfdCqtnkQoOykPCYMnUQhtX29MyD5nOng,43
+contentgrid_extension_helpers/dependencies/sqlalch/repositories/base_repository.py,sha256=PWN-V_YzYwLxRnZWSIfGyVxi8r9lq3wWObOi0cYcFRg,1975
+contentgrid_extension_helpers/logging/__init__.py,sha256=15tz-g0fLdBjJto8kWcjCYhfXCJg0qrwSXVuXRH9i3Q,77
+contentgrid_extension_helpers/logging/json_logging.py,sha256=NrzoBfEUAwQT7mmCHK0GoFJv5t9rrgjomDTXzZ-vgFI,3112
+contentgrid_extension_helpers/middleware/exception_middleware.py,sha256=6mP7IQ7vPZ6-1_QESnAPZNQ5vA0MTTTzpovdszGp964,4467
+contentgrid_extension_helpers/responses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+contentgrid_extension_helpers/responses/hal.py,sha256=g7_lqBEEmSMYEqp0ZVTqT8xfMQXlT0e4_5_a7WcS1Qs,9234
+contentgrid_extension_helpers/structured_output/model_deny.py,sha256=n2sEls0kyhvL8hHUKeo3_JQ_ZssyknIbIoDAOUvMVxc,1748
+contentgrid_extension_helpers-0.0.3.dist-info/licenses/LICENSE,sha256=tk6n-p8lEmzLJg-O4052CkMgfUtt1q2Zoh1QLAyL7S8,555
+contentgrid_extension_helpers-0.0.3.dist-info/METADATA,sha256=Wfpq2OD1UzL268ZxJEJ_9GotNg-qZU_5WkSvXU8r-oU,1574
+contentgrid_extension_helpers-0.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+contentgrid_extension_helpers-0.0.3.dist-info/top_level.txt,sha256=yJGGofrNVsl5psVGO0vLFHO1610ob88GtB9zpvS8iIk,30
+contentgrid_extension_helpers-0.0.3.dist-info/RECORD,,

{contentgrid_extension_helpers-0.0.1.dist-info → contentgrid_extension_helpers-0.0.3.dist-info}/WHEEL

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