pydocket 0.1.0__tar.gz → 0.1.2__tar.gz

pydocket-0.1.0/.cursorrules → pydocket-0.1.2/.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.2/.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.0 → pydocket-0.1.2}/.github/workflows/ci.yml

@@ -7,6 +7,7 @@ on:
     branches: [main]
   workflow_call:
 
+
 jobs:
   test:
     name: Test Python ${{ matrix.python-version }}

{pydocket-0.1.0 → pydocket-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydocket
-Version: 0.1.0
+Version: 0.1.2
 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
@@ -28,7 +28,7 @@ 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>=5.2.1
+Requires-Dist: redis>=4.6
 Requires-Dist: rich>=13.9.4
 Requires-Dist: typer>=0.15.1
 Description-Content-Type: text/markdown

{pydocket-0.1.0 → pydocket-0.1.2}/pyproject.toml

@@ -25,7 +25,7 @@ dependencies = [
     "opentelemetry-exporter-prometheus>=0.51b0",
     "prometheus-client>=0.21.1",
     "python-json-logger>=3.2.1",
-    "redis>=5.2.1",
+    "redis>=4.6",
     "rich>=13.9.4",
     "typer>=0.15.1",
 ]
@@ -68,6 +68,8 @@ 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.0 → pydocket-0.1.2}/src/docket/cli.py

