pgtask 0.1.3__tar.gz → 0.2.0__tar.gz

{pgtask-0.1.3 → pgtask-0.2.0}/Cargo.lock

@@ -1162,18 +1162,20 @@ checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "pgtask"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "pgtask-core",
  "pgtask-otel",
  "pgtask-postgres",
  "pgtask-worker",
  "serde_json",
+ "tokio",
+ "tokio-util",
 ]
 
 [[package]]
 name = "pgtask-bench"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "pgtask",
@@ -1186,7 +1188,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-cli"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "clap",
  "pgtask",
@@ -1196,7 +1198,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-core"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "cron",
@@ -1209,7 +1211,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-otel"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "opentelemetry",
  "opentelemetry_sdk",
@@ -1220,7 +1222,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-postgres"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "pgtask-core",
@@ -1235,7 +1237,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-python"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "chrono",
  "pgtask",
@@ -1252,7 +1254,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-web"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "axum",
  "chrono",
@@ -1271,7 +1273,7 @@ dependencies = [
 
 [[package]]
 name = "pgtask-worker"
-version = "0.1.3"
+version = "0.2.0"
 dependencies = [
  "axum",
  "chrono",

{pgtask-0.1.3 → pgtask-0.2.0}/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 license = "MIT"
 repository = "https://github.com/Kludex/pgtask"
 rust-version = "1.94"
-version = "0.1.3"
+version = "0.2.0"
 
 [workspace.dependencies]
 axum = "0.8.9"

pgtask-0.2.0/PKG-INFO

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: pgtask
+Version: 0.2.0
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Rust
+Requires-Dist: opentelemetry-api>=1.30
+Requires-Dist: psycopg>=3.2
+Summary: PostgreSQL-native durable tasks and workflows
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# pgtask
+
+Durable tasks and workflows that live entirely in PostgreSQL.
+
+There is no broker, no coordinator, and no extension to install. If your database is up, your queue is up.
+
+> [!WARNING]
+> `pgtask` is under active development. It is not ready for production use.
+
+## Installation
+
+```console
+pip install pgtask
+```
+
+## Define a task and run a worker
+
+A registry maps a task name to the function that runs it. A worker claims work for that queue, one lease
+at a time, so a worker that dies hands its tasks back instead of taking them with it.
+
+```python
+from __future__ import annotations
+
+import asyncio
+import os
+
+from pgtask import Client, Task, TaskRegistry, Worker
+
+tasks = TaskRegistry(queue_name="reports")
+
+
+@tasks.task("reports.render")
+async def render(task: Task, payload: dict) -> dict:
+    return {"report_id": payload["report_id"], "attempt": task.attempt}
+
+
+async def main() -> None:
+    database_url = os.environ["PGTASK_DATABASE_URL"]
+    client = await Client.connect(database_url)
+    await client.migrate()
+    await Worker(database_url, tasks).run()
+
+
+asyncio.run(main())
+```
+
+Delivery is at least once, so write handlers that are safe to run again.
+
+## Enqueue a task
+
+```python
+from __future__ import annotations
+
+import asyncio
+import os
+
+from pgtask import Client, EnqueueRequest
+
+
+async def main() -> None:
+    client = await Client.connect(os.environ["PGTASK_DATABASE_URL"])
+    handle = await client.enqueue(
+        EnqueueRequest("reports.render", {"report_id": "report-123"}, queue_name="reports")
+    )
+    print(await handle.result(timeout=30.0))
+
+
+asyncio.run(main())
+```
+
+## Enqueue inside your transaction
+
+This is the reason to keep the queue in the database. Pass your own connection and the task commits with
+your data or not at all. Roll back and the task never existed, which is what an outbox table is usually
+for.
+
+```python
+async with connection.transaction():
+    await connection.execute("INSERT INTO reports (id) VALUES (%s)", ("report-123",))
+    await Client.enqueue_on(connection, request)
+```
+
+`connection` is your `psycopg` connection, not one of ours.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/) covers workers, durable execution, signals,
+cancellation, scheduling, and OpenTelemetry propagation.
+

pgtask-0.2.0/README.md

@@ -0,0 +1,88 @@
+# pgtask
+
+Durable tasks and workflows that live entirely in PostgreSQL.
+
+There is no broker, no coordinator, and no extension to install. If your database is up, your queue is up.
+
+> [!WARNING]
+> `pgtask` is under active development. It is not ready for production use.
+
+## Installation
+
+```console
+pip install pgtask
+```
+
+## Define a task and run a worker
+
+A registry maps a task name to the function that runs it. A worker claims work for that queue, one lease
+at a time, so a worker that dies hands its tasks back instead of taking them with it.
+
+```python
+from __future__ import annotations
+
+import asyncio
+import os
+
+from pgtask import Client, Task, TaskRegistry, Worker
+
+tasks = TaskRegistry(queue_name="reports")
+
+
+@tasks.task("reports.render")
+async def render(task: Task, payload: dict) -> dict:
+    return {"report_id": payload["report_id"], "attempt": task.attempt}
+
+
+async def main() -> None:
+    database_url = os.environ["PGTASK_DATABASE_URL"]
+    client = await Client.connect(database_url)
+    await client.migrate()
+    await Worker(database_url, tasks).run()
+
+
+asyncio.run(main())
+```
+
+Delivery is at least once, so write handlers that are safe to run again.
+
+## Enqueue a task
+
+```python
+from __future__ import annotations
+
+import asyncio
+import os
+
+from pgtask import Client, EnqueueRequest
+
+
+async def main() -> None:
+    client = await Client.connect(os.environ["PGTASK_DATABASE_URL"])
+    handle = await client.enqueue(
+        EnqueueRequest("reports.render", {"report_id": "report-123"}, queue_name="reports")
+    )
+    print(await handle.result(timeout=30.0))
+
+
+asyncio.run(main())
+```
+
+## Enqueue inside your transaction
+
+This is the reason to keep the queue in the database. Pass your own connection and the task commits with
+your data or not at all. Roll back and the task never existed, which is what an outbox table is usually
+for.
+
+```python
+async with connection.transaction():
+    await connection.execute("INSERT INTO reports (id) VALUES (%s)", ("report-123",))
+    await Client.enqueue_on(connection, request)
+```
+
+`connection` is your `psycopg` connection, not one of ours.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/) covers workers, durable execution, signals,
+cancellation, scheduling, and OpenTelemetry propagation.

