pydocket 0.1.1__tar.gz → 0.1.3__tar.gz

pydocket-0.1.1/.cursorrules → pydocket-0.1.3/.cursor/rules/general.mdc

@@ -1,3 +1,10 @@
+---
+description:
+globs:
+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.
 
@@ -22,20 +29,3 @@ idempotency of an execution.
 
 A docket worker should be as easily usable in code as it is from the command line,
 and should be a breeze to use with test suites.
-
-# Code style
-
-When generating production code, always use full parameter and return type hints
-for every function. Never generate useless inline comments that just reiterate
-what the code is doing. It's okay to include comments in the rare case there is
-something tricky going on.
-
-When generating tests, always use parameter type hints, but never include the
-`-> None` return type hint for a test function. For `pytest` fixtures, always
-generate both the parameter and return type hints.
-
-When generating tests, favor smaller, focused tests that use fixtures for reuse.
-Don't include extraneous comments in the test code unless something needs more
-clarity. Always generate a docstring using "should" language to describe the
-aspect of the system the test is checking. Use simple direct language and avoid
-sounding stuffy, but make these complete sentences.

pydocket-0.1.3/.cursor/rules/python-style.mdc

@@ -0,0 +1,22 @@
+---
+description: how to write python
+globs: *.py
+alwaysApply: false
+---
+
+# Code style
+
+When generating production code, always use full parameter and return type hints
+for every function. Never generate useless inline comments that just reiterate
+what the code is doing. It's okay to include comments in the rare case there is
+something tricky going on.
+
+When generating tests, always use parameter type hints, but never include the
+`-> None` return type hint for a test function. For `pytest` fixtures, always
+generate both the parameter and return type hints.
+
+When generating tests, favor smaller, focused tests that use fixtures for reuse.
+Don't include extraneous comments in the test code unless something needs more
+clarity. Always generate a docstring using "should" language to describe the
+aspect of the system the test is checking. Use simple direct language and avoid
+sounding stuffy, but make these complete sentences.

{pydocket-0.1.1 → pydocket-0.1.3}/.github/workflows/ci.yml

@@ -9,12 +9,14 @@ on:
 
 jobs:
   test:
-    name: Test Python ${{ matrix.python-version }}
+    name: Test Python ${{ matrix.python-version }}, Redis ${{ matrix.redis-version }}, redis-py ${{ matrix.redis-py-version }}
     runs-on: ubuntu-latest
     strategy:
+      fail-fast: false
       matrix:
         python-version: ["3.12", "3.13"]
-
+        redis-version: ["6.2", "7.4"]
+        redis-py-version: [">=4.6,<5", ">=5"]
 
     steps:
       - uses: actions/checkout@v4
@@ -27,9 +29,11 @@ jobs:
           cache-dependency-glob: "pyproject.toml"
 
       - name: Install dependencies
-        run: uv sync --dev
+        run: uv sync --dev --upgrade-package 'redis${{ matrix.redis-py-version }}'
 
       - name: Run tests
+        env:
+          REDIS_VERSION: ${{ matrix.redis-version }}
         run: uv run pytest --cov-branch --cov-report=xml --cov-report=term-missing:skip-covered
 
       - name: Upload coverage reports to Codecov

{pydocket-0.1.1 → pydocket-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydocket
-Version: 0.1.1
+Version: 0.1.3
 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

{pydocket-0.1.1 → pydocket-0.1.3}/pyproject.toml

@@ -68,6 +68,7 @@ packages = ["src/docket"]
 addopts = "--cov=src/docket --cov=tests --cov-report=term-missing --cov-branch"
 asyncio_mode = "auto"
 asyncio_default_fixture_loop_scope = "session"
+filterwarnings = ["error"]
 
 [tool.pyright]
 include = ["src", "tests"]

{pydocket-0.1.1 → pydocket-0.1.3}/src/docket/cli.py

@@ -228,6 +228,14 @@ def worker(
             envvar="DOCKET_WORKER_RECONNECTION_DELAY",
         ),
     ] = timedelta(seconds=5),
