labeljetty 0.1.0__py3-none-any.whl

labeljetty/__init__.py

@@ -0,0 +1,3 @@
+from labeljetty.version import get_version
+
+__version__ = get_version()

labeljetty/__main__.py

@@ -0,0 +1,3 @@
+from labeljetty.app import run
+
+run()

labeljetty/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

labeljetty/app.py

@@ -0,0 +1,64 @@
+from typing import cast
+from pathlib import Path
+import uvicorn
+import asyncio
+from uvicorn.config import LOGGING_CONFIG
+from uvicorn.config import LifespanType
+
+from labeljetty.web.app import FastApiAppContainer
+from labeljetty.service.worker import PrintServiceManager
+
+
+def run():
+    from labeljetty.config import Config
+    from labeljetty.core.logging import get_logger, get_uvicorn_loglevel
+
+    config = Config()
+    log = get_logger()
+    log.info(f"LOG_LEVEL: {config.LOG_LEVEL}")
+    log.info(f"UVICORN_LOG_LEVEL: {get_uvicorn_loglevel()}")
+    log.info(f"Create image storage directory at '{config.IMAGE_STORAGE_DIRECTORY}'")
+    log.info(f"USB Printer at {config.PRINTER_USB} if not exists")
+    if config.auth_enabled():
+        log.info(f"AUTH_MODE=protected — {len(config.AUTH_TOKENS)} token(s), {len(config.AUTH_USERS)} user(s)")
+    else:
+        log.warning(
+            "AUTH_MODE=open — NO AUTHENTICATION. Every endpoint is public. "
+            "Only run this on a trusted LAN. Set AUTH_MODE=protected with "
+            "AUTH_TOKENS/AUTH_USERS before exposing it more widely."
+        )
+    Path(config.IMAGE_STORAGE_DIRECTORY).mkdir(parents=True, exist_ok=True)
+
+    event_loop = asyncio.get_event_loop()
+    uvicorn_log_config = LOGGING_CONFIG
+    fast_api_container = FastApiAppContainer()
+    uvicorn_config = uvicorn.Config(
+        app=fast_api_container.app,
+        host=config.SERVER_LISTENING_HOST,
+        port=config.SERVER_LISTENING_PORT,
+        log_level=get_uvicorn_loglevel(),
+        log_config=uvicorn_log_config,
+        loop=event_loop,
+        lifespan=cast(LifespanType, "on"),
+    )
+    uvicorn_server = uvicorn.Server(config=uvicorn_config)
+    print_service = PrintServiceManager()
+    fast_api_container.add_startup_callback(print_service.start)
+    fast_api_container.add_shutdown_callback(print_service.shutdown)
+    try:
+        log.debug("Start uvicorn server...")
+        event_loop.run_until_complete(uvicorn_server.serve())
+    except KeyboardInterrupt:
+        log.info("KeyboardInterrupt shutdown...")
+    except Exception:
+        log.info("Panic shutdown...")
+        raise
+    finally:
+        # Always tear the worker down with us — uvicorn's lifespan shutdown does
+        # not run when KeyboardInterrupt escapes serve(), so the lifespan callback
+        # alone is not enough. shutdown() is idempotent.
+        print_service.shutdown()
+
+
+if __name__ == "__main__":
+    run()

labeljetty/config.py