@@ -365,7 +365,7 @@ def restore(
     value_ = interpret_python_value(value)
     if parameter:
         function_name = f"{function or '(all tasks)'}"
-        print(f"Striking {function_name} {parameter} {operator} {value_!r}")
+        print(f"Restoring {function_name} {parameter} {operator} {value_!r}")
     else:
         print(f"Restoring {function}")
 

{pydocket-0.1.0 → pydocket-0.1.2}/src/docket/worker.py

@@ -262,7 +262,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.2/tests/cli/test_module.py

@@ -0,0 +1,22 @@
+import asyncio
+import subprocess
+import sys
+
+import docket
+
+
+async def test_module_invocation_as_cli_entrypoint():
+    """Should allow invoking docket as a module with python -m docket."""
+    process = await asyncio.create_subprocess_exec(
+        sys.executable,
+        "-m",
+        "docket",
+        "version",
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+
+    stdout, stderr = await process.communicate()
+
+    assert process.returncode == 0, stderr.decode()
+    assert stdout.decode().strip() == docket.__version__

{pydocket-0.1.0 → pydocket-0.1.2}/tests/cli/test_snapshot.py

@@ -1,12 +1,12 @@
 import asyncio
-import sys
 from datetime import datetime, timedelta, timezone
 
 import pytest
 from pytest import MonkeyPatch
+from typer.testing import CliRunner
 
 from docket import tasks
-from docket.cli import relative_time
+from docket.cli import app, relative_time
 from docket.docket import Docket
 from docket.worker import Worker
 
@@ -19,105 +19,83 @@ async def empty_docket(docket: Docket):
     await docket.cancel("initial")
 
 
-async def test_snapshot_empty_docket(docket: Docket):
+async def test_snapshot_empty_docket(docket: Docket, runner: CliRunner):
     """Should show an empty snapshot when no tasks are scheduled"""
-    process = await asyncio.create_subprocess_exec(
-        sys.executable,
-        "-m",
-        "docket",
-        "snapshot",
-        "--url",
-        docket.url,
-        "--docket",
-        docket.name,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
+    result = await asyncio.get_running_loop().run_in_executor(
+        None,
+        runner.invoke,
+        app,
+        [
+            "snapshot",
+            "--url",
+            docket.url,
+            "--docket",
+            docket.name,
+        ],
     )
-    await process.wait()
-
-    assert process.stderr
-    stderr = await process.stderr.read()
-    assert process.returncode == 0, stderr.decode()
+    assert result.exit_code == 0, result.output
 
-    assert process.stdout
-    output = await process.stdout.read()
-    output_text = output.decode()
+    assert "0 workers, 0/0 running" in result.output
 
-    assert "0 workers, 0/0 running" in output_text
 
-
-async def test_snapshot_with_scheduled_tasks(docket: Docket):
+async def test_snapshot_with_scheduled_tasks(docket: Docket, runner: CliRunner):
     """Should show scheduled tasks in the snapshot"""
     when = datetime.now(timezone.utc) + timedelta(seconds=5)
     await docket.add(tasks.trace, when=when, key="future-task")("hiya!")
 
-    process = await asyncio.create_subprocess_exec(
-        sys.executable,
-        "-m",
-        "docket",
-        "snapshot",
-        "--url",
-        docket.url,
-        "--docket",
-        docket.name,
-        stdout=asyncio.subprocess.PIPE,
-        stderr=asyncio.subprocess.PIPE,
+    result = await asyncio.get_running_loop().run_in_executor(
+        None,
+        runner.invoke,
+        app,
+        [
+            "snapshot",
+            "--url",
+            docket.url,
+            "--docket",
+            docket.name,
+        ],
     )
-    await process.wait()
+    assert result.exit_code == 0, result.output
 
-    assert process.stderr
-    stderr = await process.stderr.read()
-    assert process.returncode == 0, stderr.decode()
+    assert "0 workers, 0/1 running" in result.output
+    assert "future-task" in result.output
 
-    assert process.stdout
-    output = await process.stdout.read()
-    output_text = output.decode()
 
-    assert "0 workers, 0/1 running" in output_text
-    assert "future-task" in output_text
-
-
-async def test_snapshot_with_running_tasks(docket: Docket):
+async def test_snapshot_with_running_tasks(docket: Docket, runner: CliRunner):
     """Should show running tasks in the snapshot"""
     heartbeat = timedelta(milliseconds=20)
     docket.heartbeat_interval = heartbeat
 
-    await docket.add(tasks.sleep)(2)
+    await docket.add(tasks.sleep)(1)
 
     async with Worker(docket, name="test-worker") as worker:
         worker_running = asyncio.create_task(worker.run_until_finished())
 
-        process = await asyncio.create_subprocess_exec(
-            sys.executable,
-            "-m",
-            "docket",
-            "snapshot",
-            "--url",
-            docket.url,
-            "--docket",
-            docket.name,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
+        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,
+            ],
         )
-        await process.wait()
+        assert result.exit_code == 0, result.output
 
-        assert process.stderr
-        stderr = await process.stderr.read()
-        assert process.returncode == 0, stderr.decode()
-
-        assert process.stdout
-        output = await process.stdout.read()
-        output_text = output.decode()
-
-        assert "1 workers, 1/1 running" in output_text
-        assert "sleep" in output_text
-        assert "test-worker" in output_text
+        assert "1 workers, 1/1 running" in result.output
+        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):
+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
@@ -130,34 +108,26 @@ async def test_snapshot_with_mixed_tasks(docket: Docket):
     async with Worker(docket, name="test-worker", concurrency=2) as worker:
         worker_running = asyncio.create_task(worker.run_until_finished())
 
-        process = await asyncio.create_subprocess_exec(
-            sys.executable,
-            "-m",
-            "docket",
-            "snapshot",
-            "--url",
-            docket.url,
-            "--docket",
-            docket.name,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
+        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,
+            ],
         )
-        await process.wait()
-
-        assert process.stderr
-        stderr = await process.stderr.read()
-        assert process.returncode == 0, stderr.decode()
-
-        assert process.stdout
-        output = await process.stdout.read()
-        output_text = output.decode()
-
-        print(output_text)
+        assert result.exit_code == 0, result.output
 
-        assert "1 workers, 2/6 running" in output_text
-        assert "sleep" in output_text
-        assert "test-worker" in output_text
-        assert "trace" in output_text
+        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.2/tests/cli/test_striking.py

@@ -0,0 +1,232 @@
+import asyncio
+import decimal
+from datetime import timedelta
+from typing import Any
+from uuid import UUID, uuid4
+
+import pytest
+from typer.testing import CliRunner
+
+from docket.cli import app, interpret_python_value
+from docket.docket import Docket
+
+
+async def test_strike(runner: CliRunner, redis_url: str):
+    """Should strike a task"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                "strike",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "example_task",
+                "some_parameter",
+                "==",
+                "some_value",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+
+        assert "Striking example_task some_parameter == 'some_value'" in result.output
+
+        await asyncio.sleep(0.25)
+
+        assert "example_task" in docket.strike_list.task_strikes
+
+
+async def test_restore(runner: CliRunner, redis_url: str):
+    """Should restore a task"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        await docket.strike("example_task", "some_parameter", "==", "some_value")
+        assert "example_task" in docket.strike_list.task_strikes
+
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                "restore",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "example_task",
+                "some_parameter",
+                "==",
+                "some_value",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+
+        assert "Restoring example_task some_parameter == 'some_value'" in result.output
+
+        await asyncio.sleep(0.25)
+
+        assert "example_task" not in docket.strike_list.task_strikes
+
+
+async def test_task_only_strike(runner: CliRunner, redis_url: str):
+    """Should strike a task without specifying parameter conditions"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                "strike",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "example_task",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "Striking example_task" in result.output
+
+        await asyncio.sleep(0.25)
+
+        assert "example_task" in docket.strike_list.task_strikes
+
+
+async def test_task_only_restore(runner: CliRunner, redis_url: str):
+    """Should restore a task without specifying parameter conditions"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        await docket.strike("example_task")
+
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                "restore",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "example_task",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "Restoring example_task" in result.output
+
+        await asyncio.sleep(0.25)
+
+        assert "example_task" not in docket.strike_list.task_strikes
+
+
+async def test_parameter_only_strike(runner: CliRunner, redis_url: str):
+    """Should strike tasks with matching parameter conditions regardless of task name"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                "strike",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "",
+                "some_parameter",
+                "==",
+                "some_value",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "Striking (all tasks) some_parameter == 'some_value'" in result.output
+
+        await asyncio.sleep(0.25)
+
+        assert "some_parameter" in docket.strike_list.parameter_strikes
+        parameter_strikes = docket.strike_list.parameter_strikes["some_parameter"]
+        assert ("==", "some_value") in parameter_strikes
+
+
+async def test_parameter_only_restore(runner: CliRunner, redis_url: str):
+    """Should restore tasks with matching parameter conditions regardless of task
+    name"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        await docket.strike("", "some_parameter", "==", "some_value")
+
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                "restore",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "",
+                "some_parameter",
+                "==",
+                "some_value",
+            ],
+        )
+
+        assert result.exit_code == 0, result.output
+        assert "Restoring (all tasks) some_parameter == 'some_value'" in result.output
+
+        await asyncio.sleep(0.25)
+
+        assert "some_parameter" not in docket.strike_list.parameter_strikes
+
+
+@pytest.mark.parametrize("operation", ["strike", "restore"])
+async def test_strike_with_no_function_or_parameter(
+    runner: CliRunner, redis_url: str, operation: str
+):
+    """Should fail when neither function nor parameter is provided"""
+    async with Docket(name=f"test-docket-{uuid4()}", url=redis_url) as docket:
+        result = await asyncio.get_running_loop().run_in_executor(
+            None,
+            runner.invoke,
+            app,
+            [
+                operation,
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "",
+            ],
+        )
+
+        assert result.exit_code != 0, result.output
+
+
+@pytest.mark.parametrize(
+    "input_value,expected_result",
+    [
+        (None, None),
+        ("hello", "hello"),
+        ("int:42", 42),
+        ("float:3.14", 3.14),
+        ("decimal.Decimal:3.14", decimal.Decimal("3.14")),
+        ("bool:True", True),
+        ("bool:False", False),
+        ("datetime.timedelta:10", timedelta(seconds=10)),
+        (
+            "uuid.UUID:123e4567-e89b-12d3-a456-426614174000",
+            UUID("123e4567-e89b-12d3-a456-426614174000"),
+        ),
+    ],
+)
+async def test_interpret_python_value(input_value: str | None, expected_result: Any):
+    """Should interpret Python values correctly from strings"""
+    result = interpret_python_value(input_value)
+    assert result == expected_result