pydocket 0.6.2__tar.gz → 0.6.4__tar.gz

{pydocket-0.6.2 → pydocket-0.6.4}/.cursor/rules/general.mdc

@@ -6,7 +6,7 @@ alwaysApply: true
 
 # about docket
 docket is a distributed background task system for Python functions with a focus
-on the scheduling of future work as seamlessly and efficiency as immediate work.
+on the scheduling of future work as seamlessly and efficiently as immediate work.
 
 docket is built in Python and uses Redis as the message broker and storage system.
 

pydocket-0.6.4/.github/workflows/docs.yml

@@ -0,0 +1,84 @@
+name: Documentation
+
+on:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+  pull-requests: write
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install uv and set Python version
+        uses: astral-sh/setup-uv@v5
+        with:
+          python-version: "3.12"
+          enable-cache: true
+          cache-dependency-glob: "pyproject.toml"
+
+      - name: Install dependencies
+        run: uv sync --group docs
+
+      - name: Build documentation
+        run: uv run mkdocs build
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        id: docs-artifact
+        with:
+          name: documentation
+          path: site/
+
+      - name: Add or Update Comment
+        if: github.event_name == 'pull_request'
+        uses: marocchino/sticky-pull-request-comment@v2
+        with:
+          header: preview
+          message: |
+            📚 Documentation has been built for this PR!
+
+            You can download the documentation directly here:
+            ${{ steps.docs-artifact.outputs.artifact-url }}
+
+  publish:
+    needs: build
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - name: Download artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: documentation
+          path: site
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+
+      - name: Upload Pages artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: site
+
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