+    minimum_check_interval: Annotated[
+        timedelta,
+        typer.Option(
+            parser=duration,
+            help="The minimum interval to check for tasks",
+            envvar="DOCKET_WORKER_MINIMUM_CHECK_INTERVAL",
+        ),
+    ] = timedelta(milliseconds=100),
     until_finished: Annotated[
         bool,
         typer.Option(
@@ -244,6 +252,7 @@ def worker(
             concurrency=concurrency,
             redelivery_timeout=redelivery_timeout,
             reconnection_delay=reconnection_delay,
+            minimum_check_interval=minimum_check_interval,
             until_finished=until_finished,
             tasks=tasks,
         )

{pydocket-0.1.1 → pydocket-0.1.3}/src/docket/docket.py

@@ -147,17 +147,17 @@ class Docket:
         self._monitor_strikes_task = asyncio.create_task(self._monitor_strikes())
 
         # Ensure that the stream and worker group exist
-        async with self.redis() as r:
-            try:
+        try:
+            async with self.redis() as r:
                 await r.xgroup_create(
                     groupname=self.worker_group_name,
                     name=self.stream_key,
                     id="0-0",
                     mkstream=True,
                 )
-            except redis.exceptions.RedisError as e:
-                if "BUSYGROUP" not in repr(e):
-                    raise
+        except redis.exceptions.RedisError as e:
+            if "BUSYGROUP" not in repr(e):
+                raise
 
         return self
 
@@ -178,8 +178,18 @@ class Docket:
 
     @asynccontextmanager
     async def redis(self) -> AsyncGenerator[Redis, None]:
-        async with Redis.from_url(self.url) as redis:  # type: ignore
-            yield redis
+        redis: Redis | None = None
+        try:
+            redis = await Redis.from_url(
+                self.url,
+                single_connection_client=True,
+            )
+            async with redis:
+                yield redis
+        finally:
+            # redis 4.6.0 doesn't automatically disconnect and leaves connections open
+            if redis:
+                await redis.connection_pool.disconnect()
 
     def register(self, function: Callable[..., Awaitable[Any]]) -> None:
         from .dependencies import validate_dependencies
@@ -513,7 +523,7 @@ class Docket:
                 )
                 running.append(RunningExecution(execution, worker_name, started))
             else:
-                future.append(execution)
+                future.append(execution)  # pragma: no cover
 
         for message in queued_messages:
             function = self.tasks[message[b"function"].decode()]

{pydocket-0.1.1 → pydocket-0.1.3}/src/docket/worker.py

@@ -67,7 +67,7 @@ class Worker:
         concurrency: int = 10,
         redelivery_timeout: timedelta = timedelta(minutes=5),
         reconnection_delay: timedelta = timedelta(seconds=5),
-        minimum_check_interval: timedelta = timedelta(milliseconds=10),
+        minimum_check_interval: timedelta = timedelta(milliseconds=100),
     ) -> None:
         self.docket = docket
         self.name = name or f"worker:{uuid4()}"
@@ -110,6 +110,7 @@ class Worker:
         concurrency: int = 10,
         redelivery_timeout: timedelta = timedelta(minutes=5),
         reconnection_delay: timedelta = timedelta(seconds=5),
+        minimum_check_interval: timedelta = timedelta(milliseconds=100),
         until_finished: bool = False,
         tasks: list[str] = ["docket.tasks:standard_tasks"],
     ) -> None:
@@ -123,6 +124,7 @@ class Worker:
                 concurrency=concurrency,
                 redelivery_timeout=redelivery_timeout,
                 reconnection_delay=reconnection_delay,
+                minimum_check_interval=minimum_check_interval,
             ) as worker:
                 if until_finished:
                     await worker.run_until_finished()