pgtask-0.2.0/crates/pgtask/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "pgtask"
+description = "PostgreSQL-native durable tasks and workflows"
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+readme = "README.md"
+
+[dependencies]
+pgtask-core = { path = "../pgtask-core", version = "0.2.0" }
+pgtask-otel = { path = "../pgtask-otel", version = "0.2.0" }
+pgtask-postgres = { path = "../pgtask-postgres", version = "0.2.0" }
+pgtask-worker = { path = "../pgtask-worker", version = "0.2.0" }
+
+[dev-dependencies]
+serde_json.workspace = true
+tokio.workspace = true
+tokio-util.workspace = true
+
+[lints]
+workspace = true

pgtask-0.2.0/crates/pgtask/README.md

@@ -0,0 +1,100 @@
+# pgtask
+
+Durable tasks and workflows that live entirely in PostgreSQL.
+
+There is no broker, no coordinator, and no extension to install. If your database is up, your queue is up.
+
+> [!WARNING]
+> `pgtask` is under active development. It is not ready for production use.
+
+## Installation
+
+```console
+cargo add pgtask tokio tokio-util serde_json
+```
+
+## Run a worker
+
+A worker declares which tasks it can handle and claims work from a queue. Every claim takes a lease, so
+when a worker dies its tasks return to the queue instead of disappearing with it.
+
+```rust,no_run
+use std::error::Error;
+
+use pgtask::{
+    core::{HandlerVersion, QueueName, RetryPolicy, TaskName},
+    postgres::Store,
+    worker::{HandlerRegistry, Worker, WorkerConfig},
+};
+use serde_json::json;
+use tokio_util::sync::CancellationToken;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let store = Store::connect(&std::env::var("PGTASK_DATABASE_URL")?).await?;
+    store.migrate().await?;
+
+    let mut registry = HandlerRegistry::new();
+    registry.register(
+        TaskName::new("reports.render")?,
+        HandlerVersion::default(),
+        RetryPolicy::Never,
+        |task| async move { Ok(json!({ "attempt": task.attempt })) },
+    );
+
+    let config = WorkerConfig::new(QueueName::new("reports")?);
+    Worker::new(store, registry, config)?.run(CancellationToken::new()).await?;
+    Ok(())
+}
+```
+
+Cancel the token to shut down. The worker stops claiming, finishes what it is already running, and lets
+the rest expire back to the queue.
+
+## Enqueue inside your transaction
+
+This is the reason to keep the queue in the database. You pass your own transaction, so the task commits
+with your data or not at all. Roll back and the task never existed.
+
+```rust,no_run
+use std::error::Error;
+
+use pgtask::{
+    core::{EnqueueRequest, QueueName, TaskName},
+    postgres::Store,
+};
+use serde_json::json;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+    let store = Store::connect(&std::env::var("PGTASK_DATABASE_URL")?).await?;
+
+    let mut request = EnqueueRequest::new(TaskName::new("reports.render")?, json!({"report_id": "report-123"}));
+    request.queue_name = QueueName::new("reports")?;
+
+    let mut transaction = store.pool().begin().await?;
+    // Your own writes belong here, in the same transaction.
+    let result = Store::enqueue_on(&mut transaction, &request).await?;
+    transaction.commit().await?;
+
+    println!("enqueued {}", result.task_id);
+    Ok(())
+}
+```
+
+Without a transaction of your own, `store.enqueue(&request)` does the same on its own connection.
+
+## Crates
+
+This crate re-exports the others. Depend on it unless you need one layer on its own.
+
+| Crate | What it holds |
+| --- | --- |
+| `pgtask-core` | Task, queue, schedule, and retry types shared by every layer |
+| `pgtask-postgres` | The storage protocol: migrate, enqueue, claim, complete |
+| `pgtask-worker` | The worker runtime, scheduler, and retention loop |
+| `pgtask-otel` | OpenTelemetry spans, metrics, and trace propagation |
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/)