@@ -0,0 +1,245 @@
+import os
+from typing import TYPE_CHECKING, List, Self
+from pathlib import Path
+from pydantic import BaseModel, Field, model_validator
+from pydantic_settings import BaseSettings
+from typing import Literal, Optional
+
+if TYPE_CHECKING:
+    from labeljetty.printer.connection import TSPLPrinterConnectionUSB
+
+# `.env` is looked up relative to the current working directory (the repo root,
+# per the README) — the override env var takes precedence. It is intentionally
+# not resolved relative to this file, which now lives inside the package.
+env_file_path = os.environ.get(
+    "LABELJETTY_DOT_ENV_FILE", Path(".env")
+)
+
+
+class LabelProfile(BaseModel):
+    """A named label stock (width × height in mm), selectable in the web UI."""
+
+    name: str
+    width_mm: int
+    height_mm: int
+    dpi: Optional[int] = None
+
+
+class AuthToken(BaseModel):
+    """A named API token for machine-to-machine access (sent as a Bearer token)."""
+
+    name: str
+    token: str
+
+
+class AuthUser(BaseModel):
+    """A local login user. ``password_hash`` is a ``pbkdf2_sha256$…`` string —
+    generate it with the ``labeljetty-hash-password`` CLI (never store plaintext)."""
+
+    username: str
+    password_hash: str
+
+
+class Config(BaseSettings):
+    APP_NAME: str = "LabelJetty"
+    LOG_LEVEL: Literal["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"] = Field(
+        default="DEBUG"
+    )
+    LOG_DISABLE_COLORS: bool = False
+    UVICORN_LOG_LEVEL: Optional[str] = Field(
+        default=None,
+        description="The log level of the uvicorn server. If not defined it will be the same as LOG_LEVEL.",
+    )
+    SERVER_LISTENING_PORT: int = Field(default=8888)
+    SERVER_LISTENING_HOST: str = Field(
+        default="localhost",
+        examples=["0.0.0.0", "localhost", "127.0.0.1", "176.16.8.123"],
+    )
+    SQLITE_PATH: str = Field(default="./printjobs.sqlite")
+    IMAGE_STORAGE_DIRECTORY: str = Field(
+        default="./images", description="Storage for posted images to print"
+    )
+    # --- Authentication ----------------------------------------------------- #
+    # AUTH_MODE selects the policy. "open" (default) = no auth at all — intended
+    # for a trusted LAN appliance. See the fat warning in the README before
+    # exposing the service beyond a trusted network. "protected" = every route
+    # requires a valid credential from ANY configured provider (tokens and/or
+    # local users; OIDC is planned as a drop-in third provider).
+    AUTH_MODE: Literal["open", "protected"] = Field(default="open")
+    # API tokens for machine-to-machine access, as a JSON list, e.g.
+    #   AUTH_TOKENS='[{"name":"ci","token":"s3cr3t"}]'
+    # Sent by clients as `Authorization: Bearer <token>`.
+    AUTH_TOKENS: List[AuthToken] = Field(default_factory=list)
+    # Local login users (humans, via the /login form → session cookie), e.g.
+    #   AUTH_USERS='[{"username":"tim","password_hash":"pbkdf2_sha256$..."}]'
+    # Generate password_hash with: labeljetty-hash-password
+    AUTH_USERS: List[AuthUser] = Field(default_factory=list)
+    # Secret used to sign session cookies. Leave unset for an ephemeral random
+    # secret (logins won't survive a restart) — set a stable value in production.
+    SESSION_SECRET: Optional[str] = Field(default=None)
+    SESSION_COOKIE_NAME: str = Field(default="labeljetty_session")
+    SESSION_MAX_AGE: int = Field(default=1_209_600, description="Session lifetime in seconds (default 14 days).")
+    # --- OIDC (reserved — planned drop-in provider, not yet implemented) ----- #
+    # AUTH_OIDC_ISSUER / AUTH_OIDC_CLIENT_ID / AUTH_OIDC_CLIENT_SECRET will be
+    # added when OIDC lands. The auth framework already returns a Principal and
+    # resolves providers from the session, so OIDC slots in without route changes.
+    DELETE_OLD_JOBS_AFTER_DAYS: int = Field(
+        default=100,
+        description="Old job entries in the database will be removed with associated files.",
+    )
+    # Default label geometry — used when a print job does not specify its own.
+    DEFAULT_LABEL_WIDTH_MM: int = Field(default=100)
+    DEFAULT_LABEL_HEIGHT_MM: int = Field(default=30)
+    DEFAULT_DPI: int = Field(default=203)
+    # Named label profiles selectable in the web UI, as a JSON list, e.g.
+    #   LABEL_PROFILES='[{"name":"Homebox","width_mm":57,"height_mm":32}]'
+    # The server default geometry is always offered as a "Default" profile too.
+    LABEL_PROFILES: List[LabelProfile] = Field(default_factory=list)
+
+    # --- Homebox integration (optional module) ------------------------------ #
+    # The module's UI section + endpoints appear only when HOMEBOX_URL and
+    # HOMEBOX_API_KEY are both set (and HOMEBOX_ENABLED is true).
+    HOMEBOX_ENABLED: bool = Field(default=True)
+    HOMEBOX_URL: Optional[str] = Field(
+        default=None, description="Base URL of the Homebox server, e.g. https://box.example.com"
+    )
+    HOMEBOX_API_KEY: Optional[str] = Field(
+        default=None, description="Homebox API key (prefixed 'hb_…')."
+    )
+    HOMEBOX_API_PREFIX: str = Field(
+        default="/api/v1",
+        description="API path prefix on the Homebox server (entities live at <prefix>/entities).",
+    )
+    HOMEBOX_ENTITY_URL_TEMPLATE: str = Field(
+        default="/item/{id}",
+        description="Web path (appended to HOMEBOX_URL) an entity opens at; '{id}' is substituted. Used for the QR link.",
+    )
+    HOMEBOX_LABEL_SERVICE_AUTOPRINT: bool = Field(
+        default=True,
+        description=(
+            "For the push 'external label service' endpoint: also enqueue the print "
+            "as a side effect of Homebox requesting the label image. Disable if your "
+            "Homebox build calls the label-service URL for previews too (would cause "
+            "spurious prints) — then use the print-command script (path C) instead."
+        ),
+    )
+
+    def homebox_configured(self) -> bool:
+        """True when the Homebox module should be active."""
+        return bool(self.HOMEBOX_ENABLED and self.HOMEBOX_URL and self.HOMEBOX_API_KEY)
+
+    def auth_enabled(self) -> bool:
+        """True when routes require authentication (``AUTH_MODE == "protected"``)."""
+        return self.AUTH_MODE == "protected"
+
+    def find_user(self, username: str) -> Optional[AuthUser]:
+        """Return the configured user with this username, or None."""
+        for user in self.AUTH_USERS:
+            if user.username == username:
+                return user
+        return None
+
+    @model_validator(mode="after")
+    def validate_auth_config(self) -> Self:
+        """Guard against a lock-everyone-out / no-op auth configuration."""
+        if self.AUTH_MODE == "protected" and not self.AUTH_TOKENS and not self.AUTH_USERS:
+            raise ValueError(
+                "AUTH_MODE=protected but neither AUTH_TOKENS nor AUTH_USERS is "
+                "configured — this would lock out every request. Configure at "
+                "least one token or user, or set AUTH_MODE=open."
+            )
+        return self
+
+    def get_label_profiles(self) -> List[LabelProfile]:
+        """Configured profiles, preceded by the server-default geometry."""
+        default = LabelProfile(
+            name="Default",
+            width_mm=self.DEFAULT_LABEL_WIDTH_MM,
+            height_mm=self.DEFAULT_LABEL_HEIGHT_MM,
+            dpi=self.DEFAULT_DPI,
+        )
+        return [default, *self.LABEL_PROFILES]
+    # USB Printer - Choose ONE of these methods:
+    PRINTER_USB: str = Field(
+        description=(
+            "USB printer identifier. Can be:\n"
+            "  - Serial number:     'serial:ABC123456'\n"
+            "  - Device path:       'path:/dev/bus/usb/001/004' or 'path:001/004'\n"
+            "  - USB port:          'port:3-1-2'\n"
+            "  - Vendor+Product ID: 'vid:1234:pid:5678' or 'vid:1234' (first match)\n"
+            "  - Bus+Address:       'bus:1:addr:4'"
+        ),
+        examples=[
+            "serial:ABC123456",
+            "path:/dev/bus/usb/001/004",
+            "port:3-1-2",
+            "vid:1234:pid:5678",
+            "bus:1:addr:4",
+        ],
+    )
+
+    @model_validator(mode="after")
+    def validate_printer_config(self) -> Self:
+        """Ensure printer USB identifier is provided"""
+        if not self.PRINTER_USB:
+            raise ValueError(
+                "PRINTER_USB must be set. Examples:\n"
+                "  PRINTER_USB=serial:ABC123456\n"
+                "  PRINTER_USB=port:3-1-2\n"
+                "  PRINTER_USB=vid:1234:pid:5678"
+            )
+        return self
+
+    def get_printer_connection(self) -> "TSPLPrinterConnectionUSB":
+        """Returns a printer connection using the configured identifier"""
+        from labeljetty.printer.connection import TSPLPrinterConnectionUSB
+
+        usb_id = self.PRINTER_USB
+
+        if usb_id.startswith("serial:"):
+            serial = usb_id.split(":", 1)[1]
+            return TSPLPrinterConnectionUSB.by_serial(serial)
+
+        elif usb_id.startswith("path:"):
+            path = usb_id.split(":", 1)[1]
+            return TSPLPrinterConnectionUSB.by_device_path(path)
+
+        elif usb_id.startswith("port:"):
+            port = usb_id.split(":", 1)[1]
+            return TSPLPrinterConnectionUSB.by_port(port)
+
+        elif usb_id.startswith("bus:"):
+            # Format: bus:1:addr:4
+            parts = usb_id.split(":")
+            if len(parts) != 4 or parts[2] != "addr":
+                raise ValueError(
+                    f"Invalid bus format: {usb_id}. Expected 'bus:1:addr:4'"
+                )
+            bus = int(parts[1])
+            addr = int(parts[3])
+            return TSPLPrinterConnectionUSB.by_bus_and_device_id(bus, addr)
+
+        elif usb_id.startswith("vid:"):
+            # Format: vid:1234:pid:5678 or vid:1234
+            parts = usb_id.split(":")
+            vendor = parts[1]
+            product = parts[3] if len(parts) >= 4 and parts[2] == "pid" else None
+            return TSPLPrinterConnectionUSB.by_vendor_and_product_id(vendor, product)
+
+        else:
+            raise ValueError(
+                f"Invalid PRINTER_USB format: {usb_id}\n"
+                "Must start with: serial:, path:, port:, bus:, or vid:"
+            )
+
+    ###### CONFIG END ######
+    # "class Config:" is a pydantic-settings pre-defined config class to control the behaviour of our settings model
+    # you could call it a "meta config" class
+    # if you dont know what this is you can ignore it.
+    # https://docs.pydantic.dev/latest/api/base_model/#pydantic.main.BaseModel.model_config
+
+    class Config:
+        env_nested_delimiter = "__"
+        env_file = env_file_path
+        env_file_encoding = "utf-8"
+        extra = "ignore"

