jigkit 0.1.0__py3-none-any.whl

jigkit/__init__.py

@@ -0,0 +1,9 @@
+"""The shared foundations of small self-hosted web apps.
+
+Each module is imported on its own (``jigkit.settings``, ``jigkit.db``, ...); importing the
+package pulls in nothing beyond the version.
+"""
+
+from importlib.metadata import version
+
+__version__ = version("jigkit")

jigkit/db.py

@@ -0,0 +1,84 @@
+"""The async database engine, its sessions, and the transaction boundary.
+
+SQLite is the default backend and gets the pragmas its schema assumptions depend on; PostgreSQL
+(the ``postgres`` extra) gets a pre-ping, so a connection the server dropped is replaced instead
+of failing the next request.
+"""
+
+from __future__ import annotations
+
+from collections.abc import AsyncIterator
+from contextlib import asynccontextmanager
+from typing import Any
+
+from sqlalchemy import event
+from sqlalchemy.engine.interfaces import DBAPIConnection
+from sqlalchemy.ext.asyncio import (
+    AsyncEngine,
+    AsyncSession,
+    async_sessionmaker,
+    create_async_engine,
+)
+from sqlalchemy.pool import ConnectionPoolEntry
+
+#: Milliseconds a SQLite connection waits for a lock before giving up.
+SQLITE_BUSY_TIMEOUT_MS = 5000
+
+
+def is_sqlite(url: str) -> bool:
+    """Whether ``url`` names a SQLite database, whose pragmas another backend would reject."""
+    return url.startswith("sqlite")
+
+
+def apply_sqlite_pragmas(dbapi_connection: DBAPIConnection, _record: ConnectionPoolEntry) -> None:
+    """Turn on the SQLite behaviour a schema with foreign keys assumes.
+
+    ``foreign_keys`` is off by default in SQLite, which silently makes every ``ON DELETE`` rule a
+    no-op. WAL lets background work write while a request reads, instead of the two blocking each
+    other, and the busy timeout makes a writer wait for a lock rather than fail at once.
+    """
+    cursor = dbapi_connection.cursor()
+    try:
+        cursor.execute("PRAGMA foreign_keys=ON")
+        cursor.execute("PRAGMA journal_mode=WAL")
+        cursor.execute(f"PRAGMA busy_timeout={SQLITE_BUSY_TIMEOUT_MS}")
+    finally:
+        cursor.close()
+
+
+def create_engine(url: str, **kwargs: Any) -> AsyncEngine:
+    """Build an async engine for ``url``, with the backend's connection setup wired in.
+
+    Keyword arguments go to SQLAlchemy's ``create_async_engine``.
+    """
+    if is_sqlite(url):
+        engine = create_async_engine(url, **kwargs)
+        event.listen(engine.sync_engine, "connect", apply_sqlite_pragmas)
+        return engine
+    kwargs.setdefault("pool_pre_ping", True)
+    return create_async_engine(url, **kwargs)
+
+
+def create_sessionmaker(engine: AsyncEngine) -> async_sessionmaker[AsyncSession]:
+    """A session factory that leaves loaded objects usable after a commit.
+
+    ``expire_on_commit=False`` so a handler can read the object it just saved without a second
+    round trip, which under async would be implicit IO hidden behind attribute access.
+    """
+    return async_sessionmaker(engine, expire_on_commit=False, autoflush=False)
+
+
+@asynccontextmanager
+async def session_scope(factory: async_sessionmaker[AsyncSession]) -> AsyncIterator[AsyncSession]:
+    """A transaction that commits on success and rolls back on any exception.
+
+    Read-only blocks commit too. On PostgreSQL that ends them as a no-op COMMIT instead of a
+    ROLLBACK, which keeps the server's rollback ratio meaningful.
+    """
+    async with factory() as session:
+        try:
+            yield session
+            await session.commit()
+        except BaseException:
+            await session.rollback()
+            raise

jigkit/healthcheck.py