pydocket-0.6.4/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: pydocket
+Version: 0.6.4
+Summary: A distributed background task system for Python functions
+Project-URL: Homepage, https://github.com/chrisguidry/docket
+Project-URL: Bug Tracker, https://github.com/chrisguidry/docket/issues
+Author-email: Chris Guidry <guid@omg.lol>
+License: # Released under MIT License
+        
+        Copyright (c) 2025 Chris Guidry.
+        
+        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.
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: cloudpickle>=3.1.1
+Requires-Dist: opentelemetry-api>=1.30.0
+Requires-Dist: opentelemetry-exporter-prometheus>=0.51b0
+Requires-Dist: prometheus-client>=0.21.1
+Requires-Dist: python-json-logger>=3.2.1
+Requires-Dist: redis>=4.6
+Requires-Dist: rich>=13.9.4
+Requires-Dist: typer>=0.15.1
+Requires-Dist: uuid7>=0.1.0
+Description-Content-Type: text/markdown
+
+Docket is a distributed background task system for Python functions with a focus
+on the scheduling of future work as seamlessly and efficiently as immediate work.
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pydocket)](https://pypi.org/project/pydocket/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydocket)](https://pypi.org/project/pydocket/)
+[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions/workflows/ci.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/chrisguidry/docket)](https://app.codecov.io/gh/chrisguidry/docket)
+[![PyPI - License](https://img.shields.io/pypi/l/pydocket)](https://github.com/chrisguidry/docket/blob/main/LICENSE)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://chrisguidry.github.io/docket/)
+
+## At a glance
+
+```python
+from datetime import datetime, timedelta, timezone
+
+from docket import Docket
+
+
+async def greet(name: str, greeting="Hello") -> None:
+    print(f"{greeting}, {name} at {datetime.now()}!")
+
+
+async with Docket() as docket:
+    await docket.add(greet)("Jane")
+
+    now = datetime.now(timezone.utc)
+    soon = now + timedelta(seconds=3)
+    await docket.add(greet, when=soon)("John", greeting="Howdy")
+```
+
+```python
+from docket import Docket, Worker
+
+async with Docket() as docket:
+    async with Worker(docket) as worker:
+        await worker.run_until_finished()
+```
+
+```
+Hello, Jane at 2025-03-05 13:58:21.552644!
+Howdy, John at 2025-03-05 13:58:24.550773!
+```
+
+Check out our docs for more [details](http://chrisguidry.github.io/docket/),
+[examples](https://chrisguidry.github.io/docket/getting-started/), and the [API
+reference](https://chrisguidry.github.io/docket/api-reference/).
+
+## Why `docket`?
+
+⚡️ Snappy one-way background task processing without any bloat
+
+📅 Schedule immediate or future work seamlessly with the same interface
+
+⏭️ Skip problematic tasks or parameters without redeploying
+
+🌊 Purpose-built for Redis streams
+
+🧩 Fully type-complete and type-aware for your background task functions
+
+## Installing `docket`
+
+Docket is [available on PyPI](https://pypi.org/project/pydocket/) under the package name
+`pydocket`. It targets Python 3.12 or above.
+
+With [`uv`](https://docs.astral.sh/uv/):
+
+```bash
+uv pip install pydocket
+
+or
+
+uv add pydocket
+```
+
+With `pip`:
+
+```bash
+pip install pydocket
+```
+
+Docket requires a [Redis](http://redis.io/) server with Streams support (which was
+introduced in Redis 5.0.0). Docket is tested with Redis 6 and 7.
+
+# Hacking on `docket`
+
+We use [`uv`](https://docs.astral.sh/uv/) for project management, so getting set up
+should be as simple as cloning the repo and running:
+
+```bash
+uv sync
+```
+
+The to run the test suite:
+
+```bash
+pytest
+```
+
+We aim to maintain 100% test coverage, which is required for all PRs to `docket`. We
+believe that `docket` should stay small, simple, understandable, and reliable, and that
+begins with testing all the dusty branches and corners. This will give us the
+confidence to upgrade dependencies quickly and to adapt to new versions of Redis over
+time.

pydocket-0.6.4/README.md

@@ -0,0 +1,103 @@
+Docket is a distributed background task system for Python functions with a focus
+on the scheduling of future work as seamlessly and efficiently as immediate work.
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pydocket)](https://pypi.org/project/pydocket/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydocket)](https://pypi.org/project/pydocket/)
+[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions/workflows/ci.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/chrisguidry/docket)](https://app.codecov.io/gh/chrisguidry/docket)
+[![PyPI - License](https://img.shields.io/pypi/l/pydocket)](https://github.com/chrisguidry/docket/blob/main/LICENSE)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://chrisguidry.github.io/docket/)
+
+## At a glance
+
+```python
+from datetime import datetime, timedelta, timezone
+
+from docket import Docket
+
+
+async def greet(name: str, greeting="Hello") -> None:
+    print(f"{greeting}, {name} at {datetime.now()}!")
+
+
+async with Docket() as docket:
+    await docket.add(greet)("Jane")
+
+    now = datetime.now(timezone.utc)
+    soon = now + timedelta(seconds=3)
+    await docket.add(greet, when=soon)("John", greeting="Howdy")
+```
+
+```python
+from docket import Docket, Worker
+
+async with Docket() as docket:
+    async with Worker(docket) as worker:
+        await worker.run_until_finished()
+```
+
+```
+Hello, Jane at 2025-03-05 13:58:21.552644!
+Howdy, John at 2025-03-05 13:58:24.550773!
+```
+
+Check out our docs for more [details](http://chrisguidry.github.io/docket/),
+[examples](https://chrisguidry.github.io/docket/getting-started/), and the [API
+reference](https://chrisguidry.github.io/docket/api-reference/).
+
+## Why `docket`?
+
+⚡️ Snappy one-way background task processing without any bloat
+
+📅 Schedule immediate or future work seamlessly with the same interface
+
+⏭️ Skip problematic tasks or parameters without redeploying
+
+🌊 Purpose-built for Redis streams
+
+🧩 Fully type-complete and type-aware for your background task functions
+
+## Installing `docket`
+
+Docket is [available on PyPI](https://pypi.org/project/pydocket/) under the package name
+`pydocket`. It targets Python 3.12 or above.
+
+With [`uv`](https://docs.astral.sh/uv/):
+
+```bash
+uv pip install pydocket
+
+or
+
+uv add pydocket
+```
+
+With `pip`:
+
+```bash
+pip install pydocket
+```
+
+Docket requires a [Redis](http://redis.io/) server with Streams support (which was
+introduced in Redis 5.0.0). Docket is tested with Redis 6 and 7.
+
+# Hacking on `docket`
+
+We use [`uv`](https://docs.astral.sh/uv/) for project management, so getting set up
+should be as simple as cloning the repo and running:
+
+```bash
+uv sync
+```
+
+The to run the test suite:
+
+```bash
+pytest
+```
+
+We aim to maintain 100% test coverage, which is required for all PRs to `docket`. We
+believe that `docket` should stay small, simple, understandable, and reliable, and that
+begins with testing all the dusty branches and corners. This will give us the
+confidence to upgrade dependencies quickly and to adapt to new versions of Redis over
+time.

pydocket-0.6.4/docs/api-reference.md

@@ -0,0 +1,3 @@
+# API Reference
+
+::: docket

pydocket-0.6.2/README.md → pydocket-0.6.4/docs/getting-started.md

@@ -1,69 +1,14 @@
-Docket is a distributed background task system for Python functions with a focus
-on the scheduling of future work as seamlessly and efficiency as immediate work.
-
-[![PyPI - Version](https://img.shields.io/pypi/v/pydocket)](https://pypi.org/project/pydocket/)
-[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydocket)](https://pypi.org/project/pydocket/)
-[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions/workflows/ci.yml)
-[![Codecov](https://img.shields.io/codecov/c/github/chrisguidry/docket)](https://app.codecov.io/gh/chrisguidry/docket)
-[![PyPI - License](https://img.shields.io/pypi/l/pydocket)](https://github.com/chrisguidry/docket/blob/main/LICENSE)
-
-## At a glance
-
-```python
-from datetime import datetime, timedelta, timezone
-
-from docket import Docket
-
-
-async def greet(name: str, greeting="Hello") -> None:
-    print(f"{greeting}, {name} at {datetime.now()}!")
-
-
-async with Docket() as docket:
-    await docket.add(greet)("Jane")
-
-    now = datetime.now(timezone.utc)
-    soon = now + timedelta(seconds=3)
-    await docket.add(greet, when=soon)("John", greeting="Howdy")
-```
-
-```python
-from docket import Docket, Worker
-
-async with Docket() as docket:
-    async with Worker(docket) as worker:
-        await worker.run_until_finished()
-```
-
-```
-Hello, Jane at 2025-03-05 13:58:21.552644!
-Howdy, John at 2025-03-05 13:58:24.550773!
-```
-
-## Why `docket`?
-
-⚡️ Snappy one-way background task processing without any bloat
-
-📅 Schedule immediate or future work seamlessly with the same interface
-
-⏭️ Skip problematic tasks or parameters without redeploying
-
-🌊 Purpose-built for Redis streams
-
-🧩 Fully type-complete and type-aware for your background task functions
-
-
 ## Installing `docket`
 
 Docket is [available on PyPI](https://pypi.org/project/pydocket/) under the package name
-`pydocket`.  It targets Python 3.12 or above.
+`pydocket`. It targets Python 3.12 or above.
 
 With [`uv`](https://docs.astral.sh/uv/):
 
 ```bash
 uv pip install pydocket
 
-or
+# or
 
 uv add pydocket
 ```
@@ -74,14 +19,10 @@ With `pip`:
 pip install pydocket
 ```
 
-Docket requires a [Redis](http://redis.io/) server with Streams support (which was
-introduced in Redis 5.0.0).  Docket is tested with Redis 7.
-
-
 ## Creating a `Docket`
 
 Each `Docket` should have a name that will be shared across your system, like the name
-of a topic or queue.  By default this is `"docket"`.  You can support many separate
+of a topic or queue. By default this is `"docket"`. You can support many separate
 dockets on a single Redis server as long as they have different names.
 
 Docket accepts a URL to connect to the Redis server (defaulting to the local
@@ -96,11 +37,10 @@ async with Docket(name="orders", url="redis://my-redis:6379/0") as docket:
 The `name` and `url` together represent a single shared docket of work across all your
 system.
 
-
 ## Scheduling work
 
-A `Docket` is the entrypoint to scheduling immediate and future work.  You define work
-in the form of `async` functions that return `None`.  These task functions can accept
+A `Docket` is the entrypoint to scheduling immediate and future work. You define work
+in the form of `async` functions that return `None`. These task functions can accept
 any parameter types, so long as they can be serialized with
 [`cloudpickle`](https://github.com/cloudpipe/cloudpickle).
 
@@ -125,7 +65,7 @@ async with Docket() as docket:
 `when: datetime` parameter).
 
 All task executions are identified with a `key` that captures the unique essence of that
-piece of work.  By default they are randomly assigned UUIDs, but assigning your own keys
+piece of work. By default they are randomly assigned UUIDs, but assigning your own keys
 unlocks many powerful capabilities.
 
 ```python
@@ -171,9 +111,9 @@ await docket.cancel("welcome-email-for-12345")
 ```
 
 Tasks may also be called by name, in cases where you can't or don't want to import the
-module that has your tasks.  This may be common in a distributed environment where the
+module that has your tasks. This may be common in a distributed environment where the
 code of your task system just isn't available, or it requires heavyweight libraries that
-you wouldn't want to import into your web server.  In this case, you will lose the
+you wouldn't want to import into your web server. In this case, you will lose the
 type-checking for `.add` and `.replace` calls, but otherwise everything will work as
 it does with the actual function:
 
@@ -187,8 +127,8 @@ large-scale and robust system of background tasks for your application.
 ## Writing tasks
 
 Tasks are any `async` function that takes `cloudpickle`-able parameters, and returns
-`None`.  Returning `None` is a strong signal that these are _fire-and-forget_ tasks
-whose results aren't used or waited-on by your application.  These are the only kinds of
+`None`. Returning `None` is a strong signal that these are _fire-and-forget_ tasks
+whose results aren't used or waited-on by your application. These are the only kinds of
 tasks that Docket supports.
 
 Docket uses a parameter-based dependency and configuration pattern, which has become
@@ -198,7 +138,7 @@ As such, there is no decorator for tasks.
 
 A very common requirement for tasks is that they have access to schedule further work
 on their own docket, especially for chains of self-perpetuating tasks to implement
-distributed polling and other periodic systems.  One of the first dependencies you may
+distributed polling and other periodic systems. One of the first dependencies you may
 look for is the `CurrentDocket`:
 
 ```python
@@ -215,8 +155,8 @@ async def poll_for_changes(file: Path, docket: Docket = CurrentDocket()) -> None
 ```
 
 Here the argument to `docket` is an instance of `Docket` with the same name and URL as
-the worker it's running on.  You can ask for the `CurrentWorker` and `CurrentExecution`
-as well.  Many times it could be useful to have your own task `key` available in order
+the worker it's running on. You can ask for the `CurrentWorker` and `CurrentExecution`
+as well. Many times it could be useful to have your own task `key` available in order
 to idempotently schedule future work:
 
 ```python
@@ -252,7 +192,7 @@ async def faily(retry: Retry = Retry(attempts=5, delay=timedelta(seconds=3))):
 ```
 
 In this case, the task `faily` will run 4 times with a delay of 3 seconds between each
-attempt.  If it were to get to 5 attempts, no more would be attempted.  This is a
+attempt. If it were to get to 5 attempts, no more would be attempted. This is a
 linear retry, and an `ExponentialRetry` is also available:
 
 ```python
@@ -276,13 +216,12 @@ async def faily(
 
 This would retry in 2, 4, 8, then 16 seconds before that fourth attempt succeeded.
 
-
 ## Running workers
 
-You can run as many workers as you like to process the tasks on your docket.  You can
-either run a worker programmatically in Python, or via the CLI.  Clients using docket
+You can run as many workers as you like to process the tasks on your docket. You can
+either run a worker programmatically in Python, or via the CLI. Clients using docket
 have the advantage that they are usually passing the task functions, but workers don't
-necessarily know which tasks they are supposed to run.  Docket solves this by allowing
+necessarily know which tasks they are supposed to run. Docket solves this by allowing
 you to explicitly register tasks.
 
 In `my_tasks.py`:
@@ -324,30 +263,24 @@ to your needs with the `concurrency=` keyword argument or the `--concurrency` CL
 option.
 
 When a worker crashes ungracefully, any tasks it was currently executing will be held
-for a period of time before being redelivered to other workers.  You can control this
-time period with `redelivery_timeout=` or `--redelivery-timeout`.  You'd want to set
-this to a value higher than the longest task you expect to run.  For queues of very fast
+for a period of time before being redelivered to other workers. You can control this
+time period with `redelivery_timeout=` or `--redelivery-timeout`. You'd want to set
+this to a value higher than the longest task you expect to run. For queues of very fast
 tasks, a few seconds may be ideal; for long data-processing steps involving large
 amount of data, you may need minutes.
 
+## Delivery guarantees
 
-# Hacking on `docket`
-
-We use [`uv`](https://docs.astral.sh/uv/) for project management, so getting set up
-should be as simple as cloning the repo and running:
-
-```bash
-uv sync
-```
-
-The to run the test suite:
+Docket provides _at-least-once_ delivery semantics. When a worker picks up a
+task, if it crashes or fails to acknowledge within `redelivery_timeout`, the
+task will be considered unacknowledged and redelivered to another available
+worker. This ensures tasks are not lost but may be delivered more than once. To
+achieve exactly-once processing, design your tasks to be idempotent.
 
-```bash
-pytest
-```
+## Serialization and cloudpickle usage
 
-We aim to main 100% test coverage, which is required for all PRs to `docket`.  We
-believe that `docket` should stay small, simple, understandable, and reliable, and that
-begins with testing all the dusty branches and corners.  This will give us the
-confidence to upgrade dependencies quickly and to adapt to new versions of Redis over
-time.
+Docket uses `cloudpickle` to serialize task functions and their arguments. This
+allows you to pass nearly any Python object as arguments to a task, but it also
+means that deserializing these arguments can execute arbitrary code. Avoid
+scheduling tasks from untrusted or unauthenticated sources to mitigate security
+risks.

pydocket-0.6.4/docs/index.md

@@ -0,0 +1,71 @@
+# Welcome to docket
+
+Docket is a distributed background task system for Python functions with a focus
+on the scheduling of future work as seamlessly and efficiently as immediate work.
+
+[![PyPI - Version](https://img.shields.io/pypi/v/pydocket)](https://pypi.org/project/pydocket/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/pydocket)](https://pypi.org/project/pydocket/)
+[![GitHub main checks](https://img.shields.io/github/check-runs/chrisguidry/docket/main)](https://github.com/chrisguidry/docket/actions/workflows/ci.yml)
+[![Codecov](https://img.shields.io/codecov/c/github/chrisguidry/docket)](https://app.codecov.io/gh/chrisguidry/docket)
+[![PyPI - License](https://img.shields.io/pypi/l/pydocket)](https://github.com/chrisguidry/docket/blob/main/LICENSE)
+
+## At a glance
+
+```python
+from datetime import datetime, timedelta, timezone
+
+from docket import Docket
+
+
+async def greet(name: str, greeting="Hello") -> None:
+    print(f"{greeting}, {name} at {datetime.now()}!")
+
+
+async with Docket() as docket:
+    await docket.add(greet)("Jane")
+
+    now = datetime.now(timezone.utc)
+    soon = now + timedelta(seconds=3)
+    await docket.add(greet, when=soon)("John", greeting="Howdy")
+```
+
+And in another process, run a worker:
+
+```python
+from docket import Docket, Worker
+
+async with Docket() as docket:
+    async with Worker(docket) as worker:
+        await worker.run_until_finished()
+```
+
+Which produces:
+
+```
+Hello, Jane at 2025-03-05 13:58:21.552644!
+Howdy, John at 2025-03-05 13:58:24.550773!
+```
+
+## Why docket?
+
+⚡️ Snappy one-way background task processing without any bloat
+
+📅 Schedule immediate or future work seamlessly with the same interface
+
+⏭️ Skip problematic tasks or parameters without redeploying
+
+🌊 Purpose-built for Redis streams
+
+🧩 Fully type-complete and type-aware for your background task functions
+
+## How It Works
+
+docket integrates two modes of task execution:
+
+1. **Immediate tasks** are pushed onto a Redis stream and are available to be picked up by any worker.
+2. **Scheduled tasks** are pushed onto a Redis sorted set with a schedule time. A loop within each worker moves scheduled tasks onto the stream when their schedule time has arrived. This move is performed as a Lua script to ensure atomicity.
+
+Docket requires a [Redis](http://redis.io/) server with Streams support (which was
+introduced in Redis 5.0.0). Docket is tested with Redis 6 and 7.
+
+For more detailed information, check out our [Getting Started](getting-started.md) guide or dive into the [API Reference](api-reference.md).

{pydocket-0.6.2 → pydocket-0.6.4}/examples/common.py

@@ -30,7 +30,7 @@ async def run_redis(version: str) -> AsyncGenerator[str, None]:
             break
 
     url = f"redis://localhost:{port}/0"
-    print("***** Redis is running on %s *****", url)
+    print(f"***** Redis is running on {url} *****")
     try:
         yield url
     finally:
@@ -43,8 +43,6 @@ async def run_example_workers(workers: int, concurrency: int, tasks: str):
             await asyncio.create_subprocess_exec(
                 "docket",
                 "worker",
-                "--name",
-                f"worker-{i}",
                 "--url",
                 redis_url,
                 "--tasks",

{pydocket-0.6.2 → pydocket-0.6.4}/examples/find_and_flood.py

@@ -1,4 +1,5 @@
 import asyncio
+import random
 from datetime import timedelta
 from logging import Logger, LoggerAdapter
 from typing import Annotated
@@ -16,7 +17,7 @@ async def find(
     perpetual: Perpetual = Perpetual(every=timedelta(seconds=3), automatic=True),
 ) -> None:
     for i in range(1, 10 + 1):
-        await docket.add(flood, key=f"item-{i}")(i)
+        await docket.add(flood)(i)
 
 
 async def flood(
@@ -24,6 +25,7 @@ async def flood(
     logger: LoggerAdapter[Logger] = TaskLogger(),
 ) -> None:
     logger.info("Working on %s", item)
+    await asyncio.sleep(random.uniform(0.5, 2))
 
 
 tasks = [find, flood]