labeljetty/core/db.py

@@ -0,0 +1,121 @@
+from typing import Optional, Literal, Dict, Generator, Any
+from datetime import datetime
+from sqlmodel import SQLModel, Field, Column, Session, create_engine
+from sqlalchemy import String
+from contextlib import contextmanager
+from labeljetty.core.sqltypes import SqlJsonText
+from labeljetty.config import Config
+import uuid
+from pathlib import Path
+from pydantic import field_serializer, field_validator
+from labeljetty.printer import JobType, TSPLPrinterStatusMessage
+
+config = Config()
+# Database URL - configure as needed
+DATABASE_URL = f"sqlite:///{config.SQLITE_PATH}"
+
+# Create engine
+engine = create_engine(DATABASE_URL, echo=False)
+
+
+class PrintJob(SQLModel, table=True):
+    id: Optional[uuid.UUID] = Field(default_factory=uuid.uuid4, primary_key=True)
+
+    job_type: JobType = Field(
+        sa_column=Column(String), description="Which renderer the worker should use"
+    )
+    # Type-specific parameters (text content, barcode_type, ecc_level, font_size, ...)
+    params: Dict[str, Any] = Field(
+        default_factory=dict,
+        sa_column=Column(SqlJsonText),
+    )
+    # Stored upload for file-based jobs (png/pdf); None for parameter-only jobs.
+    input_file_name: Optional[str] = None
+
+    # Per-job label geometry override; None → fall back to config defaults.
+    label_width_mm: Optional[int] = None
+    label_height_mm: Optional[int] = None
+    dpi: Optional[int] = None
+    copies: int = 1
+
+    error: Optional[str] = None
+    printer_status_on_finished: Optional[TSPLPrinterStatusMessage] = Field(
+        default=None,
+        sa_column=Column(SqlJsonText),
+    )
+    created_at: datetime = Field(default_factory=datetime.now)
+    started_at: Optional[datetime] = None
+    finished_at: Optional[datetime] = None
+
+    def get_status(self) -> Literal["queued", "processing", "done", "failed"]:
+        if self.started_at is None:
+            return "queued"
+        elif self.finished_at is None:
+            return "processing"
+        elif self.error is not None:
+            return "failed"
+        else:
+            return "done"
+
+    def get_input_file_path(self) -> Optional[Path]:
+        if self.input_file_name is None:
+            return None
+        return Path(f"{config.IMAGE_STORAGE_DIRECTORY}/{self.input_file_name}")
+
+    @field_serializer("printer_status_on_finished")
+    def serialize_printer_status(
+        self, value: Optional[TSPLPrinterStatusMessage]
+    ) -> Optional[Dict[str, Any]]:
+        """Convert TSPLPrinterStatusMessage to dict for database storage"""
+        return value.model_dump() if value is not None else None
+
+    @field_validator("printer_status_on_finished", mode="before")
+    @classmethod
+    def validate_printer_status(cls, value: Dict[str, Any] | None):
+        """Convert dict to TSPLPrinterStatusMessage when loading from database"""
+        if value is None or isinstance(value, TSPLPrinterStatusMessage):
+            return value
+        if isinstance(value, dict):
+            return TSPLPrinterStatusMessage(**value)
+        return value
+
+
+class WorkerStatus(SQLModel, table=True):
+    id: Optional[int] = Field(
+        default=1, primary_key=True, description="dummy pk field. Will always be one"
+    )
+    worker_error: Optional[str] = Field(
+        default=None, description="If set the worker is dead"
+    )
+    process_id: Optional[int] = Field(default=None)
+
+
+# Database initialization
+def init_db():
+    """Initialize database tables"""
+    SQLModel.metadata.create_all(engine)
+
+
+# Session management
+@contextmanager
+def get_session() -> Generator[Session, None, None]:
+    """Context manager for database sessions.
+
+    ``expire_on_commit=False`` keeps attributes populated after commit so jobs can
+    be safely returned/serialized once the session has closed (FastAPI responses,
+    the worker handing a fetched job to the printer).
+    """
+    session = Session(engine, expire_on_commit=False)
+    try:
+        yield session
+        session.commit()
+    except Exception:
+        session.rollback()
+        raise
+    finally:
+        session.close()
+
+
+def get_db_url() -> str:
+    """Get database URL"""
+    return DATABASE_URL