@@ -0,0 +1,92 @@
+"""A container health probe: ``python -m jigkit.healthcheck URL [--expect KEY=VALUE ...]``.
+
+Exits 0 only when the URL answers 200 with a JSON object holding every expected value. A probe
+that only checked the port would call a container healthy while every request it served failed,
+so an application reports what it depends on (``{"database": "connected"}``) and the probe
+checks it::
+
+    HEALTHCHECK CMD ["python", "-m", "jigkit.healthcheck",
+                     "http://127.0.0.1:8000/api/health", "--expect", "database=connected"]
+
+Only the standard library is used, so the probe starts quickly and needs no extra.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.error
+import urllib.request
+from collections.abc import Mapping, Sequence
+
+TIMEOUT_SECONDS = 5.0
+
+
+def probe(
+    url: str, expect: Mapping[str, object] | None = None, timeout: float = TIMEOUT_SECONDS
+) -> int:
+    """Report whether the application at ``url`` is healthy, as an exit status.
+
+    Each reason for an unhealthy result is printed to stderr, where Docker keeps it in the
+    container's health log.
+    """
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as response:  # noqa: S310
+            # urlopen raises for 4xx and 5xx, so this catches a 2xx that is not 200, which is not
+            # an answer to a health question either.
+            if response.status != 200:
+                return _unhealthy(f"HTTP {response.status}")
+            body = json.load(response)
+    except urllib.error.HTTPError as error:
+        # Closed explicitly: an HTTPError carries the response it was raised from.
+        with error:
+            return _unhealthy(f"HTTP {error.code}")
+    except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as error:
+        return _unhealthy(str(error))
+
+    if not isinstance(body, dict):
+        return _unhealthy(f"expected a JSON object, got {type(body).__name__}")
+    for key, wanted in (expect or {}).items():
+        if body.get(key) != wanted:
+            return _unhealthy(f"{key} is {body.get(key)!r}, expected {wanted!r}")
+    return 0
+
+
+def _unhealthy(reason: str) -> int:
+    """Print why the probe failed, and return the failing exit status."""
+    print(f"unhealthy: {reason}", file=sys.stderr)
+    return 1
+
+
+def _expectation(text: str) -> tuple[str, object]:
+    """Parse ``KEY=VALUE``, VALUE as JSON if it parses (``true``, ``3``) and as text if not."""
+    key, separator, raw = text.partition("=")
+    if not separator or not key:
+        raise argparse.ArgumentTypeError(f"expected KEY=VALUE, got {text!r}")
+    try:
+        value: object = json.loads(raw)
+    except json.JSONDecodeError:
+        value = raw
+    return key, value
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """Run the probe from the command line."""
+    parser = argparse.ArgumentParser(prog="python -m jigkit.healthcheck", description=__doc__)
+    parser.add_argument("url", help="the health endpoint to query")
+    parser.add_argument(
+        "--expect",
+        action="append",
+        type=_expectation,
+        default=[],
+        metavar="KEY=VALUE",
+        help="a value the JSON body must hold; repeatable",
+    )
+    parser.add_argument("--timeout", type=float, default=TIMEOUT_SECONDS)
+    arguments = parser.parse_args(argv)
+    return probe(arguments.url, dict(arguments.expect), arguments.timeout)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

jigkit/logging.py

@@ -0,0 +1,105 @@
+"""Where an application's log goes, and how its level changes while it runs.
+
+Two destinations. The stream is what ``docker logs`` shows. The file survives the container
+being recreated; it belongs in the mounted data directory, so it can be read from the host, and
+it rotates, because nothing else rotates a file inside a container.
+
+The level can change at runtime, because the moment DEBUG is needed is the moment something is
+failing, and restarting to get it loses whatever state was interesting.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterable
+from logging.handlers import RotatingFileHandler
+from pathlib import Path
+
+FORMAT = "%(asctime)s %(levelname)-7s %(name)s %(message)s"
+
+#: The levels an application offers to choose from.
+LEVELS = ("DEBUG", "INFO", "WARNING", "ERROR")
+
+#: Five files of five megabytes.
+MAX_BYTES = 5 * 1024 * 1024
+BACKUP_COUNT = 5
+
+#: Loggers that hold a level of their own and so are set alongside the root; uvicorn gives its
+#: access and error loggers one, and raising the root alone would leave them where they were.
+FOLLOW_ROOT = ("uvicorn", "uvicorn.access", "uvicorn.error")
+
+#: Loggers held at WARNING however low the application goes. httpx logs every request's URL at
+#: INFO and httpcore logs headers at DEBUG, and URLs and headers carry credentials: push-monitor
+#: tokens, bot tokens, session cookies.
+QUIET = ("httpx", "httpcore")
+
+# Marks the handlers this module installed, so a repeated call replaces them rather than stacking
+# a second copy that logs every line twice.
+_MARKER = "_jigkit_handler"
+
+
+def configure_logging(
+    level: str = "INFO",
+    *,
+    log_file: Path | None = None,
+    quiet: Iterable[str] = QUIET,
+    max_bytes: int = MAX_BYTES,
+    backup_count: int = BACKUP_COUNT,
+) -> Path | None:
+    """Install the stream handler, and the rotating file handler when ``log_file`` is given.
+
+    Idempotent: calling it again replaces the handlers it installed rather than adding more.
+    Returns the file's path, or None when there is no file or it could not be opened. An
+    unwritable data directory does not stop the application, since the stream still carries
+    everything.
+    """
+    quiet = tuple(quiet)
+    apply_level(level, quiet=quiet)
+
+    root = logging.getLogger()
+    for handler in [h for h in root.handlers if getattr(h, _MARKER, False)]:
+        root.removeHandler(handler)
+        handler.close()
+
+    formatter = logging.Formatter(FORMAT)
+    stream = logging.StreamHandler()
+    stream.setFormatter(formatter)
+    setattr(stream, _MARKER, True)
+    root.addHandler(stream)
+
+    if log_file is None:
+        return None
+    try:
+        log_file.parent.mkdir(parents=True, exist_ok=True)
+        file_handler = RotatingFileHandler(
+            log_file, maxBytes=max_bytes, backupCount=backup_count, encoding="utf-8"
+        )
+    except OSError:
+        logging.getLogger(__name__).warning(
+            "could not open %s for writing; logging to the stream only", log_file, exc_info=True
+        )
+        return None
+    file_handler.setFormatter(formatter)
+    setattr(file_handler, _MARKER, True)
+    root.addHandler(file_handler)
+    return log_file
+
+
+def apply_level(level: str, *, quiet: Iterable[str] = QUIET) -> int:
+    """Set the level of the root logger and of the loggers that follow it, and return it.
+
+    The ``quiet`` loggers never go below WARNING.
+    """
+    resolved = resolve_level(level)
+    logging.getLogger().setLevel(resolved)
+    for name in FOLLOW_ROOT:
+        logging.getLogger(name).setLevel(resolved)
+    for name in quiet:
+        logging.getLogger(name).setLevel(max(resolved, logging.WARNING))
+    return resolved
+
+
+def resolve_level(level: str) -> int:
+    """The numeric level for a name, INFO for anything unrecognised."""
+    value = logging.getLevelNamesMapping().get(level.strip().upper())
+    return value if value is not None else logging.INFO

jigkit/migrations.py

