taskito 0.2.0__tar.gz → 0.2.2__tar.gz

{taskito-0.2.0 → taskito-0.2.2}/Cargo.lock

@@ -221,7 +221,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -448,7 +448,7 @@ checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
 dependencies = [
  "libc",
  "wasi",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -705,7 +705,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -802,12 +802,12 @@ checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
 [[package]]
 name = "socket2"
-version = "0.6.2"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
 dependencies = [
  "libc",
- "windows-sys 0.60.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -847,7 +847,7 @@ checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
 
 [[package]]
 name = "taskito-core"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "chrono",
  "cron",
@@ -866,7 +866,7 @@ dependencies = [
 
 [[package]]
 name = "taskito-python"
-version = "0.2.0"
+version = "0.2.2"
 dependencies = [
  "crossbeam-channel",
  "pyo3",
@@ -885,7 +885,7 @@ dependencies = [
  "getrandom 0.4.2",
  "once_cell",
  "rustix",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -973,7 +973,7 @@ dependencies = [
  "signal-hook-registry",
  "socket2",
  "tokio-macros",
- "windows-sys 0.61.2",
+ "windows-sys",
 ]
 
 [[package]]
@@ -1184,15 +1184,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-sys"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
-dependencies = [
- "windows-targets",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.61.2"
@@ -1202,71 +1193,6 @@ dependencies = [
  "windows-link",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.53.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
-dependencies = [
- "windows-link",
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
-
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
-
 [[package]]
 name = "wit-bindgen"
 version = "0.51.0"

taskito-0.2.2/PKG-INFO

@@ -0,0 +1,286 @@
+Metadata-Version: 2.4
+Name: taskito
+Version: 0.2.2
+Requires-Dist: cloudpickle>=3.0
+Requires-Dist: pytest>=7.0 ; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21 ; extra == 'dev'
+Requires-Dist: ruff>=0.8 ; extra == 'dev'
+Requires-Dist: mypy>=1.13 ; extra == 'dev'
+Requires-Dist: zensical ; extra == 'docs'
+Requires-Dist: fastapi>=0.100.0 ; extra == 'fastapi'
+Requires-Dist: pydantic>=2.0 ; extra == 'fastapi'
+Requires-Dist: opentelemetry-api ; extra == 'otel'
+Requires-Dist: opentelemetry-sdk ; extra == 'otel'
+Provides-Extra: dev
+Provides-Extra: docs
+Provides-Extra: fastapi
+Provides-Extra: otel
+License-File: LICENSE
+Summary: Rust-powered task queue for Python. No broker required.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+# taskito
+
+[![PyPI version](https://img.shields.io/pypi/v/taskito.svg)](https://pypi.org/project/taskito/)
+[![Python versions](https://img.shields.io/pypi/pyversions/taskito.svg)](https://pypi.org/project/taskito/)
+[![License](https://img.shields.io/pypi/l/taskito.svg)](https://github.com/pratyush618/taskito/blob/master/LICENSE)
+
+A Rust-powered task queue for Python. No broker required — just SQLite.
+
+```
+pip install taskito
+```
+
+## Quickstart
+
+**1. Define tasks** in `tasks.py`:
+
+```python
+from taskito import Queue
+
+queue = Queue(db_path="tasks.db")
+
+@queue.task()
+def add(a: int, b: int) -> int:
+    return a + b
+```
+
+**2. Start a worker** in one terminal:
+
+```bash
+taskito worker --app tasks:queue
+```
+
+**3. Enqueue jobs** from another terminal or script:
+
+```python
+from tasks import add
+
+job = add.delay(2, 3)
+print(job.result(timeout=10))  # 5
+```
+
+## Why taskito?
+
+Most Python task queues require a separate broker (Redis, RabbitMQ) even for single-machine workloads. taskito embeds everything — storage, scheduling, and worker management — into a single `pip install` with no external dependencies beyond Python itself.
+
+The heavy lifting runs in Rust: a Tokio async scheduler, OS thread worker pool with crossbeam channels, and Diesel ORM over SQLite in WAL mode. Python's GIL is only held during task execution.
+
+## Features
+
+- **Priority queues** — higher priority jobs run first
+- **Retry with exponential backoff** — automatic retries with jitter
+- **Dead letter queue** — inspect and replay failed jobs
+- **Rate limiting** — token bucket with `"100/m"` syntax
+- **Task dependencies** — `depends_on` for DAG workflows with cascade cancel
+- **Task workflows** — `chain`, `group`, `chord` primitives
+- **Periodic tasks** — cron scheduling with seconds granularity
+- **Progress tracking** — report and read progress from inside tasks
+- **Job cancellation** — cancel pending or running jobs
+- **Unique tasks** — deduplicate active jobs by key
+- **Batch enqueue** — `task.map()` for high-throughput bulk inserts
+- **Named queues** — route tasks to isolated queues
+- **Hooks** — before/after/success/failure middleware
+- **Per-task middleware** — `TaskMiddleware` with `before`/`after`/`on_retry` hooks
+- **Pluggable serializers** — `CloudpickleSerializer` (default), `JsonSerializer`, or custom
+- **Cancel running tasks** — cooperative cancellation with `check_cancelled()`
+- **Soft timeouts** — `check_timeout()` inside tasks
+- **Worker heartbeat** — monitor worker health via `queue.workers()`
+- **Job expiration** — `expires` parameter for time-sensitive jobs
+- **Exception filtering** — `retry_on` / `dont_retry_on` for selective retries
+- **OpenTelemetry** — optional tracing integration via `pip install taskito[otel]`
+- **Async support** — `await job.aresult()`, `await queue.astats()`
+- **Web dashboard** — `taskito dashboard --app myapp:queue` serves a built-in monitoring UI
+- **FastAPI integration** — `TaskitoRouter` for instant REST API over the queue
+- **CLI** — `taskito worker`, `taskito info --watch`, `taskito dashboard`
+
+## Examples
+
+### Retry with Backoff
+
+```python
+@queue.task(max_retries=5, retry_backoff=2.0)
+def fetch_url(url: str) -> str:
+    return requests.get(url).text
+```
+
+### Priority Queues
+
+```python
+urgent_report.apply_async(args=[data], priority=10)
+bulk_report.delay(data)  # default priority 0
+```
+
+### Rate Limiting
+
+```python
+@queue.task(rate_limit="100/m")
+def call_api(endpoint: str) -> dict:
+    return requests.get(endpoint).json()
+```
+
+### Task Dependencies
+
+```python
+download = fetch_file.delay("data.csv")
+parsed = parse_file.apply_async(
+    args=["data.csv"],
+    depends_on=[download.id],
+)
+# parsed waits until download completes; if download fails, parsed is cancelled
+```
+
+### Workflows
+
+```python
+from taskito import chain, group, chord
+
+# Sequential pipeline — each step receives the previous result
+chain(fetch.s(url), parse.s(), store.s()).apply()
+
+# Parallel fan-out
+group(process.s(chunk) for chunk in chunks).apply()
+
+# Parallel + callback when all complete
+chord([download.s(u) for u in urls], merge.s()).apply()
+```
+
+### Periodic Tasks
+
+```python
+@queue.periodic(cron="0 */6 * * *")
+def cleanup_temp_files():
+    ...
+```
+
+### Progress Tracking
+
+```python
+from taskito import current_job
+
+@queue.task()
+def train_model(epochs: int):
+    for i in range(epochs):
+        ...
+        current_job.update_progress(int((i + 1) / epochs * 100))
+```
+
+### Hooks
+
+```python
+@queue.on_failure
+def alert_on_failure(task_name, args, kwargs, error):
+    slack.post(f"Task {task_name} failed: {error}")
+```
+
+### Exception Filtering
+
+```python
+@queue.task(
+    max_retries=5,
+    retry_on=[ConnectionError, TimeoutError],
+    dont_retry_on=[ValueError],
+)
+def fetch_data(url: str) -> dict:
+    return requests.get(url).json()
+```
+
+### Per-Task Middleware
+
+```python
+from taskito import TaskMiddleware
+
+class TimingMiddleware(TaskMiddleware):
+    def before(self, ctx):
+        ctx._start = time.time()
+
+    def after(self, ctx, result, error):
+        elapsed = time.time() - ctx._start
+        print(f"{ctx.task_name} took {elapsed:.2f}s")
+
+@queue.task(middleware=[TimingMiddleware()])
+def process(data):
+    ...
+```
+
+### Delayed Scheduling
+
+```python
+# Run 30 minutes from now
+reminder.apply_async(args=[user_id, msg], delay=1800)
+```
+
+### Unique Tasks
+
+```python
+report.apply_async(args=[user_id], unique_key=f"report:{user_id}")
+# Second enqueue with same key is silently deduplicated while first is active
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from taskito.contrib.fastapi import TaskitoRouter
+
+app = FastAPI()
+app.include_router(TaskitoRouter(queue), prefix="/tasks")
+# GET /tasks/stats, GET /tasks/jobs/{id}, GET /tasks/jobs/{id}/progress (SSE), ...
+```
+
+### Batch Enqueue
+
+```python
+jobs = send_email.map([("alice@x.com",), ("bob@x.com",), ("carol@x.com",)])
+```
+
+### Async Support
+
+```python
+job = expensive_task.delay(data)
+result = await job.aresult(timeout=30)
+stats = await queue.astats()
+```
+
+## Testing
+
+taskito includes a built-in test mode — no worker needed:
+
+```python
+def test_add():
+    with queue.test_mode() as results:
+        add.delay(2, 3)
+        assert results[0].return_value == 5
+```
+
+## Documentation
+
+Full documentation with guides, API reference, architecture diagrams, and examples:
+
+**[Read the docs →](https://taskito-sepia.vercel.app)**
+
+Coming from Celery? See the **[Migration Guide](https://taskito-sepia.vercel.app/guide/migration/)**.
+
+## Comparison
+
+| Feature | taskito | Celery | RQ | Dramatiq | Huey |
+|---|---|---|---|---|---|
+| Broker required | **No** | Yes | Yes | Yes | Yes |
+| Core language | **Rust + Python** | Python | Python | Python | Python |
+| Priority queues | **Yes** | Yes | No | No | Yes |
+| Rate limiting | **Yes** | Yes | No | Yes | No |
+| Dead letter queue | **Yes** | No | Yes | No | No |
+| Task dependencies | **Yes** | No | No | No | No |
+| Task chaining | **Yes** | Yes | No | Yes | No |
+| Built-in dashboard | **Yes** | No | No | No | No |
+| FastAPI integration | **Yes** | No | No | No | No |
+| Per-task middleware | **Yes** | No | No | Yes | No |
+| Cancel running tasks | **Yes** | Yes | No | No | No |
+| Custom serializers | **Yes** | Yes | No | No | No |
+| Setup | **`pip install`** | Broker + backend | Redis | Broker | Redis |
+
+## License
+
+MIT
+

taskito-0.2.2/README.md

@@ -0,0 +1,263 @@
+# taskito
+
+[![PyPI version](https://img.shields.io/pypi/v/taskito.svg)](https://pypi.org/project/taskito/)
+[![Python versions](https://img.shields.io/pypi/pyversions/taskito.svg)](https://pypi.org/project/taskito/)
+[![License](https://img.shields.io/pypi/l/taskito.svg)](https://github.com/pratyush618/taskito/blob/master/LICENSE)
+
+A Rust-powered task queue for Python. No broker required — just SQLite.
+
+```
+pip install taskito
+```
+
+## Quickstart
+
+**1. Define tasks** in `tasks.py`:
+
+```python
+from taskito import Queue
+
+queue = Queue(db_path="tasks.db")
+
+@queue.task()
+def add(a: int, b: int) -> int:
+    return a + b
+```
+
+**2. Start a worker** in one terminal:
+
+```bash
+taskito worker --app tasks:queue
+```
+
+**3. Enqueue jobs** from another terminal or script:
+
+```python
+from tasks import add
+
+job = add.delay(2, 3)
+print(job.result(timeout=10))  # 5
+```
+
+## Why taskito?
+
+Most Python task queues require a separate broker (Redis, RabbitMQ) even for single-machine workloads. taskito embeds everything — storage, scheduling, and worker management — into a single `pip install` with no external dependencies beyond Python itself.
+
+The heavy lifting runs in Rust: a Tokio async scheduler, OS thread worker pool with crossbeam channels, and Diesel ORM over SQLite in WAL mode. Python's GIL is only held during task execution.
+
+## Features
+
+- **Priority queues** — higher priority jobs run first
+- **Retry with exponential backoff** — automatic retries with jitter
+- **Dead letter queue** — inspect and replay failed jobs
+- **Rate limiting** — token bucket with `"100/m"` syntax
+- **Task dependencies** — `depends_on` for DAG workflows with cascade cancel
+- **Task workflows** — `chain`, `group`, `chord` primitives
+- **Periodic tasks** — cron scheduling with seconds granularity
+- **Progress tracking** — report and read progress from inside tasks
+- **Job cancellation** — cancel pending or running jobs
+- **Unique tasks** — deduplicate active jobs by key
+- **Batch enqueue** — `task.map()` for high-throughput bulk inserts
+- **Named queues** — route tasks to isolated queues
+- **Hooks** — before/after/success/failure middleware
+- **Per-task middleware** — `TaskMiddleware` with `before`/`after`/`on_retry` hooks
+- **Pluggable serializers** — `CloudpickleSerializer` (default), `JsonSerializer`, or custom
+- **Cancel running tasks** — cooperative cancellation with `check_cancelled()`
+- **Soft timeouts** — `check_timeout()` inside tasks
+- **Worker heartbeat** — monitor worker health via `queue.workers()`
+- **Job expiration** — `expires` parameter for time-sensitive jobs
+- **Exception filtering** — `retry_on` / `dont_retry_on` for selective retries
+- **OpenTelemetry** — optional tracing integration via `pip install taskito[otel]`
+- **Async support** — `await job.aresult()`, `await queue.astats()`
+- **Web dashboard** — `taskito dashboard --app myapp:queue` serves a built-in monitoring UI
+- **FastAPI integration** — `TaskitoRouter` for instant REST API over the queue
+- **CLI** — `taskito worker`, `taskito info --watch`, `taskito dashboard`
+
+## Examples
+
+### Retry with Backoff
+
+```python
+@queue.task(max_retries=5, retry_backoff=2.0)
+def fetch_url(url: str) -> str:
+    return requests.get(url).text
+```
+
+### Priority Queues
+
+```python
+urgent_report.apply_async(args=[data], priority=10)
+bulk_report.delay(data)  # default priority 0
+```
+
+### Rate Limiting
+
+```python
+@queue.task(rate_limit="100/m")
+def call_api(endpoint: str) -> dict:
+    return requests.get(endpoint).json()
+```
+
+### Task Dependencies
+
+```python
+download = fetch_file.delay("data.csv")
+parsed = parse_file.apply_async(
+    args=["data.csv"],
+    depends_on=[download.id],
+)
+# parsed waits until download completes; if download fails, parsed is cancelled
+```
+
+### Workflows
+
+```python
+from taskito import chain, group, chord
+
+# Sequential pipeline — each step receives the previous result
+chain(fetch.s(url), parse.s(), store.s()).apply()
+
+# Parallel fan-out
+group(process.s(chunk) for chunk in chunks).apply()
+
+# Parallel + callback when all complete
+chord([download.s(u) for u in urls], merge.s()).apply()
+```
+
+### Periodic Tasks
+
+```python
+@queue.periodic(cron="0 */6 * * *")
+def cleanup_temp_files():
+    ...
+```
+
+### Progress Tracking
+
+```python
+from taskito import current_job
+
+@queue.task()
+def train_model(epochs: int):
+    for i in range(epochs):
+        ...
+        current_job.update_progress(int((i + 1) / epochs * 100))
+```
+
+### Hooks
+
+```python
+@queue.on_failure
+def alert_on_failure(task_name, args, kwargs, error):
+    slack.post(f"Task {task_name} failed: {error}")
+```
+
+### Exception Filtering
+
+```python
+@queue.task(
+    max_retries=5,
+    retry_on=[ConnectionError, TimeoutError],
+    dont_retry_on=[ValueError],
+)
+def fetch_data(url: str) -> dict:
+    return requests.get(url).json()
+```
+
+### Per-Task Middleware
+
+```python
+from taskito import TaskMiddleware
+
+class TimingMiddleware(TaskMiddleware):
+    def before(self, ctx):
+        ctx._start = time.time()
+
+    def after(self, ctx, result, error):
+        elapsed = time.time() - ctx._start
+        print(f"{ctx.task_name} took {elapsed:.2f}s")
+
+@queue.task(middleware=[TimingMiddleware()])
+def process(data):
+    ...
+```
+
+### Delayed Scheduling
+
+```python
+# Run 30 minutes from now
+reminder.apply_async(args=[user_id, msg], delay=1800)
+```
+
+### Unique Tasks
+
+```python
+report.apply_async(args=[user_id], unique_key=f"report:{user_id}")
+# Second enqueue with same key is silently deduplicated while first is active
+```
+
+### FastAPI Integration
+
+```python
+from fastapi import FastAPI
+from taskito.contrib.fastapi import TaskitoRouter
+
+app = FastAPI()
+app.include_router(TaskitoRouter(queue), prefix="/tasks")
+# GET /tasks/stats, GET /tasks/jobs/{id}, GET /tasks/jobs/{id}/progress (SSE), ...
+```
+
+### Batch Enqueue
+
+```python
+jobs = send_email.map([("alice@x.com",), ("bob@x.com",), ("carol@x.com",)])
+```
+
+### Async Support
+
+```python
+job = expensive_task.delay(data)
+result = await job.aresult(timeout=30)
+stats = await queue.astats()
+```
+
+## Testing
+
+taskito includes a built-in test mode — no worker needed:
+
+```python
+def test_add():
+    with queue.test_mode() as results:
+        add.delay(2, 3)
+        assert results[0].return_value == 5
+```
+
+## Documentation
+
+Full documentation with guides, API reference, architecture diagrams, and examples:
+
+**[Read the docs →](https://taskito-sepia.vercel.app)**
+
+Coming from Celery? See the **[Migration Guide](https://taskito-sepia.vercel.app/guide/migration/)**.
+
+## Comparison
+
+| Feature | taskito | Celery | RQ | Dramatiq | Huey |
+|---|---|---|---|---|---|
+| Broker required | **No** | Yes | Yes | Yes | Yes |
+| Core language | **Rust + Python** | Python | Python | Python | Python |
+| Priority queues | **Yes** | Yes | No | No | Yes |
+| Rate limiting | **Yes** | Yes | No | Yes | No |
+| Dead letter queue | **Yes** | No | Yes | No | No |
+| Task dependencies | **Yes** | No | No | No | No |
+| Task chaining | **Yes** | Yes | No | Yes | No |
+| Built-in dashboard | **Yes** | No | No | No | No |
+| FastAPI integration | **Yes** | No | No | No | No |
+| Per-task middleware | **Yes** | No | No | Yes | No |
+| Cancel running tasks | **Yes** | Yes | No | No | No |
+| Custom serializers | **Yes** | Yes | No | No | No |
+| Setup | **`pip install`** | Broker + backend | Redis | Broker | Redis |
+
+## License
+
+MIT

{taskito-0.2.0 → taskito-0.2.2}/crates/taskito-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-core"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 
 [dependencies]

{taskito-0.2.0 → taskito-0.2.2}/crates/taskito-python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "taskito-python"
-version = "0.2.0"
+version = "0.2.2"
 edition = "2021"
 
 [lib]

{taskito-0.2.0 → taskito-0.2.2}/py_src/taskito/canvas.py

@@ -79,9 +79,7 @@ class group:
             concurrently. Members are dispatched in waves.
     """
 
-    def __init__(
-        self, *signatures: Signature, max_concurrency: int | None = None
-    ):
+    def __init__(self, *signatures: Signature, max_concurrency: int | None = None):
         if len(signatures) < 1:
             raise ValueError("group requires at least one signature")
         self.signatures = list(signatures)
@@ -154,9 +152,7 @@ class chord:
         )
 
 
-def chunks(
-    task: TaskWrapper, items: list[Any], chunk_size: int
-) -> group:
+def chunks(task: TaskWrapper, items: list[Any], chunk_size: int) -> group:
     """Split items into chunks and create a group of tasks processing each chunk.
 
     Args:
@@ -179,9 +175,7 @@ def chunks(
     return group(*sigs)
 
 
-def starmap(
-    task: TaskWrapper, args_list: list[tuple[Any, ...]]
-) -> group:
+def starmap(task: TaskWrapper, args_list: list[tuple[Any, ...]]) -> group:
     """Create a group with one task per args tuple.
 
     Args:

{taskito-0.2.0 → taskito-0.2.2}/py_src/taskito/context.py

@@ -75,9 +75,7 @@ class JobContext:
         if _queue_ref is None:
             raise RuntimeError("Queue reference not set. Cannot write log.")
         extra_str = json.dumps(extra) if extra else None
-        _queue_ref._inner.write_task_log(
-            ctx.job_id, ctx.task_name, level, message, extra_str
-        )
+        _queue_ref._inner.write_task_log(ctx.job_id, ctx.task_name, level, message, extra_str)
 
     def check_cancelled(self) -> None:
         """Check if cancellation has been requested for this job.

{taskito-0.2.0 → taskito-0.2.2}/py_src/taskito/dashboard.py

@@ -25,7 +25,9 @@ if TYPE_CHECKING:
 
 def _load_spa_html() -> str:
     """Load the dashboard SPA HTML from the bundled template file."""
-    return resources.files("taskito").joinpath("templates/dashboard.html").read_text(encoding="utf-8")
+    return (
+        resources.files("taskito").joinpath("templates/dashboard.html").read_text(encoding="utf-8")
+    )
 
 
 _SPA_HTML: str | None = None
@@ -106,7 +108,9 @@ def _make_handler(queue: Queue) -> type:
                 level = qs.get("level", [None])[0]
                 since = int(qs.get("since", ["3600"])[0])
                 limit = int(qs.get("limit", ["100"])[0])
-                self._json_response(queue.query_logs(task_name=task, level=level, since=since, limit=limit))
+                self._json_response(
+                    queue.query_logs(task_name=task, level=level, since=since, limit=limit)
+                )
             elif path == "/api/circuit-breakers":
                 self._json_response(queue.circuit_breakers())
             elif path == "/api/workers":

{taskito-0.2.0 → taskito-0.2.2}/py_src/taskito/mixins.py

@@ -19,9 +19,7 @@ class _AsyncMixin:
     async def _run_sync(self, fn: Any, *args: Any, **kwargs: Any) -> Any:
         loop = asyncio.get_event_loop()
         if kwargs:
-            return await loop.run_in_executor(
-                self._executor, lambda: fn(*args, **kwargs)
-            )
+            return await loop.run_in_executor(self._executor, lambda: fn(*args, **kwargs))
         return await loop.run_in_executor(self._executor, lambda: fn(*args))
 
 

{taskito-0.2.0 → taskito-0.2.2}/py_src/taskito/result.py

@@ -90,9 +90,7 @@ class JobResult:
             return status, cloudpickle.loads(result_bytes)
 
         if status in ("failed", "dead"):
-            raise RuntimeError(
-                f"Job {self.id} {status}: {self._py_job.error or 'unknown error'}"
-            )
+            raise RuntimeError(f"Job {self.id} {status}: {self._py_job.error or 'unknown error'}")
 
         return status, None
 

{taskito-0.2.0 → taskito-0.2.2}/py_src/taskito/testing.py

@@ -181,9 +181,7 @@ class _FakeJobResult:
 
     def result(self, timeout: float = 30.0, **kwargs: Any) -> Any:
         if self._tr.error:
-            raise RuntimeError(
-                f"Job {self._tr.job_id} failed: {self._tr.error}"
-            )
+            raise RuntimeError(f"Job {self._tr.job_id} failed: {self._tr.error}")
         return self._tr.return_value
 
     async def aresult(self, timeout: float = 30.0, **kwargs: Any) -> Any:

{taskito-0.2.0 → taskito-0.2.2}/pyproject.toml

@@ -4,10 +4,11 @@ build-backend = "maturin"
 
 [project]
 name = "taskito"
-version = "0.2.0"
+version = "0.2.2"
 description = "Rust-powered task queue for Python. No broker required."
 requires-python = ">=3.9"
 license = { file = "LICENSE" }
+readme = "README.md"
 dependencies = ["cloudpickle>=3.0"]
 
 [project.optional-dependencies]
@@ -23,7 +24,7 @@ module-name = "taskito._taskito"
 features = ["pyo3/extension-module"]
 
 [project.scripts]
-taskito = "taskito.cli:main"
+taskito = "taskito.cli:main"    
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

taskito-0.2.0/PKG-INFO

@@ -1,20 +0,0 @@
-Metadata-Version: 2.4
-Name: taskito
-Version: 0.2.0
-Requires-Dist: cloudpickle>=3.0
-Requires-Dist: pytest>=7.0 ; extra == 'dev'
-Requires-Dist: pytest-asyncio>=0.21 ; extra == 'dev'
-Requires-Dist: ruff>=0.8 ; extra == 'dev'
-Requires-Dist: mypy>=1.13 ; extra == 'dev'
-Requires-Dist: zensical ; extra == 'docs'
-Requires-Dist: fastapi>=0.100.0 ; extra == 'fastapi'
-Requires-Dist: pydantic>=2.0 ; extra == 'fastapi'
-Requires-Dist: opentelemetry-api ; extra == 'otel'
-Requires-Dist: opentelemetry-sdk ; extra == 'otel'
-Provides-Extra: dev
-Provides-Extra: docs
-Provides-Extra: fastapi
-Provides-Extra: otel
-License-File: LICENSE
-Summary: Rust-powered task queue for Python. No broker required.
-Requires-Python: >=3.9