labeljetty/core/logging.py

@@ -0,0 +1,177 @@
+import logging
+import sys
+import os
+import hashlib
+from typing import Optional, Dict, Tuple
+import inspect
+from pathlib import Path
+from labeljetty.config import Config
+
+config = Config()
+
+
+APP_LOGGER_DEFAULT_NAME = config.APP_NAME
+
+
+# suppress "AttributeError: module 'bcrypt' has no attribute '__about__'"-warning
+# https://github.com/pyca/bcrypt/issues/684
+logging.getLogger("passlib").setLevel(logging.ERROR)
+
+
+# ANSI Color codes
+class Colors:
+    """ANSI color codes for terminal output"""
+
+    RESET = "\033[0m"
+
+    # Log level colors
+    DEBUG = "\033[36m"  # Cyan
+    INFO = "\033[32m"  # Green
+    WARNING = "\033[33m"  # Yellow
+    ERROR = "\033[31m"  # Red
+    CRITICAL = "\033[35m"  # Magenta
+
+    # Module name colors - distinctive, neutral palette
+    MODULE_COLORS = [
+        "\033[34m",  # Blue
+        "\033[33m",  # Yellow
+        "\033[32m",  # Green
+        "\033[36m",  # Cyan
+        "\033[35m",  # Magenta
+        "\033[94m",  # Bright Blue
+        "\033[93m",  # Bright Yellow
+        "\033[92m",  # Bright Green
+        "\033[96m",  # Bright Cyan
+        "\033[95m",  # Bright Magenta
+        "\033[91m",  # Bright Red (subtle, for modules)
+    ]
+
+
+def get_loglevel():
+    return os.getenv("LOG_LEVEL", config.LOG_LEVEL)
+
+
+def get_module_color(module_name: str) -> str:
+    """
+    Generate a deterministic, unique color for each module name.
+    Same module name will always get the same color.
+    """
+    if config.LOG_DISABLE_COLORS:
+        return ""
+
+    hash_digest = hashlib.md5(module_name.encode()).hexdigest()
+    hash_int = int(hash_digest, 16)
+    color_index = hash_int % len(Colors.MODULE_COLORS)
+    return Colors.MODULE_COLORS[color_index]
+
+
+def get_loglevel_color(level: int) -> str:
+    """Get the color for a specific log level"""
+    if config.LOG_DISABLE_COLORS:
+        return ""
+
+    if level >= logging.CRITICAL:
+        return Colors.CRITICAL
+    elif level >= logging.ERROR:
+        return Colors.ERROR
+    elif level >= logging.WARNING:
+        return Colors.WARNING
+    elif level >= logging.INFO:
+        return Colors.INFO
+    else:  # DEBUG and below
+        return Colors.DEBUG
+
+
+class ColoredFormatter(logging.Formatter):
+    """Custom formatter that adds colors to log output"""
+
+    GRAY = "\033[90m"  # Bright black (dark gray)
+
+    def format(self, record):
+        # Get colors
+        levelcolor = get_loglevel_color(record.levelno)
+
+        # Color the level name
+        record.levelname = f"{levelcolor}{record.levelname}{Colors.RESET if not config.LOG_DISABLE_COLORS else ''}"
+
+        # Format the record
+        result = super().format(record)
+
+        # Color the timestamp gray if colors are enabled
+        if not config.LOG_DISABLE_COLORS:
+            parts = result.split(" - ", 1)
+            if parts:
+                timestamp = parts[0]
+                rest = " - " + parts[1] if len(parts) > 1 else ""
+                result = f"{self.GRAY}{timestamp}{Colors.RESET}{rest}"
+
+        return result
+
+
+active_loggers_store = None
+
+
+def get_logger(
+    name: Optional[str] = APP_LOGGER_DEFAULT_NAME, modulename: Optional[str] = ""
+) -> logging.Logger:
+    global active_loggers_store
+    if active_loggers_store is None:
+        active_loggers_store = {}
+    if not modulename:
+        modulename = Path(inspect.stack()[1].filename).name
+    store_name = f"{name}{modulename}"
+    module = ""
+    module_color_code = ""
+
+    if modulename:
+        module_color_code = get_module_color(modulename)
+        module = f" - [{module_color_code}{modulename}{Colors.RESET}]"
+
+    logger_ = None
+
+    if store_name not in active_loggers_store:
+        logger_ = logging.getLogger(store_name)
+        logger_.setLevel(get_loglevel())
+
+        # Clear existing handlers to avoid duplicate logs
+        logger_.handlers.clear()
+
+        handler = logging.StreamHandler(sys.stdout)
+
+        format_string = f"%(asctime)s - {name}{module} - %(levelname)s - %(message)s"
+        formatter = ColoredFormatter(format_string)
+        handler.setFormatter(formatter)
+
+        logger_.addHandler(handler)
+        active_loggers_store[store_name] = logger_
+    else:
+        logger_ = active_loggers_store[store_name]
+
+    return logger_
+
+
+def get_uvicorn_loglevel() -> str:
+    # uvicorn has a different log level naming system than python, we need to translate the log level setting
+    UVICORN_LOG_LEVEL_map: Dict[Tuple[int | str, ...], str] = {
+        (logging.NOTSET, "NOTSET", "notset", "0"): "trace",
+        (logging.CRITICAL, "50", "CRITICAL", "critical", "FATAL", "fatal"): "critical",
+        (logging.ERROR, "40", "ERROR", "error"): "error",
+        (logging.WARNING, "30", "WARNING", "warning", "WARN", "warn"): "warning",
+        (logging.INFO, "20", "INFO", "info"): "info",
+        (logging.DEBUG, "10", "DEBUG", "debug"): "debug",
+    }
+
+    # if the uvicorn log level is not defined, it will be the same as the python log level
+    UVICORN_LOG_LEVEL: str = (
+        config.UVICORN_LOG_LEVEL
+        if config.UVICORN_LOG_LEVEL is not None
+        else config.LOG_LEVEL
+    )
+    uvicorn_log_level_mapped: str | None = None
+    for key, val in UVICORN_LOG_LEVEL_map.items():
+        if UVICORN_LOG_LEVEL in key:
+            uvicorn_log_level_mapped = val
+            break
+    if uvicorn_log_level_mapped is None:
+        uvicorn_log_level_mapped = "info"
+    return uvicorn_log_level_mapped

labeljetty/core/sqltypes.py

@@ -0,0 +1,25 @@
+from typing import Any, Optional
+from sqlalchemy.types import TypeDecorator, Text
+import json
+
+
+class SqlJsonText(TypeDecorator):
+    """Stores JSON-serializable Python objects (dicts or Pydantic models) as TEXT.
+
+    Pydantic models are dumped via ``model_dump()`` before serialization; ``None``
+    is stored as SQL NULL and read back as ``None``.
+    """
+
+    impl = Text
+
+    def process_bind_param(self, value: Any, dialect) -> Optional[str]:
+        if value is None:
+            return None
+        if hasattr(value, "model_dump"):
+            value = value.model_dump()
+        return json.dumps(value)
+
+    def process_result_value(self, value: Optional[str], dialect) -> Any:
+        if value is None:
+            return None
+        return json.loads(value)