@@ -0,0 +1,131 @@
+"""Alembic's environment, shared: the whole body of an application's ``alembic/env.py``.
+
+An application's env.py becomes::
+
+    from jigkit.migrations import run_migrations
+
+    from myapp.config import get_settings
+    from myapp.models import Base
+
+    run_migrations(get_settings().resolved_database_url, Base.metadata)
+
+Migrations run through jigkit's own engine, so ``alembic upgrade head`` and the running
+application can never disagree about which database is meant or how it is connected to.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from logging.config import fileConfig
+from pathlib import Path
+from typing import Any
+
+from alembic import context
+from sqlalchemy import Connection, MetaData, event
+from sqlalchemy.engine import make_url
+
+from .db import create_engine, is_sqlite
+from .models import UtcDateTime
+
+
+def render_item(obj_type: str, obj: object, autogen_context: Any) -> str | bool:  # noqa: ARG001
+    """Render :class:`~jigkit.models.UtcDateTime` as the plain ``DateTime`` it is built on.
+
+    A migration has to keep running years later, and one that imports an application class stops
+    working when that class moves. At the DDL level the type is exactly ``sa.DateTime()``.
+
+    Everything else returns False, Alembic's "use the default rendering"; None would render the
+    item as an empty string.
+    """
+    if obj_type == "type" and isinstance(obj, UtcDateTime):
+        return "sa.DateTime()"
+    return False
+
+
+def run_migrations(url: str, metadata: MetaData) -> None:
+    """Run the migrations Alembic was asked for against the database at ``url``.
+
+    Online, this applies them; offline (``alembic upgrade --sql``), it prints the SQL instead.
+    The logging configuration in alembic.ini is applied first, as Alembic's own template does.
+    """
+    if context.config.config_file_name is not None:
+        fileConfig(context.config.config_file_name)
+    if context.is_offline_mode():
+        _run_offline(url, metadata)
+    else:
+        asyncio.run(_run_online(url, metadata))
+
+
+def _configure_options(metadata: MetaData) -> dict[str, Any]:
+    """The Alembic options both modes share.
+
+    ``render_as_batch`` is required for SQLite, which cannot ALTER a column or a constraint:
+    batch mode copies the table instead. Set unconditionally, it keeps generated migrations
+    portable between backends.
+    """
+    return {
+        "target_metadata": metadata,
+        "render_as_batch": True,
+        "compare_type": True,
+        "render_item": render_item,
+    }
+
+
+def _run_offline(url: str, metadata: MetaData) -> None:
+    """Emit the migrations' SQL to stdout instead of running it."""
+    context.configure(
+        url=url,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+        **_configure_options(metadata),
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def _run(connection: Connection, metadata: MetaData) -> None:
+    """Apply migrations on a live connection, then prove they left no dangling references."""
+    context.configure(connection=connection, **_configure_options(metadata))
+    with context.begin_transaction():
+        context.run_migrations()
+    if connection.dialect.name == "sqlite":
+        dangling = connection.exec_driver_sql("PRAGMA foreign_key_check").fetchall()
+        if dangling:
+            raise RuntimeError(f"the migrations left rows pointing at nothing: {dangling}")
+
+
+def _without_foreign_keys(dbapi_connection: Any, _record: object) -> None:
+    """Turn SQLite's foreign keys off for the migrations.
+
+    Batch mode rebuilds a table by copying it, dropping the original and renaming the copy. With
+    foreign keys on, dropping the original runs every ON DELETE rule that points at it, so
+    rebuilding a parent table would delete or orphan every child row. The check after the
+    migrations stands in for the enforcement left off during them.
+    """
+    cursor = dbapi_connection.cursor()
+    try:
+        cursor.execute("PRAGMA foreign_keys=OFF")
+    finally:
+        cursor.close()
+
+
+def _ensure_sqlite_directory(url: str) -> None:
+    """Create the directory a SQLite file lives in, which SQLite will not do itself."""
+    database = make_url(url).database
+    if database and database != ":memory:" and not database.startswith("file:"):
+        Path(database).parent.mkdir(parents=True, exist_ok=True)
+
+
+async def _run_online(url: str, metadata: MetaData) -> None:
+    """Apply migrations against the database at ``url``."""
+    engine = create_engine(url)
+    if is_sqlite(url):
+        _ensure_sqlite_directory(url)
+        # Registered after create_engine's own listener, which turns foreign keys on for every
+        # connection, so this one runs last and wins.
+        event.listen(engine.sync_engine, "connect", _without_foreign_keys)
+    try:
+        async with engine.connect() as connection:
+            await connection.run_sync(_run, metadata)
+    finally:
+        await engine.dispose()

jigkit/models.py

@@ -0,0 +1,70 @@
+"""The declarative base every model shares, and the column types that keep data consistent.
+
+One :class:`Base` per process: an application's models and the tables jigkit itself provides
+register on the same metadata, so one set of migrations covers them all.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Any
+
+from sqlalchemy import DateTime, MetaData, TypeDecorator
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+#: Deterministic constraint names. SQLite cannot ALTER a constraint, so Alembic rebuilds the
+#: whole table to change one, which it can only do when every constraint has a name it can
+#: reproduce.
+NAMING_CONVENTION = {
+    "ix": "ix_%(column_0_label)s",
+    "uq": "uq_%(table_name)s_%(column_0_name)s",
+    "ck": "ck_%(table_name)s_%(constraint_name)s",
+    "fk": "fk_%(table_name)s_%(column_0_name)s_%(referred_table_name)s",
+    "pk": "pk_%(table_name)s",
+}
+
+
+class UtcDateTime(TypeDecorator[datetime]):
+    """A timestamp that is always a timezone-aware UTC ``datetime`` in Python.
+
+    SQLite has no timestamp type: it stores a string and hands back a naive ``datetime``, and
+    comparing that with ``datetime.now(UTC)`` raises ``TypeError``. Normalising to UTC on the way
+    in and re-attaching the zone on the way out keeps every datetime aware, whatever the backend.
+    Naive input is rejected rather than assumed to be UTC, because the assumption is wrong exactly
+    when a caller has a local time in hand.
+    """
+
+    impl = DateTime
+    cache_ok = True
+
+    def process_bind_param(self, value: datetime | None, dialect: Any) -> datetime | None:  # noqa: ARG002
+        """Store an aware datetime as naive UTC."""
+        if value is None:
+            return None
+        if value.tzinfo is None:
+            raise ValueError(f"expected a timezone-aware datetime, got {value!r}")
+        return value.astimezone(UTC).replace(tzinfo=None)
+
+    def process_result_value(self, value: datetime | None, dialect: Any) -> datetime | None:  # noqa: ARG002
+        """Load a stored naive UTC value as an aware datetime."""
+        if value is None:
+            return None
+        return value.replace(tzinfo=UTC)
+
+
+def utcnow() -> datetime:
+    """The current time, timezone-aware, for column defaults."""
+    return datetime.now(UTC)
+
+
+class Base(DeclarativeBase):
+    """Declarative base for every model."""
+
+    metadata = MetaData(naming_convention=NAMING_CONVENTION)
+
+
+class TimestampMixin:
+    """Creation and modification times, maintained by the ORM."""
+
+    created_at: Mapped[datetime] = mapped_column(UtcDateTime, default=utcnow)
+    updated_at: Mapped[datetime] = mapped_column(UtcDateTime, default=utcnow, onupdate=utcnow)

jigkit/secrets.py

@@ -0,0 +1,66 @@
+"""Secrets an application generates for itself on first start and keeps in its data directory.
+
+Generating on first start is what lets an application run with no configuration at all. The file
+is never rewritten afterwards: whatever the secret protects (encrypted rows, signed tokens) is
+lost with it.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import secrets
+import tempfile
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+#: Random bytes in a generated secret, before URL-safe base64 encoding.
+SECRET_BYTES = 48
+
+
+class SecretFileError(RuntimeError):
+    """A secret file exists but holds nothing usable."""
+
+
+def load_or_create_secret(path: Path, nbytes: int = SECRET_BYTES) -> str:
+    """Return the secret in ``path``, generating it there first if the file does not exist.
+
+    The secret is written to a temporary owner-only file beside ``path`` and hard-linked into
+    place. The link either succeeds with the whole secret already in the file, or fails because
+    the file exists, so when two processes start at once one creates the secret and the other
+    reads it, and neither ever sees a half-written file.
+
+    An existing empty file is an error rather than something to overwrite: the secret it should
+    hold may already protect data, and replacing it would silently make that data unreadable.
+    """
+    try:
+        return _read(path)
+    except FileNotFoundError:
+        pass
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    secret = secrets.token_urlsafe(nbytes)
+    # mkstemp creates the file 0600, so the secret is never readable by anyone else.
+    fd, temporary = tempfile.mkstemp(dir=path.parent, prefix=f".{path.name}.")
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as handle:
+            handle.write(secret)
+            handle.flush()
+            os.fsync(handle.fileno())
+        try:
+            os.link(temporary, path)
+        except FileExistsError:
+            return _read(path)
+    finally:
+        os.unlink(temporary)
+    logger.info("generated a new secret at %s", path)
+    return secret
+
+
+def _read(path: Path) -> str:
+    """The secret in ``path``, which must not be empty."""
+    value = path.read_text(encoding="utf-8").strip()
+    if not value:
+        raise SecretFileError(f"{path} is empty; restore it, or delete it to generate a new one")
+    return value

jigkit/settings.py

@@ -0,0 +1,139 @@
+"""Settings read from the environment, with the behaviour every application needs.
+
+An application subclasses :class:`AppSettings`, adds its own fields, and gets:
+
+- **Blank means unset.** Compose writes ``VAR: ${VAR:-}`` for an optional setting, so a variable
+  nobody set arrives as an empty string. A blank value is dropped before validation, so the
+  field takes its default: an empty ``STATIC_DIR`` stays ``None`` instead of becoming
+  ``Path(".")``, and an empty ``COOKIE_SECURE`` stays "follow the scheme" instead of failing to
+  parse.
+- **Secrets from files.** A field ``x`` with a sibling ``x_file`` can be given either directly
+  or as a path to a file holding it, such as a mounted Docker secret. Setting both is an error,
+  as is a file that is empty or unreadable: either way the application would otherwise run with
+  a value nobody intended.
+- **A known time zone.** ``TZ`` is validated at startup, so a typo stops the application instead
+  of surfacing later as a scheduler that cannot compute the next run.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, ClassVar, Self
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from pydantic import AliasChoices, Field, TypeAdapter, field_validator, model_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+#: The suffix that marks a field as the file form of another.
+FILE_SUFFIX = "_file"
+
+
+class AppSettings(BaseSettings):
+    """The settings every application shares.
+
+    Subclass it and add fields. Set ``database_filename`` on the subclass to name the SQLite file
+    the default database URL points at.
+    """
+
+    model_config = SettingsConfigDict(env_file=".env", extra="ignore", populate_by_name=True)
+
+    #: The SQLite file inside ``data_dir`` that :attr:`resolved_database_url` defaults to.
+    database_filename: ClassVar[str] = "app.db"
+
+    #: Where all mutable state lives: the database, generated keys, logs, uploads. One directory
+    #: means a deployment has exactly one thing to persist and back up.
+    data_dir: Path = Path("data")
+    #: Where the built single-page app is served from. Unset, the API runs on its own, which is
+    #: how a development stack works (the frontend's dev server serves the app and proxies the API).
+    static_dir: Path | None = None
+    #: Overrides the default SQLite database in ``data_dir``.
+    database_url: str | None = None
+
+    log_level: str = "INFO"
+
+    #: The address people open the application at, behind its reverse proxy.
+    public_url: str | None = None
+    #: Forces the session cookie's Secure flag on or off. Unset, it follows the request's scheme.
+    cookie_secure: bool | None = None
+    #: The proxies whose X-Forwarded-For and X-Forwarded-Proto are believed, as uvicorn's
+    #: ``forwarded_allow_ips`` takes them. Never ``*``: uvicorn then believes the leftmost
+    #: address, which the client wrote itself.
+    forwarded_allow_ips: str = "127.0.0.1"
+
+    #: The application's time zone, read from ``TZ``, which the container's clock follows too.
+    timezone: str = Field("UTC", validation_alias=AliasChoices("TZ", "timezone"))
+
+    #: The commit the image was built from; unset outside an image.
+    revision: str | None = None
+
+    #: Whether in-process scheduled work runs. Tests turn it off and drive the work themselves.
+    scheduler_enabled: bool = True
+    scheduler_tick_seconds: int = Field(60, ge=1)
+
+    @model_validator(mode="before")
+    @classmethod
+    def _blank_means_unset(cls, data: Any) -> Any:
+        """Drop blank string values, so their fields take their defaults."""
+        if not isinstance(data, dict):
+            return data
+        return {
+            key: value
+            for key, value in data.items()
+            if not (isinstance(value, str) and not value.strip())
+        }
+
+    @field_validator("timezone")
+    @classmethod
+    def _known_zone(cls, value: str) -> str:
+        """Reject a time zone the standard library does not know."""
+        try:
+            ZoneInfo(value)
+        except (ZoneInfoNotFoundError, ValueError) as error:
+            raise ValueError(f"unknown time zone {value!r}") from error
+        return value
+
+    @model_validator(mode="after")
+    def _read_secret_files(self) -> Self:
+        """Fill each field whose ``*_file`` companion names a file, from that file.
+
+        The file's stripped text is validated as the target field's type, so a number or a flag
+        can come from a file as well as a string. The value and its file are exclusive, and the
+        file must hold something: an unreadable or empty file is an error rather than a silent
+        fall back to the default.
+        """
+        fields = type(self).model_fields
+        for name in fields:
+            if not name.endswith(FILE_SUFFIX):
+                continue
+            target = name.removesuffix(FILE_SUFFIX)
+            path = getattr(self, name)
+            if target not in fields or path is None:
+                continue
+            env_target = target.upper()
+            if target in self.model_fields_set:
+                raise ValueError(
+                    f"{env_target} and {env_target}{FILE_SUFFIX.upper()} are exclusive; "
+                    "set one of them"
+                )
+            try:
+                value = Path(path).read_text(encoding="utf-8").strip()
+            except OSError as error:
+                raise ValueError(
+                    f"{env_target}{FILE_SUFFIX.upper()}: cannot read {path}: {error.strerror}"
+                ) from error
+            if not value:
+                raise ValueError(f"{env_target}{FILE_SUFFIX.upper()}: {path} is empty")
+            setattr(self, target, TypeAdapter(fields[target].annotation).validate_python(value))
+        return self
+
+    @property
+    def resolved_database_url(self) -> str:
+        """The database URL, defaulting to a SQLite file inside the data directory."""
+        if self.database_url:
+            return self.database_url
+        return f"sqlite+aiosqlite:///{self.data_dir / self.database_filename}"
+
+    @property
+    def zone(self) -> ZoneInfo:
+        """The application's time zone."""
+        return ZoneInfo(self.timezone)

jigkit/testing/__init__.py

@@ -0,0 +1,90 @@
+"""The pytest plugin for applications built on jigkit (extra ``testing``).
+
+Load it from the application's ``conftest.py``::
+
+    pytest_plugins = ["jigkit.testing"]
+
+It provides fixtures; the migration checks are in :mod:`jigkit.testing.migrations`. Fixtures an
+application defines under the same name in its own conftest take precedence.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import socket
+from collections.abc import Iterator
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+#: Host names a test may still resolve and connect to under :func:`no_network`.
+LOCAL_NAMES = frozenset({"localhost", "localhost.localdomain", ""})
+
+
+class NetworkAccessError(AssertionError):
+    """A test tried to reach a host other than this machine."""
+
+
+@pytest.fixture
+def data_dir(tmp_path: Path) -> Path:
+    """A throwaway data directory, created and empty."""
+    directory = tmp_path / "data"
+    directory.mkdir()
+    return directory
+
+
+def _is_local(host: object) -> bool:
+    """Whether ``host`` (a name or an address) is this machine."""
+    if not isinstance(host, str):
+        return False
+    if host.lower() in LOCAL_NAMES:
+        return True
+    try:
+        return ipaddress.ip_address(host.split("%", 1)[0]).is_loopback
+    except ValueError:
+        return False
+
+
+def _is_allowed(family: int, address: Any) -> bool:
+    """Whether a socket address of ``family`` stays on this machine."""
+    if family == getattr(socket, "AF_UNIX", object()):
+        return True
+    if isinstance(address, tuple) and address:
+        return _is_local(address[0])
+    return False
+
+
+@pytest.fixture
+def no_network(monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
+    """Fail the test if it resolves or connects to anything but this machine.
+
+    A suite that quietly reaches the network depends on DNS and on hosts it does not control,
+    and sends traffic to whatever host a fixture names. Loopback stays open, so tests can still
+    talk to a server they started themselves. Request it per test, or make it autouse in the
+    application's conftest.
+    """
+    real_connect = socket.socket.connect
+    real_connect_ex = socket.socket.connect_ex
+    real_getaddrinfo = socket.getaddrinfo
+
+    def guarded_connect(self: socket.socket, address: Any) -> None:
+        if not _is_allowed(self.family, address):
+            raise NetworkAccessError(f"test tried to connect to {address!r}")
+        real_connect(self, address)
+
+    def guarded_connect_ex(self: socket.socket, address: Any) -> int:
+        if not _is_allowed(self.family, address):
+            raise NetworkAccessError(f"test tried to connect to {address!r}")
+        return real_connect_ex(self, address)
+
+    def guarded_getaddrinfo(host: Any, *args: Any, **kwargs: Any) -> Any:
+        name = host.decode() if isinstance(host, bytes) else host
+        if name is not None and not _is_local(name):
+            raise NetworkAccessError(f"test tried to resolve {name!r}")
+        return real_getaddrinfo(host, *args, **kwargs)
+
+    monkeypatch.setattr(socket.socket, "connect", guarded_connect)
+    monkeypatch.setattr(socket.socket, "connect_ex", guarded_connect_ex)
+    monkeypatch.setattr(socket, "getaddrinfo", guarded_getaddrinfo)
+    yield

jigkit/testing/migrations.py

@@ -0,0 +1,301 @@
+"""Checks an application runs against its own Alembic migrations.
+
+Every check runs ``alembic`` in a subprocess from the application's directory, exactly as a
+container's entrypoint does, so the application's real env.py and settings are what is tested::
+
+    from jigkit.testing.migrations import MigrationProject
+
+    PROJECT = MigrationProject(Path(__file__).parents[1], database_filename="myapp.db")
+
+    def test_models_match_migrations(data_dir):
+        PROJECT.assert_models_match(Base.metadata, data_dir)
+
+    def test_one_head():
+        PROJECT.assert_single_head()
+
+    def test_rebuilding_parents_keeps_children(data_dir, tmp_path):
+        PROJECT.assert_parent_rebuilds_keep_children(Base.metadata, data_dir, tmp_path)
+
+The application's tests build their schema with ``create_all``, so without these nothing would
+notice a model change that never got a migration, or a migration that empties a table.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import uuid
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from datetime import UTC, date, datetime, time, timedelta
+from decimal import Decimal
+from pathlib import Path
+from typing import Any
+
+from alembic.autogenerate import compare_metadata
+from alembic.config import Config
+from alembic.migration import MigrationContext
+from alembic.script import ScriptDirectory
+from sqlalchemy import (
+    JSON,
+    Boolean,
+    Column,
+    Date,
+    DateTime,
+    Enum,
+    Float,
+    Integer,
+    Interval,
+    LargeBinary,
+    MetaData,
+    Numeric,
+    String,
+    Table,
+    Time,
+    Uuid,
+    create_engine,
+    func,
+    select,
+)
+
+from jigkit.models import UtcDateTime
+
+#: Environment variables passed through to the Alembic subprocess. Everything else is left out,
+#: so a developer's own DATABASE_URL or similar cannot point the check at a real database.
+PASSED_THROUGH = ("PATH", "HOME", "TMPDIR", "LANG", "LC_ALL", "SYSTEMROOT")
+
+#: The revision of the throwaway migration that rebuilds every parent table.
+REBUILD_REVISION = "jigkit_rebuild_parents"
+
+
+class UnsupportedColumnError(TypeError):
+    """A column needs a value the synthetic row generator cannot invent."""
+
+
+@dataclass(frozen=True)
+class MigrationProject:
+    """An application directory holding ``alembic.ini``, and how to point it at a database.
+
+    ``env`` is added to the subprocess environment, for settings the application insists on
+    (a secret key, say). The data directory reaches the application as ``data_dir_variable``.
+    """
+
+    directory: Path
+    database_filename: str = "app.db"
+    env: Mapping[str, str] = field(default_factory=dict)
+    data_dir_variable: str = "DATA_DIR"
+    ini_name: str = "alembic.ini"
+
+    def config(self) -> Config:
+        """The application's Alembic configuration, with paths made absolute."""
+        config = Config(str(self.directory / self.ini_name))
+        location = config.get_main_option("script_location") or "alembic"
+        config.set_main_option("script_location", str(self.directory / location))
+        return config
+
+    def sync_url(self, data_dir: Path) -> str:
+        """A synchronous URL for the SQLite database the application keeps in ``data_dir``."""
+        return f"sqlite:///{data_dir / self.database_filename}"
+
+    def alembic(self, data_dir: Path, *args: str, directory: Path | None = None) -> None:
+        """Run ``alembic *args`` against the database in ``data_dir``; raise if it fails.
+
+        ``directory`` runs it from a copy of the project instead of the project itself.
+        """
+        cwd = directory or self.directory
+        environment = {k: v for k, v in os.environ.items() if k in PASSED_THROUGH}
+        # Coverage measures subprocesses through variables of its own; keep them so the code
+        # the migrations run is measured too.
+        environment |= {k: v for k, v in os.environ.items() if k.startswith("COVERAGE")}
+        environment |= {"PYTHONPATH": os.pathsep.join(self._python_path())}
+        environment |= dict(self.env)
+        environment[self.data_dir_variable] = str(data_dir)
+        result = subprocess.run(
+            [sys.executable, "-m", "alembic", "-c", self.ini_name, *args],
+            cwd=cwd,
+            env=environment,
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode != 0:
+            raise AssertionError(
+                f"alembic {' '.join(args)} failed with status {result.returncode}:\n"
+                f"{result.stdout}{result.stderr}"
+            )
+
+    def _python_path(self) -> list[str]:
+        """The project's ``prepend_sys_path`` entries made absolute, then the current path.
+
+        Absolute, so the project's own modules still import when Alembic runs from a copy.
+        """
+        config = Config(str(self.directory / self.ini_name))
+        entries = (config.get_main_option("prepend_sys_path") or "").split(os.pathsep)
+        prepended = [str((self.directory / entry).resolve()) for entry in entries if entry]
+        return [*prepended, *sys.path]
+
+    def assert_single_head(self) -> None:
+        """Fail unless the migrations have exactly one head.
+
+        Two heads mean two migrations claim the same parent, and ``alembic upgrade head`` fails
+        on a deployment rather than in CI.
+        """
+        heads = ScriptDirectory.from_config(self.config()).get_heads()
+        assert len(heads) == 1, f"expected one migration head, found {len(heads)}: {heads}"
+
+    def assert_models_match(self, metadata: MetaData, data_dir: Path) -> None:
+        """Fail unless upgrading an empty database to head yields exactly ``metadata``'s schema."""
+        self.alembic(data_dir, "upgrade", "head")
+        engine = create_engine(self.sync_url(data_dir))
+        try:
+            with engine.connect() as connection:
+                context = MigrationContext.configure(
+                    connection, opts={"compare_type": True, "render_as_batch": True}
+                )
+                differences = compare_metadata(context, metadata)
+        finally:
+            engine.dispose()
+        assert differences == [], (
+            f"the models and the migrations disagree; generate a migration for: {differences}"
+        )
+
+    def assert_parent_rebuilds_keep_children(
+        self,
+        metadata: MetaData,
+        data_dir: Path,
+        scratch: Path,
+        overrides: Mapping[str, Mapping[str, Any]] | None = None,
+    ) -> None:
+        """Fail if rebuilding a table that others point at loses or orphans their rows.
+
+        SQLite's batch mode rebuilds a table by copying it, dropping the original and renaming
+        the copy; with foreign keys on, the drop runs every ON DELETE rule pointing at it. This
+        upgrades a database to head, puts one synthetic row in every table, then runs a copy of
+        the migrations with one more that rebuilds every referenced table, and checks every row
+        is still there.
+
+        Rows are invented from column types. ``overrides`` supplies values for columns whose
+        type or constraints the generator cannot satisfy: ``{"table": {"column": value}}``.
+        ``scratch`` is an empty directory for the copy of the migrations.
+        """
+        parents = sorted(
+            {fk.column.table.name for table in metadata.sorted_tables for fk in table.foreign_keys}
+        )
+        assert parents, "no table is referenced by a foreign key; there is nothing to check"
+
+        self.alembic(data_dir, "upgrade", "head")
+        engine = create_engine(self.sync_url(data_dir))
+        try:
+            with engine.begin() as connection:
+                for table in metadata.sorted_tables:
+                    connection.execute(table.insert().values(**synthetic_row(table, overrides)))
+            before = _row_counts(engine, metadata)
+
+            copy = self._copy_with_rebuild(scratch, parents)
+            self.alembic(data_dir, "upgrade", "head", directory=copy)
+
+            after = _row_counts(engine, metadata)
+        finally:
+            engine.dispose()
+        lost = {name: (before[name], after[name]) for name in before if after[name] != before[name]}
+        assert not lost, (
+            f"rebuilding {', '.join(parents)} changed row counts (before, after): {lost}"
+        )
+
+    def _copy_with_rebuild(self, scratch: Path, parents: list[str]) -> Path:
+        """Copy the project's Alembic files into ``scratch`` and add the rebuilding migration."""
+        config = self.config()
+        source = Path(config.get_main_option("script_location") or "")
+        head = ScriptDirectory.from_config(config).get_current_head()
+        shutil.copy(self.directory / self.ini_name, scratch / self.ini_name)
+        relative = source.relative_to(self.directory)
+        shutil.copytree(source, scratch / relative)
+        versions = scratch / relative / "versions"
+        (versions / f"{REBUILD_REVISION}.py").write_text(
+            "from alembic import op\n\n"
+            f"revision = {REBUILD_REVISION!r}\n"
+            f"down_revision = {head!r}\n"
+            "branch_labels = None\n"
+            "depends_on = None\n\n\n"
+            "def upgrade():\n"
+            f"    for name in {parents!r}:\n"
+            "        with op.batch_alter_table(name, recreate='always'):\n"
+            "            pass\n\n\n"
+            "def downgrade():\n"
+            "    pass\n",
+            encoding="utf-8",
+        )
+        return scratch
+
+
+def _row_counts(engine: Any, metadata: MetaData) -> dict[str, int]:
+    """The number of rows in each of ``metadata``'s tables."""
+    with engine.connect() as connection:
+        return {
+            table.name: connection.execute(select(func.count()).select_from(table)).scalar_one()
+            for table in metadata.sorted_tables
+        }
+
+
+def synthetic_row(
+    table: Table, overrides: Mapping[str, Mapping[str, Any]] | None = None
+) -> dict[str, Any]:
+    """Values for one row of ``table`` that point every foreign key at the referenced table's row.
+
+    Every table gets a row with integer primary keys of 1, so a foreign key column takes the
+    value of the column it references in the row generated for that table. Nullable columns with
+    no foreign key and columns with a server default are left out.
+    """
+    explicit = dict((overrides or {}).get(table.name, {}))
+    row: dict[str, Any] = {}
+    for column in table.columns:
+        if column.name in explicit:
+            row[column.name] = explicit[column.name]
+        elif column.foreign_keys:
+            # A column with several foreign keys points at the same value in each referenced row,
+            # since every generated row has the same keys; the first one decides it.
+            fk = sorted(column.foreign_keys, key=lambda key: key.target_fullname)[0]
+            row[column.name] = _value_for(fk.column, table.name, overrides)
+        elif column.primary_key or not (column.nullable or column.server_default is not None):
+            row[column.name] = _value_for(column, table.name, overrides)
+    return row
+
+
+def _value_for(
+    column: Column[Any], table_name: str, overrides: Mapping[str, Mapping[str, Any]] | None
+) -> Any:
+    """The value the generated row of ``column``'s table holds in it."""
+    owner = column.table.name
+    explicit = (overrides or {}).get(owner, {})
+    if column.name in explicit:
+        return explicit[column.name]
+    column_type = column.type
+    # Checked before the generic table below: Enum is a String, and UtcDateTime wraps DateTime.
+    if isinstance(column_type, Enum):
+        return column_type.enums[0]
+    if isinstance(column_type, UtcDateTime):
+        return datetime(2026, 1, 1, tzinfo=UTC)
+    simple: list[tuple[type, Any]] = [
+        (Boolean, True),
+        (Integer, 1),
+        (String, "x"),
+        (DateTime, datetime(2026, 1, 1)),
+        (Date, date(2026, 1, 1)),
+        (Time, time(0, 0)),
+        (Interval, timedelta(0)),
+        # Float subclasses Numeric, so it comes first.
+        (Float, 1.0),
+        (Numeric, Decimal(1)),
+        (LargeBinary, b"\x00"),
+        (JSON, {}),
+        (Uuid, uuid.UUID(int=1)),
+    ]
+    for kind, value in simple:
+        if isinstance(column_type, kind):
+            return value
+    raise UnsupportedColumnError(
+        f"no synthetic value for {owner}.{column.name} ({column_type!r}) while filling "
+        f"{table_name}; pass one in overrides={{{owner!r}: {{{column.name!r}: ...}}}}"
+    )

jigkit-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.5
+Name: jigkit
+Version: 0.1.0
+Summary: The shared foundations of small self-hosted web apps: settings, database, migrations, logging, health checks and test fixtures
+Project-URL: Homepage, https://github.com/jmerhar/jigkit
+Project-URL: Changelog, https://github.com/jmerhar/jigkit/blob/main/CHANGELOG.md
+Author: Jure Merhar
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Typing :: Typed
+Requires-Python: >=3.14
+Requires-Dist: pydantic-settings>=2.15
+Requires-Dist: pydantic>=2.13
+Requires-Dist: tzdata>=2026.5
+Provides-Extra: db
+Requires-Dist: aiosqlite>=0.22; extra == 'db'
+Requires-Dist: alembic>=1.19; extra == 'db'
+Requires-Dist: sqlalchemy[asyncio]>=2.0.52; extra == 'db'
+Provides-Extra: dev
+Requires-Dist: aiosqlite>=0.22; extra == 'dev'
+Requires-Dist: alembic>=1.19; extra == 'dev'
+Requires-Dist: build>=1.3; extra == 'dev'
+Requires-Dist: pytest-asyncio>=1.4; extra == 'dev'
+Requires-Dist: pytest-cov>=7.1; extra == 'dev'
+Requires-Dist: pytest>=9.1; extra == 'dev'
+Requires-Dist: ruff>=0.16; extra == 'dev'
+Requires-Dist: sqlalchemy[asyncio]>=2.0.52; extra == 'dev'
+Requires-Dist: twine>=6.2; extra == 'dev'
+Provides-Extra: postgres
+Requires-Dist: aiosqlite>=0.22; extra == 'postgres'
+Requires-Dist: alembic>=1.19; extra == 'postgres'
+Requires-Dist: asyncpg>=0.30; extra == 'postgres'
+Requires-Dist: sqlalchemy[asyncio]>=2.0.52; extra == 'postgres'
+Provides-Extra: testing
+Requires-Dist: pytest-asyncio>=1.4; extra == 'testing'
+Requires-Dist: pytest>=9.1; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# jigkit
+
+The shared foundations of small self-hosted web apps built on FastAPI, async SQLAlchemy and
+Svelte: settings, database, migrations, logging, health checks and test fixtures, each hardened
+once instead of copied between applications.
+
+```bash
+pip install "jigkit[db]"
+```
+
+| Module | Extra | What it gives an application |
+|---|---|---|
+| `jigkit.settings` | — | `AppSettings`: blank environment values mean unset, `X` or `X_FILE` for secrets (never both), a validated `TZ`, a data directory |
+| `jigkit.db` | `db` | an async engine with SQLite's pragmas (foreign keys, WAL, busy timeout), a session factory, a commit-or-roll-back `session_scope` |
+| `jigkit.models` | `db` | a declarative `Base` with deterministic constraint names, `UtcDateTime`, `TimestampMixin` |
+| `jigkit.migrations` | `db` | the whole of an Alembic `env.py`, with foreign keys off during SQLite table rebuilds and checked afterwards |
+| `jigkit.logging` | — | stream and rotating file handlers, a level that changes at runtime, credential-carrying HTTP client loggers kept quiet |
+| `jigkit.healthcheck` | — | `python -m jigkit.healthcheck URL --expect database=connected`, a container health probe |
+| `jigkit.secrets` | — | `load_or_create_secret`, a generated secret kept owner-only in the data directory |
+| `jigkit.testing` | `testing` | a pytest plugin (`data_dir`, `no_network`) and migration checks run through the application's own `env.py` |
+
+PostgreSQL is supported through the `postgres` extra. Python 3.14 or newer.
+
+See the [repository](https://github.com/jmerhar/jigkit) for the changelog and documentation.

jigkit-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+jigkit/__init__.py,sha256=ODsJ8SvjKmh4Sz8-C_NDgdwyGvdfCtblRCxwoMJgHZ8,272
+jigkit/db.py,sha256=gRnapV6OEewx8ldGkfziK7YRCFVn6Hgxy_jBnLRTtxo,3173
+jigkit/healthcheck.py,sha256=hAZ6UH0hQBnYdCWMJdFPYTH3Ii7GfruIGBLpl0e8pV8,3452
+jigkit/logging.py,sha256=hQ-sepb1wKG2e-7ETpdOfpnVxG-rFUSlpGDqZo2wNTc,3921
+jigkit/migrations.py,sha256=reXhJnbVxtapzu8zwVQbnq4hujwob6WiUycf9i_YsWs,4967
+jigkit/models.py,sha256=oTcgOJDs_-KFj6TG7qickBR0oCQ3M3Ededx86ERsnzI,2726
+jigkit/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jigkit/secrets.py,sha256=3k1tJ4GwtF80iXDhOODRk9_lNijnUvaMjcfFpXXrxZs,2368
+jigkit/settings.py,sha256=60OnhST0dSvw1cGqygRt8Ve-BqmP5Ha5OJl2aD-yAZg,6199
+jigkit/testing/__init__.py,sha256=aBOeSnKo3xxERX9lTp7n4l47LDXarj_kAYbmwXsfYbs,3233
+jigkit/testing/migrations.py,sha256=WDRkMBJy2LRIKnIL5P24IUXuB3QCenAqfw749q6wgCY,12464
+jigkit-0.1.0.dist-info/METADATA,sha256=rnicey7cgvBpSPJrxE4MZea1XW362A8dcPT3ueo2Hqs,3420
+jigkit-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+jigkit-0.1.0.dist-info/licenses/LICENSE,sha256=73LaOF6AdxjwgsK9X5n4lEFJj1jAEh4d_QJZtdOCRKY,1068
+jigkit-0.1.0.dist-info/RECORD,,

jigkit-0.1.0.dist-info/WHEEL

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

jigkit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jure Merhar
+
+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.