@@ -170,28 +172,31 @@ class Worker:
                     """
                 local total_work = redis.call('ZCARD', KEYS[1])
                 local due_work = 0
-                local tasks = redis.call('ZRANGEBYSCORE', KEYS[1], 0, ARGV[1])
 
-                for i, key in ipairs(tasks) do
-                    local hash_key = ARGV[2] .. ":" .. key
-                    local task_data = redis.call('HGETALL', hash_key)
-
-                    if #task_data > 0 then
-                        local task = {}
-                        for j = 1, #task_data, 2 do
-                            task[task_data[j]] = task_data[j+1]
+                if total_work > 0 then
+                    local tasks = redis.call('ZRANGEBYSCORE', KEYS[1], 0, ARGV[1])
+
+                    for i, key in ipairs(tasks) do
+                        local hash_key = ARGV[2] .. ":" .. key
+                        local task_data = redis.call('HGETALL', hash_key)
+
+                        if #task_data > 0 then
+                            local task = {}
+                            for j = 1, #task_data, 2 do
+                                task[task_data[j]] = task_data[j+1]
+                            end
+
+                            redis.call('XADD', KEYS[2], '*',
+                                'key', task['key'],
+                                'when', task['when'],
+                                'function', task['function'],
+                                'args', task['args'],
+                                'kwargs', task['kwargs'],
+                                'attempt', task['attempt']
+                            )
+                            redis.call('DEL', hash_key)
+                            due_work = due_work + 1
                         end
-
-                        redis.call('XADD', KEYS[2], '*',
-                            'key', task['key'],
-                            'when', task['when'],
-                            'function', task['function'],
-                            'args', task['args'],
-                            'kwargs', task['kwargs'],
-                            'attempt', task['attempt']
-                        )
-                        redis.call('DEL', hash_key)
-                        due_work = due_work + 1
                     end
                 end
 
@@ -262,7 +267,7 @@ class Worker:
                         )
 
                     redeliveries: RedisMessages
-                    _, redeliveries, _ = await redis.xautoclaim(
+                    _, redeliveries, *_ = await redis.xautoclaim(
                         name=self.docket.stream_key,
                         groupname=self.docket.worker_group_name,
                         consumername=self.name,

{pydocket-0.1.1 → pydocket-0.1.3}/tests/cli/test_snapshot.py

@@ -91,45 +91,6 @@ async def test_snapshot_with_running_tasks(docket: Docket, runner: CliRunner):
         assert "sleep" in result.output
         assert "test-worker" in result.output
 
-        worker_running.cancel()
-        await worker_running
-
-
-async def test_snapshot_with_mixed_tasks(docket: Docket, runner: CliRunner):
-    """Should show both running and scheduled tasks in the snapshot"""
-    heartbeat = timedelta(milliseconds=20)
-    docket.heartbeat_interval = heartbeat
-
-    future = datetime.now(timezone.utc) + timedelta(seconds=5)
-    await docket.add(tasks.trace, when=future)("hi!")
-    for _ in range(5):  # more than the concurrency allows
-        await docket.add(tasks.sleep)(2)
-
-    async with Worker(docket, name="test-worker", concurrency=2) as worker:
-        worker_running = asyncio.create_task(worker.run_until_finished())
-
-        await asyncio.sleep(0.1)
-
-        result = await asyncio.get_running_loop().run_in_executor(
-            None,
-            runner.invoke,
-            app,
-            [
-                "snapshot",
-                "--url",
-                docket.url,
-                "--docket",
-                docket.name,
-            ],
-        )
-        assert result.exit_code == 0, result.output
-
-        assert "1 workers, 2/6 running" in result.output
-        assert "sleep" in result.output
-        assert "test-worker" in result.output
-        assert "trace" in result.output
-
-        worker_running.cancel()
         await worker_running
 
 

{pydocket-0.1.1 → pydocket-0.1.3}/tests/conftest.py

@@ -1,7 +1,9 @@
+import os
 import time
+from contextlib import contextmanager
 from datetime import datetime, timezone
 from functools import partial
-from typing import AsyncGenerator, Callable, Generator, Iterable, cast
+from typing import Any, AsyncGenerator, Callable, Generator, Iterable, cast
 from unittest.mock import AsyncMock
 from uuid import uuid4
 
@@ -9,10 +11,12 @@ import pytest
 import redis.exceptions
 from docker import DockerClient
 from docker.models.containers import Container
-from redis import Redis
+from redis import ConnectionPool, Redis
 
 from docket import Docket, Worker
 
+REDIS_VERSION = os.environ.get("REDIS_VERSION", "7.4")
+
 
 @pytest.fixture
 def now() -> Callable[[], datetime]:
@@ -24,6 +28,19 @@ def redis_port(unused_tcp_port_factory: Callable[[], int]) -> int:
     return unused_tcp_port_factory()
 
 
+@contextmanager
+def _sync_redis(url: str) -> Generator[Redis, None, None]:
+    pool: ConnectionPool | None = None
+    redis = Redis.from_url(url, single_connection_client=True)  # type: ignore
+    try:
+        with redis:
+            pool = redis.connection_pool  # type: ignore
+            yield redis
+    finally:
+        if pool:  # pragma: no branch
+            pool.disconnect()
+
+
 @pytest.fixture(scope="session")
 def redis_server(redis_port: int) -> Generator[Container, None, None]:
     client = DockerClient.from_env()
@@ -39,19 +56,22 @@ def redis_server(redis_port: int) -> Generator[Container, None, None]:
         container.remove(force=True)
 
     container = client.containers.run(
-        "redis:7.4.2",
+        f"redis:{REDIS_VERSION}",
         detach=True,
         ports={"6379/tcp": redis_port},
         labels={"source": "docket-unit-tests"},
         auto_remove=True,
     )
 
+    url = f"redis://localhost:{redis_port}/0"
+
     while True:
         try:
-            with Redis.from_url(f"redis://localhost:{redis_port}/0") as r:  # type: ignore
-                if r.ping():  # type: ignore
+            with _sync_redis(url) as r:
+                success = r.ping()  # type: ignore
+                if success:  # pragma: no branch
                     break
-        except redis.exceptions.ConnectionError:
+        except redis.exceptions.ConnectionError:  # pragma: no cover
             pass
 
         time.sleep(0.1)
@@ -59,15 +79,24 @@ def redis_server(redis_port: int) -> Generator[Container, None, None]:
     try:
         yield container
     finally:
+        with _sync_redis(url) as r:
+            info: dict[str, Any] = r.info()  # type: ignore
+
         container.stop()
 
+        # By the time the test suite finishes, there should have been no more open
+        # Redis connections (just the one that we used to ask about client connections).
+        assert info["connected_clients"] == 1, (
+            f"Expected 1 connected clients, but found {info['connected_clients']}"
+        )
+
 
 @pytest.fixture
 def redis_url(redis_server: Container, redis_port: int) -> str:
-    with Redis.from_url(f"redis://localhost:{redis_port}/0") as r:  # type: ignore
+    url = f"redis://localhost:{redis_port}/0"
+    with _sync_redis(url) as r:
         r.flushdb()  # type: ignore
-
-    return f"redis://localhost:{redis_port}/0"
+    return url
 
 
 @pytest.fixture