{pgtask-0.1.3 → pgtask-0.2.0}/crates/pgtask/src/lib.rs

@@ -1,4 +1,4 @@
-#![doc = "PostgreSQL-native durable tasks and workflows."]
+#![doc = include_str!("../README.md")]
 
 pub use pgtask_core as core;
 pub use pgtask_otel as otel;

{pgtask-0.1.3 → pgtask-0.2.0}/crates/pgtask-core/Cargo.toml

@@ -6,6 +6,7 @@ license.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
+readme = "README.md"
 
 [dependencies]
 chrono.workspace = true

pgtask-0.2.0/crates/pgtask-core/README.md

@@ -0,0 +1,13 @@
+# pgtask-core
+
+The types every layer of `pgtask` agrees on: tasks, queues, schedules, retry policies, and the states a
+task can be in.
+
+There is no database access and no runtime here. The crate exists so the storage layer, the worker, and
+the telemetry layer share one definition of a task instead of three that drift apart.
+
+You probably want [`pgtask`](https://crates.io/crates/pgtask), which re-exports this as `pgtask::core`.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/)

{pgtask-0.1.3 → pgtask-0.2.0}/crates/pgtask-otel/Cargo.toml

@@ -6,6 +6,7 @@ license.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
+readme = "README.md"
 
 [dependencies]
 opentelemetry.workspace = true

pgtask-0.2.0/crates/pgtask-otel/README.md

@@ -0,0 +1,13 @@
+# pgtask-otel
+
+OpenTelemetry for `pgtask`: span names and attributes, queue and worker metrics, and trace context carried
+inside task headers.
+
+Because the context travels with the task, a worker span is a child of the request that enqueued it, even
+though the two ran in different processes minutes apart. Without that, a queue is where your traces end.
+
+You probably want [`pgtask`](https://crates.io/crates/pgtask), which re-exports this as `pgtask::otel`.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/)

{pgtask-0.1.3 → pgtask-0.2.0}/crates/pgtask-postgres/Cargo.toml

@@ -6,11 +6,12 @@ license.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
+readme = "README.md"
 
 [dependencies]
 chrono.workspace = true
-pgtask-core = { path = "../pgtask-core", version = "0.1.3" }
-pgtask-otel = { path = "../pgtask-otel", version = "0.1.3" }
+pgtask-core = { path = "../pgtask-core", version = "0.2.0" }
+pgtask-otel = { path = "../pgtask-otel", version = "0.2.0" }
 serde_json.workspace = true
 sqlx.workspace = true
 thiserror.workspace = true

pgtask-0.2.0/crates/pgtask-postgres/README.md

@@ -0,0 +1,15 @@
+# pgtask-postgres
+
+The PostgreSQL storage layer for `pgtask`: migrations, enqueue, claim, complete, schedules, and the views
+you read from.
+
+Every operation is a call to a versioned SQL function, so the database is the contract rather than this
+crate. Clients in other languages call the same functions, and both the schema and each client declare a
+storage protocol range that has to overlap before a worker will start.
+
+Depend on it directly when you produce tasks but never run a worker. Otherwise take
+[`pgtask`](https://crates.io/crates/pgtask), which re-exports this as `pgtask::postgres`.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/)

{pgtask-0.1.3 → pgtask-0.2.0}/crates/pgtask-worker/Cargo.toml

@@ -6,14 +6,15 @@ license.workspace = true
 repository.workspace = true
 rust-version.workspace = true
 version.workspace = true
+readme = "README.md"
 
 [dependencies]
 axum.workspace = true
 chrono.workspace = true
 futures.workspace = true
-pgtask-core = { path = "../pgtask-core", version = "0.1.3" }
-pgtask-otel = { path = "../pgtask-otel", version = "0.1.3" }
-pgtask-postgres = { path = "../pgtask-postgres", version = "0.1.3" }
+pgtask-core = { path = "../pgtask-core", version = "0.2.0" }
+pgtask-otel = { path = "../pgtask-otel", version = "0.2.0" }
+pgtask-postgres = { path = "../pgtask-postgres", version = "0.2.0" }
 serde_json.workspace = true
 thiserror.workspace = true
 tokio.workspace = true

pgtask-0.2.0/crates/pgtask-worker/README.md

@@ -0,0 +1,13 @@
+# pgtask-worker
+
+The runtime that claims tasks, runs your handlers, and keeps their leases alive.
+
+It also brings the parts you would otherwise write yourself: retries with backoff, durable execution with
+checkpoints, a scheduler that needs no leader, retention, graceful shutdown, and a health endpoint.
+
+You probably want [`pgtask`](https://crates.io/crates/pgtask), which re-exports this as `pgtask::worker`
+and shows a complete worker in a few lines.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/)

{pgtask-0.1.3 → pgtask-0.2.0}/python/pgtask/__init__.py

@@ -13,6 +13,7 @@ from pgtask.client import (
     TaskState,
     TransactionConnection,
     Worker,
+    get_current_task,
 )
 
 __all__ = [
@@ -28,4 +29,5 @@ __all__ = [
     "TaskState",
     "TransactionConnection",
     "Worker",
+    "get_current_task",
 ]

{pgtask-0.1.3 → pgtask-0.2.0}/python/pgtask/client.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Awaitable, Callable, Sequence
+from contextvars import ContextVar
 from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, Generic, TypeVar, cast
@@ -211,6 +212,18 @@ class Task:
         return cast(JSONValue, await self._context.wait_for_result(step_name, occurrence, task_id, timeout))
 
 
+_current_task: ContextVar[Task | None] = ContextVar("pgtask_current_task", default=None)
+
+
+def get_current_task() -> Task | None:
+    """The task running in this call chain, or `None` outside a handler.
+
+    Reach for this when a frame between your handler and the code that needs the task cannot pass it
+    down, which is the usual shape when a framework calls you back.
+    """
+    return _current_task.get()
+
+
 @dataclass(frozen=True)
 class TaskHandle(Generic[ResultT]):
     id: str
@@ -348,9 +361,11 @@ class Worker:
             ) -> JSONValue:
                 task = Task.from_native(value, context)
                 token = attach(extract(cast(dict[str, str], task.headers)))
+                current = _current_task.set(task)
                 try:
                     return cast(JSONValue, await registered.handler(task, task.payload))
                 finally:
+                    _current_task.reset(current)
                     detach(token)
 
             self._native.register(

{pgtask-0.1.3 → pgtask-0.2.0}/sdks/python/Cargo.toml

@@ -14,7 +14,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 chrono.workspace = true
-pgtask = { path = "../../crates/pgtask", version = "0.1.3" }
+pgtask = { path = "../../crates/pgtask", version = "0.2.0" }
 pyo3.workspace = true
 pyo3-async-runtimes = { workspace = true, features = ["tokio-runtime"] }
 pythonize.workspace = true

pgtask-0.2.0/sdks/python/README.md

@@ -0,0 +1,88 @@
+# pgtask
+
+Durable tasks and workflows that live entirely in PostgreSQL.
+
+There is no broker, no coordinator, and no extension to install. If your database is up, your queue is up.
+
+> [!WARNING]
+> `pgtask` is under active development. It is not ready for production use.
+
+## Installation
+
+```console
+pip install pgtask
+```
+
+## Define a task and run a worker
+
+A registry maps a task name to the function that runs it. A worker claims work for that queue, one lease
+at a time, so a worker that dies hands its tasks back instead of taking them with it.
+
+```python
+from __future__ import annotations
+
+import asyncio
+import os
+
+from pgtask import Client, Task, TaskRegistry, Worker
+
+tasks = TaskRegistry(queue_name="reports")
+
+
+@tasks.task("reports.render")
+async def render(task: Task, payload: dict) -> dict:
+    return {"report_id": payload["report_id"], "attempt": task.attempt}
+
+
+async def main() -> None:
+    database_url = os.environ["PGTASK_DATABASE_URL"]
+    client = await Client.connect(database_url)
+    await client.migrate()
+    await Worker(database_url, tasks).run()
+
+
+asyncio.run(main())
+```
+
+Delivery is at least once, so write handlers that are safe to run again.
+
+## Enqueue a task
+
+```python
+from __future__ import annotations
+
+import asyncio
+import os
+
+from pgtask import Client, EnqueueRequest
+
+
+async def main() -> None:
+    client = await Client.connect(os.environ["PGTASK_DATABASE_URL"])
+    handle = await client.enqueue(
+        EnqueueRequest("reports.render", {"report_id": "report-123"}, queue_name="reports")
+    )
+    print(await handle.result(timeout=30.0))
+
+
+asyncio.run(main())
+```
+
+## Enqueue inside your transaction
+
+This is the reason to keep the queue in the database. Pass your own connection and the task commits with
+your data or not at all. Roll back and the task never existed, which is what an outbox table is usually
+for.
+
+```python
+async with connection.transaction():
+    await connection.execute("INSERT INTO reports (id) VALUES (%s)", ("report-123",))
+    await Client.enqueue_on(connection, request)
+```
+
+`connection` is your `psycopg` connection, not one of ours.
+
+## Documentation
+
+[kludex.github.io/pgtask](https://kludex.github.io/pgtask/) covers workers, durable execution, signals,
+cancellation, scheduling, and OpenTelemetry propagation.

{pgtask-0.1.3 → pgtask-0.2.0}/sdks/python/tests/test_python_sdk.py

@@ -40,6 +40,7 @@ def test_public_python_contract() -> None:
         "TaskState",
         "TransactionConnection",
         "Worker",
+        "get_current_task",
     ]
     assert tuple(inspect.signature(TaskRegistry.task).parameters) == (
         "self",
@@ -405,3 +406,42 @@ async def test_python_handler_uses_durable_workflow_operations() -> None:
     assert step_calls == 1
     worker.shutdown()
     await running
+
+
+@pytest.mark.anyio
+async def test_ambient_task_is_reachable_from_any_frame_below_the_handler() -> None:
+    database_url = os.environ["PGTASK_DATABASE_URL"]
+    client = await Client.connect(database_url)
+    await client.migrate()
+    queue_name = f"python-{os.urandom(8).hex()}"
+    registry = TaskRegistry(queue_name)
+    started = asyncio.Event()
+    observed: dict[str, tuple[str, str]] = {}
+
+    async def deep_frame() -> str:
+        ambient = pgtask.get_current_task()
+        assert ambient is not None
+        return ambient.id
+
+    @registry.task("python.ambient")
+    async def ambient(task: Task, payload: dict[str, JSONValue]) -> JSONValue:
+        if payload["wait"]:
+            started.set()
+            await asyncio.sleep(0.2)
+        observed[task.id] = (await deep_frame(), await task.step("inside-step", deep_frame))
+        return {"id": task.id}
+
+    assert pgtask.get_current_task() is None
+    worker = Worker(database_url, registry, concurrency=2, poll_interval=30.0)
+    slow = await client.enqueue(ambient.request({"wait": True}))
+    running = asyncio.create_task(worker.run())
+    await asyncio.wait_for(started.wait(), timeout=5)
+    fast = await client.enqueue(ambient.request({"wait": False}))
+    for handle in (fast, slow):
+        result = await handle.result(timeout=10)
+        assert result is not None
+        assert result.state == "succeeded"
+    assert observed == {fast.id: (fast.id, fast.id), slow.id: (slow.id, slow.id)}
+    assert pgtask.get_current_task() is None
+    worker.shutdown()
+    await running

pgtask-0.1.3/PKG-INFO

@@ -1,42 +0,0 @@
-Metadata-Version: 2.4
-Name: pgtask
-Version: 0.1.3
-Classifier: Development Status :: 2 - Pre-Alpha
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Rust
-Requires-Dist: opentelemetry-api>=1.30
-Requires-Dist: psycopg>=3.2
-Summary: PostgreSQL-native durable tasks and workflows
-License-Expression: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
-
-# `pgtask`
-
-```python
-from __future__ import annotations
-
-import asyncio
-import os
-
-from pgtask import Client, EnqueueRequest
-
-
-async def main() -> None:
-    client = await Client.connect(os.environ["PGTASK_DATABASE_URL"])
-    task = await client.enqueue(EnqueueRequest("reports.render", {"report_id": "report-123"}))
-    print(await task.result(timeout=30.0))
-
-
-asyncio.run(main())
-```
-
-This package provides the Python producer client and worker runtime for `pgtask`. See the
-[Python SDK documentation](https://github.com/Kludex/pgtask/blob/main/docs/sdk/python.md) for workers, transactions,
-durable execution, signals, cancellation, and OpenTelemetry propagation.
-

pgtask-0.1.3/README.md

@@ -1,23 +0,0 @@
-# `pgtask`
-
-```python
-from __future__ import annotations
-
-import asyncio
-import os
-
-from pgtask import Client, EnqueueRequest
-
-
-async def main() -> None:
-    client = await Client.connect(os.environ["PGTASK_DATABASE_URL"])
-    task = await client.enqueue(EnqueueRequest("reports.render", {"report_id": "report-123"}))
-    print(await task.result(timeout=30.0))
-
-
-asyncio.run(main())
-```
-
-This package provides the Python producer client and worker runtime for `pgtask`. See the
-[Python SDK documentation](https://github.com/Kludex/pgtask/blob/main/docs/sdk/python.md) for workers, transactions,
-durable execution, signals, cancellation, and OpenTelemetry propagation.

pgtask-0.1.3/crates/pgtask/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "pgtask"
-description = "PostgreSQL-native durable tasks and workflows"
-edition.workspace = true
-license.workspace = true
-repository.workspace = true
-rust-version.workspace = true
-version.workspace = true
-
-[dependencies]
-pgtask-core = { path = "../pgtask-core", version = "0.1.3" }
-pgtask-otel = { path = "../pgtask-otel", version = "0.1.3" }
-pgtask-postgres = { path = "../pgtask-postgres", version = "0.1.3" }
-pgtask-worker = { path = "../pgtask-worker", version = "0.1.3" }
-
-[dev-dependencies]
-serde_json.workspace = true
-
-[lints]
-workspace = true

pgtask-0.1.3/sdks/python/README.md

@@ -1,23 +0,0 @@
-# `pgtask`
-
-```python
-from __future__ import annotations
-
-import asyncio
-import os
-
-from pgtask import Client, EnqueueRequest
-
-
-async def main() -> None:
-    client = await Client.connect(os.environ["PGTASK_DATABASE_URL"])
-    task = await client.enqueue(EnqueueRequest("reports.render", {"report_id": "report-123"}))
-    print(await task.result(timeout=30.0))
-
-
-asyncio.run(main())
-```
-
-This package provides the Python producer client and worker runtime for `pgtask`. See the
-[Python SDK documentation](https://github.com/Kludex/pgtask/blob/main/docs/sdk/python.md) for workers, transactions,
-durable execution, signals, cancellation, and OpenTelemetry propagation.