dcc-backend-common 0.0.1__py3-none-any.whl

dcc_backend_common/config/__init__.py

@@ -0,0 +1,3 @@
+from .app_config import AbstractAppConfig, AppConfig, AppConfigError, get_env_or_throw, log_secret
+
+__all__ = ["AbstractAppConfig", "AppConfig", "AppConfigError", "get_env_or_throw", "log_secret"]

dcc_backend_common/config/app_config.py

@@ -0,0 +1,78 @@
+import os
+from typing import override
+
+from pydantic import BaseModel, Field
+
+
+class AppConfigError(ValueError):
+    """Exception raised for errors in the application configuration."""
+
+    def __init__(self, variable_name: str) -> None:
+        super().__init__(f"Configuration variable '{variable_name}' is not set or invalid.")
+
+
+def get_env_or_throw(env_name: str) -> str:
+    value = os.getenv(env_name)
+    if value is None:
+        raise AppConfigError(env_name)
+    return value
+
+
+def log_secret(secret: str | None) -> str:
+    return "****" if secret is not None and len(secret) > 0 else "None"
+
+
+class AbstractAppConfig(BaseModel):
+    """Abstract base class for application configurations."""
+
+    @classmethod
+    def from_env(cls) -> "AbstractAppConfig":
+        raise NotImplementedError("Subclasses must implement from_env.")
+
+    @override
+    def __str__(self) -> str:
+        raise NotImplementedError("Subclasses must implement __str__.")
+
+
+class AppConfig(AbstractAppConfig):
+    client_url: str = Field(description="The URL for the client application")
+    hmac_secret: str = Field(description="The secret key for HMAC authentication")
+    openai_api_key: str = Field(description="The API key for authenticating with OpenAI")
+    llm_url: str = Field(description="The URL for the LLM API")
+    docling_url: str = Field(description="The URL for the Docling service")
+    whisper_url: str = Field(description="The URL for the Whisper API")
+    ocr_url: str = Field(description="The URL for the OCR API")
+
+    @classmethod
+    @override
+    def from_env(cls) -> "AppConfig":
+        client_url: str = get_env_or_throw("CLIENT_URL")
+        hmac_secret: str = get_env_or_throw("HMAC_SECRET")
+        openai_api_key: str = get_env_or_throw("OPENAI_API_KEY")
+        llm_url: str = get_env_or_throw("LLM_URL")
+        docling_url: str = get_env_or_throw("DOCLING_URL")
+        whisper_url: str = get_env_or_throw("WHISPER_URL")
+        ocr_url: str = get_env_or_throw("OCR_URL")
+        return cls(
+            client_url=client_url,
+            hmac_secret=hmac_secret,
+            openai_api_key=openai_api_key,
+            llm_url=llm_url,
+            docling_url=docling_url,
+            whisper_url=whisper_url,
+            ocr_url=ocr_url,
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"""
+        AppConfig(
+            client_url={self.client_url},
+            hmac_secret={log_secret(self.hmac_secret)},
+            openai_api_key={log_secret(self.openai_api_key)},
+            llm_url={self.llm_url},
+            docling_url={self.docling_url},
+            whisper_url={self.whisper_url},
+            ocr_url={self.ocr_url},
+        )
+        """

dcc_backend_common/fastapi_error_handling/__init__.py

@@ -0,0 +1,12 @@
+from .error_codes import ApiErrorCodes
+from .error_exception import ApiErrorException, ErrorResponse, api_error_exception, construct_api_error_exception
+from .error_handler import inject_api_error_handler
+
+__all__ = [
+    "ApiErrorCodes",
+    "ApiErrorException",
+    "ErrorResponse",
+    "api_error_exception",
+    "construct_api_error_exception",
+    "inject_api_error_handler",
+]

dcc_backend_common/fastapi_error_handling/error_codes.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class ApiErrorCodes(StrEnum):
+    UNEXPECTED_ERROR = "unexpected_error"
+    SERVICE_UNAVAILABLE = "service_unavailable"
+    INVALID_REQUEST = "invalid_request"
+    AUTHENTICATION_FAILED = "authentication_failed"
+    PERMISSION_DENIED = "permission_denied"
+    RESOURCE_NOT_FOUND = "resource_not_found"
+    RATE_LIMIT_EXCEEDED = "rate_limit_exceeded"
+    VALIDATION_ERROR = "validation_error"

dcc_backend_common/fastapi_error_handling/error_exception.py

@@ -0,0 +1,62 @@
+from typing import TypedDict
+
+from fastapi import status
+from fastapi.exceptions import HTTPException
+
+from dcc_backend_common.fastapi_error_handling.error_codes import ApiErrorCodes
+
+
+class ErrorResponse(TypedDict, total=False):
+    errorId: str | ApiErrorCodes
+    status: int | None  # default to 500 if not provided
+    debugMessage: str | None
+
+
+class ApiErrorException(Exception):
+    def __init__(self, error_response: ErrorResponse):
+        if "status" not in error_response:
+            error_response["status"] = status.HTTP_500_INTERNAL_SERVER_ERROR
+        self.error_response = error_response
+
+
+def api_error_exception(
+    errorId: str = ApiErrorCodes.UNEXPECTED_ERROR,
+    status: int = status.HTTP_500_INTERNAL_SERVER_ERROR,
+    debugMessage: str | None = None,
+):
+    return ApiErrorException(
+        error_response={
+            "errorId": errorId,
+            "status": status,
+            "debugMessage": debugMessage,
+        }
+    )
+
+
+def construct_api_error_exception(
+    exception: Exception,
+    error_id: str | ApiErrorCodes = ApiErrorCodes.UNEXPECTED_ERROR,
+    status_code: int | None = None,
+) -> ApiErrorException:
+    """
+    Constructs an ApiErrorException from the given exception, error ID, and status code.
+
+    Parameters:
+        exception (Exception): The original exception that occurred.
+        error_id (str | ApiErrorCodes): A string or enum value representing the error ID
+        status_code (int | None): An optional HTTP status code for the error response.
+
+    Returns:
+        ApiErrorException: An exception containing the structured error response.
+    """
+    error_response: ErrorResponse = {"errorId": error_id, "status": status_code}
+
+    if not status_code and isinstance(exception, HTTPException):
+        error_response["status"] = exception.status_code
+
+    debug_message = str(exception) if exception is not None else None
+
+    if debug_message is not None:
+        error_response["debugMessage"] = debug_message
+
+    return ApiErrorException(error_response)

dcc_backend_common/fastapi_error_handling/error_handler.py

@@ -0,0 +1,42 @@
+from fastapi import FastAPI, Request, Response, status
+from fastapi.responses import JSONResponse
+
+from dcc_backend_common.fastapi_error_handling.error_codes import ApiErrorCodes
+from dcc_backend_common.fastapi_error_handling.error_exception import ApiErrorException
+
+
+def inject_api_error_handler(app: FastAPI):
+    app.add_exception_handler(ApiErrorException, api_error_handler)
+
+
+def api_error_handler(request: Request, exc: Exception) -> Response:
+    """
+    Convert exceptions raised during request handling into a JSON HTTP response.
+
+    If `exc` is an `ApiErrorException`, returns its `error_response` payload and status code.
+    Otherwise returns a 500 response with `errorId` set to `UNEXPECTED_ERROR`, `status` 500, and a `debugMessage` containing the exception string.
+
+    Parameters:
+        request (Request): The incoming HTTP request that triggered the exception.
+        exc (Exception): The exception raised during request processing.
+
+    Returns:
+        Response: A JSON HTTP response describing the error.
+    """
+    if isinstance(exc, ApiErrorException):
+        status_code = (
+            exc.error_response.get("status", status.HTTP_500_INTERNAL_SERVER_ERROR)
+            or status.HTTP_500_INTERNAL_SERVER_ERROR
+        )
+
+        return JSONResponse(
+            status_code=status_code,
+            media_type="application/json",
+            content=exc.error_response,
+        )
+
+    return JSONResponse(
+        status_code=500,
+        media_type="application/json",
+        content={"errorId": ApiErrorCodes.UNEXPECTED_ERROR, "status": 500, "debugMessage": str(exc)},
+    )

dcc_backend_common/fastapi_health_probes/__init__.py

@@ -0,0 +1,3 @@
+from .router import health_probe_router
+
+__all__ = ["health_probe_router"]

dcc_backend_common/fastapi_health_probes/router.py

@@ -0,0 +1,98 @@
+import logging
+import time
+from datetime import UTC, datetime
+from http import HTTPStatus
+from typing import Any, TypedDict
+
+import aiohttp
+from fastapi import APIRouter, HTTPException, Response
+
+
+class ServiceDependency(TypedDict):
+    name: str
+    health_check_url: str
+    api_key: str | None
+
+
+def health_probe_router(service_dependencies: list[ServiceDependency]) -> APIRouter:
+    router = APIRouter(prefix="/health")
+
+    START_TIME = time.time()
+
+    # Disable logging for health check endpoints
+    class EndpointFilter(logging.Filter):
+        def filter(self, record: logging.LogRecord) -> bool:
+            # Endpoints to exclude from logging
+            skip_paths = {"/health"}
+
+            # Extract the request path from the log message
+            return all(skip_path not in record.getMessage() for skip_path in skip_paths)
+
+    # Configure the filter
+    logging.getLogger("uvicorn.access").addFilter(EndpointFilter())
+
+    @router.get("/liveness")
+    async def liveness_probe():
+        """
+        Liveness Probe
+        * Purpose: Checks if the application process is running and not deadlocked.
+        * K8s Action: If this fails, the container is KILLED and RESTARTED.
+        * Rule: Keep it simple. Do NOT check databases here.
+        """
+        return {"status": "up", "uptime_seconds": time.time() - START_TIME}
+
+    @router.get("/readiness")
+    async def readiness_probe(response: Response):
+        """
+        Readiness Probe
+        * Purpose: Checks if the app is ready to handle user requests (e.g., external APIs).
+        * K8s Action: If this fails, traffic stops sending to this pod.
+        * Rule: Check critical dependencies here.
+        """
+
+        health_check: dict[str, Any] = {
+            "status": "ready",
+            "checks": {service["name"]: "unknown" for service in service_dependencies},
+        }
+
+        try:
+            timeout = aiohttp.ClientTimeout(total=5.0)
+
+            for service in service_dependencies:
+                async with aiohttp.ClientSession(
+                    timeout=timeout,
+                    headers={"Authorization": f"Bearer {service['api_key']}"} if service["api_key"] else {},
+                ) as session:
+                    try:
+                        async with session.get(service["health_check_url"]) as svc_response:
+                            if svc_response.status == 200:
+                                health_check["checks"][service["name"]] = "healthy"
+                            else:
+                                health_check["checks"][service["name"]] = f"unhealthy (status: {svc_response.status})"
+                                raise HTTPException(
+                                    status_code=HTTPStatus.SERVICE_UNAVAILABLE,
+                                    detail=f"{service['name']} returned status {svc_response.status}",
+                                )
+                    except aiohttp.ClientError as e:
+                        health_check["checks"][service["name"]] = f"error: {e!s}"
+                        raise
+
+        except Exception as e:
+            # If a critical dependency fails, we must return a 503.
+            # This tells K8s to stop sending traffic to this specific pod.
+            response.status_code = HTTPStatus.SERVICE_UNAVAILABLE
+            return {"status": "unhealthy", "checks": health_check["checks"], "error": str(e)}
+        else:
+            return health_check
+
+    @router.get("/startup")
+    async def startup_probe():
+        """
+        Startup Probe
+        * Purpose: Checks if the application has finished initialization.
+        * K8s Action: Blocks Liveness/Readiness probes until this returns 200.
+        * Rule: Useful for apps that need to load large ML models or caches on boot.
+        """
+        return {"status": "started", "timestamp": datetime.now(UTC).isoformat()}
+
+    return router

dcc_backend_common/logger/__init__.py

@@ -0,0 +1,3 @@
+from .logger import get_logger, init_logger
+
+__all__ = ["get_logger", "init_logger"]

dcc_backend_common/logger/logger.py

@@ -0,0 +1,127 @@
+import logging
+import os
+import time
+import uuid
+from collections.abc import Mapping
+from typing import Any
+
+import structlog
+import structlog.processors
+from structlog.processors import CallsiteParameter
+from structlog.stdlib import BoundLogger
+from structlog.types import EventDict, Processor
+
+from dcc_backend_common.config import get_env_or_throw
+
+
+# Standard library logging setup
+def setup_stdlib_logging() -> None:
+    """Configure standard library logging to work with structlog."""
+    log_level = os.getenv("LOG_LEVEL", "INFO").upper()
+
+    level = getattr(logging, log_level, logging.INFO)
+
+    # Create a handler for console output
+    handler = logging.StreamHandler()
+
+    # Configure root logger
+    root_logger = logging.getLogger()
+    root_logger.setLevel(level)
+    root_logger.addHandler(handler)
+
+    # Disable propagation for libraries that are too verbose
+    for logger_name in ["uvicorn.access"]:
+        lib_logger = logging.getLogger(logger_name)
+        lib_logger.propagate = False
+
+
+def add_request_id(logger: BoundLogger, method_name: str, event_dict: EventDict) -> Mapping[str, Any]:
+    """
+    Add a request ID to the log context if it doesn't exist.
+
+    Args:
+        logger: The logger instance
+        method_name: The name of the logging method
+        event_dict: The event dictionary
+
+    Returns:
+        The updated event dictionary
+    """
+    if "request_id" not in event_dict:
+        event_dict["request_id"] = str(uuid.uuid4())
+    return event_dict
+
+
+def add_timestamp(logger: BoundLogger, method_name: str, event_dict: EventDict) -> Mapping[str, Any]:
+    """
+    Add an ISO-8601 timestamp to the log entry.
+
+    Args:
+        logger: The logger instance
+        method_name: The name of the logging method
+        event_dict: The event dictionary
+
+    Returns:
+        The updated event dictionary
+    """
+    event_dict["timestamp"] = time.strftime("%Y-%m-%dT%H:%M:%S%z")
+    return event_dict
+
+
+def init_logger() -> None:
+    """
+    Initialize the logger configuration based on environment.
+    Uses JSON renderer in production environment for compatibility with fluentbit.
+    Adds the module name as context to the logger.
+    """
+    # Set up standard library logging first
+    setup_stdlib_logging()
+
+    # Define processors list for structlog
+    processors: list[Processor] = [
+        structlog.stdlib.filter_by_level,
+        structlog.processors.add_log_level,
+        structlog.processors.StackInfoRenderer(),
+        add_timestamp,
+        add_request_id,
+        structlog.processors.CallsiteParameterAdder(
+            parameters=[
+                CallsiteParameter.MODULE,
+                CallsiteParameter.FUNC_NAME,
+                CallsiteParameter.LINENO,
+            ]
+        ),
+        structlog.processors.UnicodeDecoder(),
+    ]
+
+    # Use different renderers for development vs production
+    if get_env_or_throw("IS_PROD").lower() == "true":
+        # JSON renderer for production to be fluentbit compatible
+        processors.append(structlog.processors.JSONRenderer())
+    else:
+        # For development, use a colored console renderer
+        processors.append(structlog.dev.ConsoleRenderer(colors=True))
+
+    # Configure structlog
+    structlog.configure(
+        processors=processors,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        wrapper_class=structlog.stdlib.BoundLogger,
+        cache_logger_on_first_use=True,
+    )
+
+
+def get_logger(name: str | None = None) -> BoundLogger:
+    """
+    Get a structured logger instance.
+
+    Args:
+        name: Optional name for the logger, typically the module name
+
+    Returns:
+        A bound logger instance for structured logging
+    """
+    if name:
+        return structlog.get_logger(name)  # type: ignore[no-any-return]
+    return structlog.get_logger()  # type: ignore[no-any-return]

dcc_backend_common-0.0.1.dist-info/METADATA

@@ -0,0 +1,270 @@
+Metadata-Version: 2.4
+Name: dcc-backend-common
+Version: 0.0.1
+Summary: Common python code used in out backend services.
+Project-URL: Homepage, https://github.com/dcc-bs
+Project-URL: Repository, https://github.com/DCC-BS/backend-common
+Project-URL: Documentation, https://DCC-BS.github.io/documentation/
+Author-email: Data Competence Center Basel-Stadt <dcc@bs.ch>, Tobias Bollinger <tobias.bollinger@bs.ch>, Yanick Schraner <yanick.schraner@bs.ch>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: python
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: <4.0,>=3.12
+Requires-Dist: datasets>=4.4.1
+Requires-Dist: dspy>=3.0.4
+Requires-Dist: jiwer>=4.0.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: python-dotenv>=1.0.1
+Requires-Dist: structlog>=25.1.0
+Provides-Extra: fastapi
+Requires-Dist: aiohttp>=3.13.2; extra == 'fastapi'
+Requires-Dist: fastapi<1.0,>=0.115; extra == 'fastapi'
+Description-Content-Type: text/markdown
+
+# dcc-backend-common
+
+[![Commit activity](https://img.shields.io/github/commit-activity/m/DCC-BS/backend-common)](https://img.shields.io/github/commit-activity/m/DCC-BS/backend-common)
+[![License](https://img.shields.io/github/license/DCC-BS/backend-common)](https://img.shields.io/github/license/DCC-BS/backend-common)
+
+Common utilities and components for backend services developed by the Data Competence Center Basel-Stadt.
+
+## Overview
+
+`dcc-backend-common` is a Python library that provides shared functionality for backend services, including:
+
+- **FastAPI Health Probes**: Kubernetes-ready health check endpoints (liveness, readiness, startup)
+- **Structured Logging**: Integration with `structlog` for consistent logging across services
+- **Configuration Management**: Environment-based configuration with `python-dotenv`
+- **DSPy Utilities**: Helpers for DSPy modules, streaming listeners, metrics, and dataset preparation
+
+## Installation
+
+### Basic Installation (uv)
+
+```bash
+uv add dcc-backend-common
+```
+
+### With FastAPI Support
+
+```bash
+uv add "dcc-backend-common[fastapi]"
+```
+
+## Requirements
+
+- Python 3.12 or higher
+- Dependencies:
+  - `dspy>=3.0.4`
+  - `python-dotenv>=1.0.1`
+  - `structlog>=25.1.0`
+
+### Optional Dependencies
+
+- FastAPI extras: `aiohttp>=3.13.2`, `fastapi>=0.115,<1.0`
+
+## Features
+
+### FastAPI Health Probes
+
+The library provides Kubernetes-ready health check endpoints that follow best practices for container orchestration:
+
+#### Example Usage
+
+```python
+from fastapi import FastAPI
+from dcc_backend_common.fastapi_health_probes import health_probe_router
+
+app = FastAPI()
+
+# Define external service dependencies
+service_dependencies = [
+    {
+        "name": "database",
+        "health_check_url": "http://postgres:5432/health",
+        "api_key": None  # Optional API key for authenticated health checks
+    },
+    {
+        "name": "external-api",
+        "health_check_url": "https://api.example.com/health",
+        "api_key": "your-api-key-here"
+    }
+]
+
+# Include health probe router
+app.include_router(health_probe_router(service_dependencies))
+```
+
+#### Available Endpoints
+
+##### 1. Liveness Probe (`GET /health/liveness`)
+
+- **Purpose**: Checks if the application process is running and not deadlocked
+- **Kubernetes Action**: If this fails, the container is killed and restarted
+- **Response**: Returns uptime in seconds
+- **Rule**: Keep it simple. Do NOT check databases or external dependencies here
+
+```json
+{
+  "status": "up",
+  "uptime_seconds": 123.45
+}
+```
+
+##### 2. Readiness Probe (`GET /health/readiness`)
+
+- **Purpose**: Checks if the app is ready to handle user requests
+- **Kubernetes Action**: If this fails, traffic stops being sent to this pod
+- **Response**: Returns status of all configured service dependencies
+- **Rule**: Check critical dependencies here (databases, external APIs, etc.)
+
+```json
+{
+  "status": "ready",
+  "checks": {
+    "database": "healthy",
+    "external-api": "healthy"
+  }
+}
+```
+
+If a dependency fails:
+
+```json
+{
+  "status": "unhealthy",
+  "checks": {
+    "database": "error: Connection refused",
+    "external-api": "unhealthy (status: 503)"
+  },
+  "error": "Service unavailable"
+}
+```
+
+##### 3. Startup Probe (`GET /health/startup`)
+
+- **Purpose**: Checks if the application has finished initialization
+- **Kubernetes Action**: Blocks liveness/readiness probes until this returns 200
+- **Response**: Returns startup timestamp
+- **Rule**: Useful for apps that need to load large ML models or caches on boot
+
+```json
+{
+  "status": "started",
+  "timestamp": "2025-12-04T10:30:00.000000+00:00"
+}
+```
+
+#### Features
+
+- **Automatic Logging Suppression**: Health check endpoints are automatically excluded from access logs to reduce noise
+- **Dependency Health Checks**: Readiness probe checks external service dependencies with configurable timeouts (5 seconds default)
+- **Authentication Support**: Optional API key support for authenticated health checks
+- **Kubernetes-Ready**: HTTP status codes follow Kubernetes conventions (200 = healthy, 503 = unhealthy)
+
+### Structured Logging
+
+- Initialize structured logging with `init_logger()`, which auto-selects JSON output in production (`IS_PROD=true`) and colored console output otherwise.
+- Retrieve loggers via `get_logger(__name__)`. A `request_id` and timestamp are added automatically.
+
+### Application Configuration
+
+Load strongly-typed configuration from environment variables:
+
+```python
+from dcc_backend_common.config.app_config import AppConfig
+
+config = AppConfig.from_env()
+print(config)  # secrets are redacted in __str__
+```
+
+Required variables: `CLIENT_URL`, `HMAC_SECRET`, `OPENAI_API_KEY`, `LLM_URL`, `DOCLING_URL`, `WHISPER_URL`, `OCR_URL`. Missing values raise `AppConfigError`.
+
+
+## Development
+
+### Setup
+
+1. Clone the repository:
+
+```bash
+git clone https://github.com/DCC-BS/backend-common.git
+cd backend-common
+```
+
+2. Install development dependencies:
+
+```bash
+uv sync --group dev --extra fastapi  # include FastAPI extras for local dev
+```
+
+### Running Tests
+
+```bash
+uv run pytest
+```
+
+### Code Quality
+
+This project uses:
+
+- **Ruff**: For linting and formatting
+- **Pre-commit**: For automated code quality checks
+- **Tox**: For testing across multiple Python versions
+
+Run linting:
+
+```bash
+uv run ruff check .
+```
+
+Run pre-commit hooks:
+
+```bash
+uv run pre-commit run --all-files
+```
+
+## Releasing
+
+This project uses GitHub Actions for automated releases to PyPI.
+
+To release a new version:
+
+1.  **Update the version**: Update the `version` field in `pyproject.toml`.
+2.  **Commit and push**: Commit the version change and push it to the `main` branch.
+3.  **Trigger the workflow**:
+    *   Navigate to the **Actions** tab in the GitHub repository.
+    *   Select the **Publish to PyPI** workflow.
+    *   Click **Run workflow**.
+4.  **Automated steps**: The workflow will:
+    *   Automatically detect the version using `uv version --short`.
+    *   Create and push a git tag (e.g., `v0.1.0`).
+    *   Build the package with `uv build`.
+    *   Publish to PyPI using Trusted Publishing.
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for details on how to contribute to this project.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Authors
+
+- **Data Competence Center Basel-Stadt** - [dcc@bs.ch](mailto:dcc@bs.ch)
+- **Tobias Bollinger** - [tobias.bollinger@bs.ch](mailto:tobias.bollinger@bs.ch)
+
+## Links
+
+- **Homepage**: https://DCC-BS.github.io/backend-common/
+- **Repository**: https://github.com/DCC-BS/backend-common
+- **Documentation**: https://DCC-BS.github.io/backend-common/

dcc_backend_common-0.0.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+dcc_backend_common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dcc_backend_common/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+dcc_backend_common/config/__init__.py,sha256=sqUsKzWO-H7S6OY6XOiDYd4mjduHM3IxFSlmz2JNnk8,197
+dcc_backend_common/config/app_config.py,sha256=SfosCdyGWtt6TTLnwX75YMyC1A2tP9_4q9ODpIYgVHs,2697
+dcc_backend_common/fastapi_error_handling/__init__.py,sha256=ZOVVHyZ7xhNlTe7SVmHPGiOx0_wf0oXfP8xeX1oipW8,383
+dcc_backend_common/fastapi_error_handling/error_codes.py,sha256=0RTxeKaZefaCJQ63AxqGFUgA1JeUOhzKBjQKwU6-8P8,419
+dcc_backend_common/fastapi_error_handling/error_exception.py,sha256=wAQVRt1sdL4Zg3eAGbC78zJy2kPzDeNoMeR2um0zP3s,2022
+dcc_backend_common/fastapi_error_handling/error_handler.py,sha256=poVjt-5qtU5XB6WNv9n6hQ_jCS7pyWxC319ibI2Q7Rk,1611
+dcc_backend_common/fastapi_health_probes/__init__.py,sha256=3qzn5MHQC0MR01arNFf2ckjkIbw_9hDpCd04d7La3jc,75
+dcc_backend_common/fastapi_health_probes/router.py,sha256=RUHiCOLnDXr5uOmEUsJCXpA0Lg-UUmoHRt6KU1KXF4o,3880
+dcc_backend_common/logger/__init__.py,sha256=dSAG_ktfLo9Fdqsuixg2_9-e_h3jMpuFFm2qPZ58-2Q,85
+dcc_backend_common/logger/logger.py,sha256=hdNoBbqiimOdjhBkQLIimmaPgTPL4LprWo04TSD-7X8,3867
+dcc_backend_common-0.0.1.dist-info/METADATA,sha256=13DevsUe-S7Y3O_MjmT1tHKjG7cH7r1ZLoqpkjyJaMs,7941
+dcc_backend_common-0.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dcc_backend_common-0.0.1.dist-info/licenses/LICENSE,sha256=qgoMkVVKejeBUg8jcD2ZjwydZ4pcIGNztLXJ2OXtJX0,1091
+dcc_backend_common-0.0.1.dist-info/RECORD,,

dcc_backend_common-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

dcc_backend_common-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Data Competence Center Basel-Stadt
+
+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.