fronta 0.1.0__tar.gz

fronta-0.1.0/LICENSE

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

fronta-0.1.0/PKG-INFO

@@ -0,0 +1,226 @@
+Metadata-Version: 2.4
+Name: fronta
+Version: 0.1.0
+Summary: Distributed task queue for asyncio tasks and sandboxed processes
+Keywords: task queue,postgresql,asyncio,sandbox,bubblewrap,mcp,workers
+Author: Ondrej
+Author-email: Ondrej <ondrej@ilcik.com>
+License-Expression: MIT
+License-File: LICENSE
+License-File: THIRD_PARTY_NOTICES.md
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: AsyncIO
+Classifier: Framework :: FastAPI
+Classifier: Framework :: Pydantic :: 2
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Typing :: Typed
+Requires-Dist: click>=8.1.1,<9
+Requires-Dist: psycopg-pool>=3.2.8,<4
+Requires-Dist: psycopg[binary,pool]>=3.2.11,<4
+Requires-Dist: pydantic>=2.12,<3
+Requires-Dist: pydantic-settings>=2.5,<3
+Requires-Dist: fastapi>=0.110,<1 ; extra == 'server'
+Requires-Dist: jinja2>=3.1,<4 ; extra == 'server'
+Requires-Dist: jsonschema[format-nongpl]>=4.20,<5 ; extra == 'server'
+Requires-Dist: mcp>=2.1,<3 ; extra == 'server'
+Requires-Dist: uvicorn>=0.31.1,<1 ; extra == 'server'
+Requires-Python: >=3.12
+Project-URL: Homepage, https://github.com/dreo/fronta
+Project-URL: Repository, https://github.com/dreo/fronta
+Project-URL: Issues, https://github.com/dreo/fronta/issues
+Project-URL: Changelog, https://github.com/dreo/fronta/blob/main/CHANGELOG.md
+Provides-Extra: server
+Description-Content-Type: text/markdown
+
+# Fronta
+
+Task queue on PostgreSQL for Python. Workers run `async def` handlers in-process and executables
+in bubblewrap sandboxes; an optional server exposes the queue over REST and MCP with a small
+dashboard.
+
+Fronta keeps its tables in a `fronta` schema of your own PostgreSQL 16+ database; there is no
+broker. Workers claim rows with `SELECT … FOR UPDATE SKIP LOCKED`, hold leases renewed by
+heartbeats, and record every state change in one fenced transaction, so the tasks of a crashed or
+stalled worker are reaped and retried while attempts remain. Priorities, scheduled runs, dedupe
+keys, retries with jittered backoff and concurrency limits (per task type and per key) are enforced
+in the database; attempt timeouts and cancellation by the worker.
+
+**Status:** alpha. The API and the schema can change between minor versions before 1.0 (see
+`CHANGELOG.md`). Linux, Python 3.12–3.14, PostgreSQL 16+.
+
+## Install
+
+```bash
+uv add fronta               # SDK + worker
+uv add "fronta[server]"     # + REST/MCP server and dashboard
+```
+
+`pip install fronta` works the same. Hosts that run sandboxed processes need `bwrap` (bubblewrap),
+`prlimit` (util-linux) and unprivileged user namespaces; `import fronta` and the SDK work anywhere.
+
+## Example
+
+```python
+# app/tasks.py
+import fronta
+from pydantic import BaseModel
+
+
+class Resize(BaseModel):
+    image_id: int
+    width: int
+
+
+@fronta.task("resize", input=Resize, max_attempts=5, attempt_timeout=120)
+async def resize(ctx: fronta.Context, job: Resize) -> dict[str, int]:
+    await ctx.progress({"stage": "download"})
+    ...  # idempotent work that honors CancelledError
+    return {"bytes": 12345}
+
+
+worker = fronta.Worker([resize])
+```
+
+```bash
+export FRONTA_DSN=postgresql://user:pass@host/db   # the role must be able to create the schema
+fronta db init                    # creates schema `fronta`; safe to repeat
+fronta worker app.tasks:worker    # runs until SIGTERM/SIGINT
+```
+
+```python
+# enqueue.py: any process that reaches the database
+import asyncio
+
+import fronta
+from app.tasks import Resize, resize
+
+
+async def main() -> None:
+    await fronta.open_pool()  # once, at application start
+    try:
+        task_id = await resize.enqueue(Resize(image_id=7, width=800), priority=5, key="resize-7")
+        print(task_id)
+    finally:
+        await fronta.close_pool()  # at application shutdown
+
+
+asyncio.run(main())
+```
+
+`enqueue(..., conn=conn)` joins your own psycopg transaction instead of using the pool. `key`
+dedupes: while a task with the same key is queued or running, `enqueue` returns its id; once
+that task has finished, the same key enqueues a new one.
+
+A handler gets the validated input and a `Context` (`task_id`, `attempt`, `log`, `progress()`,
+`enqueue()`, `cancelled`, `state` from the worker lifespan). It must handle
+`asyncio.CancelledError` and be safe to run twice: after a lost lease the task runs again.
+
+A sandboxed process task, with a placeholder executable:
+
+```python
+class Convert(BaseModel):
+    source: str
+
+
+convert = fronta.process_task(
+    "convert",
+    ["/usr/bin/convert-tool", "--from-stdin"],  # reads the JSON input on stdin
+    input=Convert,
+    sandbox=fronta.Sandbox(memory_bytes=512 << 20, cpu_time_s=60, max_pids=16),
+    max_concurrency=4,
+)
+```
+
+The process runs in a private tmpfs `/work` without network; its result is
+`{"exit_code", "stdout", "stderr", "truncated"}`. Exit code 0 means the task succeeded; anything
+else fails the attempt.
+
+## Server
+
+```bash
+FRONTA_SERVER_TOKEN=... fronta server      # 127.0.0.1:8000
+```
+
+REST under `/api/v1` (task types, enqueue, get, list, cancel), MCP at `/mcp`, dashboard at `/`.
+The SDK only enqueues; inspection and cancellation go through the server. `FRONTA_SERVER_TOKEN`
+is required (the server never runs open: even on loopback a browser could be made to cancel or
+enqueue tasks); every REST and MCP request sends it as `Authorization: Bearer <token>`. Put a
+TLS-terminating reverse proxy in front of it outside a private network. Endpoints, inputs and error codes:
+[docs/reference.md](https://github.com/dreo/fronta/blob/main/docs/reference.md#server).
+
+## Deploy
+
+One database, any number of workers, optionally a server. Each process reads `FRONTA_*`
+environment variables; `FRONTA_DSN` is the only required one. Run workers under a supervisor that
+restarts them: a worker exits 0 after a graceful stop and 70 when a handler ignores cancellation or
+blocks the event loop.
+
+```ini
+# /etc/systemd/system/fronta-worker.service
+[Unit]
+Description=Fronta worker
+After=network-online.target
+
+[Service]
+User=app
+WorkingDirectory=/srv/app
+# FRONTA_DSN=... and other FRONTA_* variables; readable by root only (mode 0600)
+EnvironmentFile=/etc/fronta/worker.env
+ExecStart=/srv/app/.venv/bin/fronta worker app.tasks:worker
+# SIGTERM goes to the worker only, which stops its sandboxes itself; SIGKILL to everything
+KillMode=mixed
+Restart=always
+RestartSec=2
+TimeoutStopSec=120
+
+[Install]
+WantedBy=multi-user.target
+```
+
+`systemctl enable --now fronta-worker`. On `SIGTERM` the worker stops claiming, lets running
+attempts finish for `FRONTA_GRACE_S`, then stops the rest (another grace period for cooperative
+cancellation, then a kill) and records every outcome before it exits. That takes at most
+`2 × FRONTA_GRACE_S + 6 × FRONTA_KILL_TIMEOUT_S` (91 s with the defaults 30 s and 5 s) unless the
+database is unreachable or a sandbox cannot be killed: then the worker keeps trying rather than
+lose an outcome, and systemd's `SIGKILL` at `TimeoutStopSec` ends it. That loses no data:
+sandboxes die with the worker and unrecorded attempts are retried when their lease expires.
+
+Throughput is bounded by the database's commit rate (at least two durable commits per task, plus
+heartbeats and progress): about 150 no-op tasks/s in total on a laptop PostgreSQL with fsync; a
+claim costs ~5 ms on a 70k-row queue. Configuration, retry policy, guarantees and the
+measurements: [docs/reference.md](https://github.com/dreo/fronta/blob/main/docs/reference.md).
+
+## Not covered
+
+- Exactly-once side effects: a worker stalled past its lease may still be running while the task
+  is retried elsewhere; the stale attempt's writes to Fronta are rejected, its other effects are not.
+- Workflows, chains, or periodic tasks (only `run_at`).
+- Schema migrations before 1.0: a release that changes the schema needs `fronta db init` on a
+  fresh schema.
+- Windows or macOS workers: sandboxes are Linux-only and nothing else is tested there.
+
+## Development
+
+```bash
+uv sync --all-extras
+docker run -d --name fronta-test-pg -e POSTGRES_USER=fronta -e POSTGRES_PASSWORD=fronta \
+  -e POSTGRES_DB=fronta -p 127.0.0.1:5439:5432 postgres:16
+export FRONTA_TEST_DSN=postgresql://fronta:fronta@127.0.0.1:5439/fronta
+make check       # lint, format, types, architecture, deps (also the git pre-commit hook)
+make checkall    # check + the full test suite + pip-audit
+```
+
+CI runs `make checkall` on every pull request and push to `main`, on Python 3.12–3.14 and at the
+lowest dependency versions the declared bounds allow. To release: set the version (`uv version X.Y.Z`), add the CHANGELOG
+section, merge, then push the tag `vX.Y.Z` from that `main` commit; the gate runs again, the
+package goes to PyPI and a GitHub release is created. `SPEC.md` is the contract.
+
+## License
+
+MIT. The dashboard bundles Alpine.js (MIT); see `THIRD_PARTY_NOTICES.md`.

fronta-0.1.0/README.md

@@ -0,0 +1,186 @@
+# Fronta
+
+Task queue on PostgreSQL for Python. Workers run `async def` handlers in-process and executables
+in bubblewrap sandboxes; an optional server exposes the queue over REST and MCP with a small
+dashboard.
+
+Fronta keeps its tables in a `fronta` schema of your own PostgreSQL 16+ database; there is no
+broker. Workers claim rows with `SELECT … FOR UPDATE SKIP LOCKED`, hold leases renewed by
+heartbeats, and record every state change in one fenced transaction, so the tasks of a crashed or
+stalled worker are reaped and retried while attempts remain. Priorities, scheduled runs, dedupe
+keys, retries with jittered backoff and concurrency limits (per task type and per key) are enforced
+in the database; attempt timeouts and cancellation by the worker.
+
+**Status:** alpha. The API and the schema can change between minor versions before 1.0 (see
+`CHANGELOG.md`). Linux, Python 3.12–3.14, PostgreSQL 16+.
+
+## Install
+
+```bash
+uv add fronta               # SDK + worker
+uv add "fronta[server]"     # + REST/MCP server and dashboard
+```
+
+`pip install fronta` works the same. Hosts that run sandboxed processes need `bwrap` (bubblewrap),
+`prlimit` (util-linux) and unprivileged user namespaces; `import fronta` and the SDK work anywhere.
+
+## Example
+
+```python
+# app/tasks.py
+import fronta
+from pydantic import BaseModel
+
+
+class Resize(BaseModel):
+    image_id: int
+    width: int
+
+
+@fronta.task("resize", input=Resize, max_attempts=5, attempt_timeout=120)
+async def resize(ctx: fronta.Context, job: Resize) -> dict[str, int]:
+    await ctx.progress({"stage": "download"})
+    ...  # idempotent work that honors CancelledError
+    return {"bytes": 12345}
+
+
+worker = fronta.Worker([resize])
+```
+
+```bash
+export FRONTA_DSN=postgresql://user:pass@host/db   # the role must be able to create the schema
+fronta db init                    # creates schema `fronta`; safe to repeat
+fronta worker app.tasks:worker    # runs until SIGTERM/SIGINT
+```
+
+```python
+# enqueue.py: any process that reaches the database
+import asyncio
+
+import fronta
+from app.tasks import Resize, resize
+
+
+async def main() -> None:
+    await fronta.open_pool()  # once, at application start
+    try:
+        task_id = await resize.enqueue(Resize(image_id=7, width=800), priority=5, key="resize-7")
+        print(task_id)
+    finally:
+        await fronta.close_pool()  # at application shutdown
+
+
+asyncio.run(main())
+```
+
+`enqueue(..., conn=conn)` joins your own psycopg transaction instead of using the pool. `key`
+dedupes: while a task with the same key is queued or running, `enqueue` returns its id; once
+that task has finished, the same key enqueues a new one.
+
+A handler gets the validated input and a `Context` (`task_id`, `attempt`, `log`, `progress()`,
+`enqueue()`, `cancelled`, `state` from the worker lifespan). It must handle
+`asyncio.CancelledError` and be safe to run twice: after a lost lease the task runs again.
+
+A sandboxed process task, with a placeholder executable:
+
+```python
+class Convert(BaseModel):
+    source: str
+
+
+convert = fronta.process_task(
+    "convert",
+    ["/usr/bin/convert-tool", "--from-stdin"],  # reads the JSON input on stdin
+    input=Convert,
+    sandbox=fronta.Sandbox(memory_bytes=512 << 20, cpu_time_s=60, max_pids=16),
+    max_concurrency=4,
+)
+```
+
+The process runs in a private tmpfs `/work` without network; its result is
+`{"exit_code", "stdout", "stderr", "truncated"}`. Exit code 0 means the task succeeded; anything
+else fails the attempt.
+
+## Server
+
+```bash
+FRONTA_SERVER_TOKEN=... fronta server      # 127.0.0.1:8000
+```
+
+REST under `/api/v1` (task types, enqueue, get, list, cancel), MCP at `/mcp`, dashboard at `/`.
+The SDK only enqueues; inspection and cancellation go through the server. `FRONTA_SERVER_TOKEN`
+is required (the server never runs open: even on loopback a browser could be made to cancel or
+enqueue tasks); every REST and MCP request sends it as `Authorization: Bearer <token>`. Put a
+TLS-terminating reverse proxy in front of it outside a private network. Endpoints, inputs and error codes:
+[docs/reference.md](https://github.com/dreo/fronta/blob/main/docs/reference.md#server).
+
+## Deploy
+
+One database, any number of workers, optionally a server. Each process reads `FRONTA_*`
+environment variables; `FRONTA_DSN` is the only required one. Run workers under a supervisor that
+restarts them: a worker exits 0 after a graceful stop and 70 when a handler ignores cancellation or
+blocks the event loop.
+
+```ini
+# /etc/systemd/system/fronta-worker.service
+[Unit]
+Description=Fronta worker
+After=network-online.target
+
+[Service]
+User=app
+WorkingDirectory=/srv/app
+# FRONTA_DSN=... and other FRONTA_* variables; readable by root only (mode 0600)
+EnvironmentFile=/etc/fronta/worker.env
+ExecStart=/srv/app/.venv/bin/fronta worker app.tasks:worker
+# SIGTERM goes to the worker only, which stops its sandboxes itself; SIGKILL to everything
+KillMode=mixed
+Restart=always
+RestartSec=2
+TimeoutStopSec=120
+
+[Install]
+WantedBy=multi-user.target
+```
+
+`systemctl enable --now fronta-worker`. On `SIGTERM` the worker stops claiming, lets running
+attempts finish for `FRONTA_GRACE_S`, then stops the rest (another grace period for cooperative
+cancellation, then a kill) and records every outcome before it exits. That takes at most
+`2 × FRONTA_GRACE_S + 6 × FRONTA_KILL_TIMEOUT_S` (91 s with the defaults 30 s and 5 s) unless the
+database is unreachable or a sandbox cannot be killed: then the worker keeps trying rather than
+lose an outcome, and systemd's `SIGKILL` at `TimeoutStopSec` ends it. That loses no data:
+sandboxes die with the worker and unrecorded attempts are retried when their lease expires.
+
+Throughput is bounded by the database's commit rate (at least two durable commits per task, plus
+heartbeats and progress): about 150 no-op tasks/s in total on a laptop PostgreSQL with fsync; a
+claim costs ~5 ms on a 70k-row queue. Configuration, retry policy, guarantees and the
+measurements: [docs/reference.md](https://github.com/dreo/fronta/blob/main/docs/reference.md).
+
+## Not covered
+
+- Exactly-once side effects: a worker stalled past its lease may still be running while the task
+  is retried elsewhere; the stale attempt's writes to Fronta are rejected, its other effects are not.
+- Workflows, chains, or periodic tasks (only `run_at`).
+- Schema migrations before 1.0: a release that changes the schema needs `fronta db init` on a
+  fresh schema.
+- Windows or macOS workers: sandboxes are Linux-only and nothing else is tested there.
+
+## Development
+
+```bash
+uv sync --all-extras
+docker run -d --name fronta-test-pg -e POSTGRES_USER=fronta -e POSTGRES_PASSWORD=fronta \
+  -e POSTGRES_DB=fronta -p 127.0.0.1:5439:5432 postgres:16
+export FRONTA_TEST_DSN=postgresql://fronta:fronta@127.0.0.1:5439/fronta
+make check       # lint, format, types, architecture, deps (also the git pre-commit hook)
+make checkall    # check + the full test suite + pip-audit
+```
+
+CI runs `make checkall` on every pull request and push to `main`, on Python 3.12–3.14 and at the
+lowest dependency versions the declared bounds allow. To release: set the version (`uv version X.Y.Z`), add the CHANGELOG
+section, merge, then push the tag `vX.Y.Z` from that `main` commit; the gate runs again, the
+package goes to PyPI and a GitHub release is created. `SPEC.md` is the contract.
+
+## License
+
+MIT. The dashboard bundles Alpine.js (MIT); see `THIRD_PARTY_NOTICES.md`.

fronta-0.1.0/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,30 @@
+# Third-party notices
+
+## Alpine.js 3.14.9 (vendored as `fronta/server/static/alpine.min.js`)
+
+Source: https://cdn.jsdelivr.net/npm/alpinejs@3.14.9/dist/cdn.min.js
+(https://github.com/alpinejs/alpine), SHA-256 `3ed1eed252488921df65e363d6715deb04d7f92aaedb9e52199fdf73cb1e0ad3`.
+To update: download the new `dist/cdn.min.js`, replace the file, update the version and the
+checksum here, and run the dashboard test (`tests/test_dashboard.py`).
+
+MIT License
+
+Copyright © 2019-2025 Caleb Porzio and contributors
+
+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.

fronta-0.1.0/pyproject.toml

@@ -0,0 +1,123 @@
+[project]
+name = "fronta"
+version = "0.1.0"
+description = "Distributed task queue for asyncio tasks and sandboxed processes"
+readme = "README.md"
+authors = [
+    { name = "Ondrej", email = "ondrej@ilcik.com" }
+]
+license = "MIT"
+license-files = ["LICENSE", "THIRD_PARTY_NOTICES.md"]
+requires-python = ">=3.12"
+keywords = ["task queue", "postgresql", "asyncio", "sandbox", "bubblewrap", "mcp", "workers"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Framework :: AsyncIO",
+    "Framework :: FastAPI",
+    "Framework :: Pydantic :: 2",
+    "Intended Audience :: Developers",
+    "Operating System :: POSIX :: Linux",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: System :: Distributed Computing",
+    "Typing :: Typed",
+]
+dependencies = [
+    # Every floor is tested: CI runs the suite at `--resolution lowest-direct` with all extras and
+    # these are the versions it installs. Ceilings exclude the next major of contracts we depend
+    # on. `psycopg[binary]` gives an out-of-the-box install; an application that ships
+    # `psycopg[c]` keeps it (psycopg prefers the C implementation).
+    "click>=8.1.1,<9",                   # 8.1.0's decorators are untyped for mypy
+    "psycopg-pool>=3.2.8,<4",             # 3.2.8: CancelledError inside connection() no longer swallowed
+    "psycopg[binary,pool]>=3.2.11,<4",  # 3.2.4 keeps notifies across notifies() restarts; 3.2.10/11 cancel + wait fixes
+    "pydantic>=2.12,<3",                 # mcp 2.1 needs 2.12; the lowest version CI tests
+    "pydantic-settings>=2.5,<3",
+]
+
+[project.urls]
+Homepage = "https://github.com/dreo/fronta"
+Repository = "https://github.com/dreo/fronta"
+Issues = "https://github.com/dreo/fronta/issues"
+Changelog = "https://github.com/dreo/fronta/blob/main/CHANGELOG.md"
+
+[project.optional-dependencies]
+# `fronta server` (REST + MCP + dashboard); workers and the SDK do not need it.
+server = [
+    "fastapi>=0.110,<1",                 # lifespan= and Annotated dependencies
+    "jinja2>=3.1,<4",
+    "jsonschema[format-nongpl]>=4.20,<5",  # Draft 2020-12 + FORMAT_CHECKER
+    "mcp>=2.1,<3",                       # MCPServer + streamable_http_app(host=, max_request_body_size=)
+    "uvicorn>=0.31.1,<1",                  # timeout_graceful_shutdown=
+]
+
+[project.scripts]
+fronta = "fronta.cli:main"
+
+[build-system]
+requires = ["uv_build>=0.11.18,<0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "deptry>=0.25.1",
+    "httpx>=0.28.1",
+    "import-linter>=2.14",
+    "mypy>=2.3.1",
+    "pip-audit>=2.10.1",
+    "playwright>=1.62.0",
+    "pre-commit>=4.6.2",
+    "pytest>=9.1.1",
+    "pytest-asyncio>=1.4.0",
+    "ruff>=0.16.5",
+    "types-jsonschema>=4.26.0.20260518",
+]
+
+[tool.ruff]
+target-version = "py312"
+line-length = 100
+
+[tool.ruff.lint]
+select = [
+    "E", "W", "F", "I", "S", "B", "C4", "UP", "D", "PT",
+    "RUF", "ANN", "SIM", "TC", "ARG", "ERA", "PL", "PTH", "DTZ", "T20",
+]
+ignore = ["D1"]
+
+[tool.ruff.lint.pydocstyle]
+convention = "google"
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["S101", "D", "ANN", "PLR2004"]
+
+[tool.mypy]
+strict = true
+packages = ["fronta"]
+mypy_path = "src"
+
+[tool.importlinter]
+root_package = "fronta"
+
+[[tool.importlinter.contracts]]
+name = "Layers: cli > server | worker > executors > sandbox | definitions > runtime > store > codec > model | config | errors"
+type = "layers"
+layers = [
+    "fronta.cli",
+    "fronta.server | fronta.worker",
+    "fronta.executors",
+    "fronta.sandbox | fronta.definitions",
+    "fronta.runtime",
+    "fronta.store",
+    "fronta.codec",
+    "fronta.model | fronta.config | fronta.errors",
+]
+
+[tool.deptry]
+# Add per-rule ignores only with a justifying comment.
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+asyncio_default_test_loop_scope = "function"
+testpaths = ["tests"]

fronta-0.1.0/src/fronta/__init__.py

@@ -0,0 +1,58 @@
+"""Fronta: distributed task processing on PostgreSQL with sandboxed process execution."""
+
+from importlib.metadata import version
+
+from fronta.config import Settings
+from fronta.definitions import Context, ProcessTaskDefinition, TaskDefinition, process_task, task
+from fronta.errors import (
+    ConfigurationError,
+    FrontaError,
+    InputValidationError,
+    InvalidInput,
+    NonRetryableError,
+    NotCancellable,
+    PayloadTooLarge,
+    ProgressTooLarge,
+    ResultSerializationError,
+    SandboxError,
+    TaskNotFound,
+    UnknownTaskType,
+)
+from fronta.model import Backoff, Policy, Sandbox, State, TaskRow, TaskSummary, TaskTypeRow
+from fronta.runtime import close_pool, configure, open_pool
+from fronta.worker import Worker
+
+__version__: str = version("fronta")
+
+__all__ = [
+    "Backoff",
+    "ConfigurationError",
+    "Context",
+    "FrontaError",
+    "InputValidationError",
+    "InvalidInput",
+    "NonRetryableError",
+    "NotCancellable",
+    "PayloadTooLarge",
+    "Policy",
+    "ProcessTaskDefinition",
+    "ProgressTooLarge",
+    "ResultSerializationError",
+    "Sandbox",
+    "SandboxError",
+    "Settings",
+    "State",
+    "TaskDefinition",
+    "TaskNotFound",
+    "TaskRow",
+    "TaskSummary",
+    "TaskTypeRow",
+    "UnknownTaskType",
+    "Worker",
+    "__version__",
+    "close_pool",
+    "configure",
+    "open_pool",
+    "process_task",
+    "task",
+]