pydocket 0.1.0__tar.gz → 0.1.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydocket
-Version: 0.1.0
+Version: 0.1.1
 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.1}/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",
 ]

{pydocket-0.1.0 → pydocket-0.1.1}/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.1/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.1}/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.1/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

pydocket-0.1.1/tests/cli/test_worker.py

@@ -0,0 +1,179 @@
+import asyncio
+import inspect
+import json
+import logging
+from datetime import datetime, timezone
+from functools import partial
+
+import pytest
+from typer.testing import CliRunner
+
+from docket.cli import app
+from docket.docket import Docket
+from docket.tasks import trace
+from docket.worker import Worker
+
+
+@pytest.fixture(autouse=True)
+def reset_logging() -> None:
+    logging.basicConfig(force=True)
+
+
+def test_worker_command_exposes_all_the_options_of_worker():
+    """Should expose all the options of Worker.run in the CLI command"""
+    from docket.cli import worker as worker_cli_command
+
+    cli_signature = inspect.signature(worker_cli_command)
+    worker_run_signature = inspect.signature(Worker.run)
+
+    cli_params = {
+        name: (param.default, param.annotation)
+        for name, param in cli_signature.parameters.items()
+    }
+
+    # Remove CLI-only parameters
+    cli_params.pop("logging_level")
+
+    worker_params = {
+        name: (param.default, param.annotation)
+        for name, param in worker_run_signature.parameters.items()
+    }
+
+    for name, (default, _) in worker_params.items():
+        cli_name = name if name != "docket_name" else "docket_"
+
+        assert cli_name in cli_params, f"Parameter {name} missing from CLI"
+
+        cli_default, _ = cli_params[cli_name]
+
+        if name == "name":
+            # Skip hostname check for the 'name' parameter as it's machine-specific
+            continue
+
+        assert cli_default == default, (
+            f"Default for {name} doesn't match: CLI={cli_default}, Worker.run={default}"
+        )
+
+
+def test_worker_command(
+    runner: CliRunner,
+    docket: Docket,
+):
+    """Should run a worker until there are no more tasks to process"""
+    result = runner.invoke(
+        app,
+        [
+            "worker",
+            "--until-finished",
+            "--url",
+            docket.url,
+            "--docket",
+            docket.name,
+        ],
+        color=True,
+    )
+    assert result.exit_code == 0
+
+    assert "Starting worker" in result.output
+    assert "trace" in result.output
+
+
+async def test_rich_logging_format(runner: CliRunner, docket: Docket):
+    """Should use rich formatting for logs by default"""
+    await docket.add(trace)("hello")
+
+    logging.basicConfig(force=True)
+
+    result = await asyncio.get_running_loop().run_in_executor(
+        None,
+        partial(
+            runner.invoke,
+            app,
+            [
+                "worker",
+                "--until-finished",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "--logging-format",
+                "rich",
+            ],
+            color=True,
+        ),
+    )
+
+    assert result.exit_code == 0, result.output
+
+    assert "Starting worker" in result.output
+    assert "trace" in result.output
+
+
+async def test_plain_logging_format(runner: CliRunner, docket: Docket):
+    """Should use plain formatting for logs when specified"""
+    await docket.add(trace)("hello")
+
+    result = await asyncio.get_running_loop().run_in_executor(
+        None,
+        partial(
+            runner.invoke,
+            app,
+            [
+                "worker",
+                "--until-finished",
+                "--url",
+                docket.url,
+                "--docket",
+                docket.name,
+                "--logging-format",
+                "plain",
+            ],
+            color=True,
+        ),
+    )
+
+    assert result.exit_code == 0, result.output
+
+    assert "Starting worker" in result.output
+    assert "trace" in result.output
+
+
+async def test_json_logging_format(runner: CliRunner, docket: Docket):
+    """Should use JSON formatting for logs when specified"""
+    await docket.add(trace)("hello")
+
+    start = datetime.now(timezone.utc)
+
+    result = await asyncio.get_running_loop().run_in_executor(
+        None,
+        runner.invoke,
+        app,
+        [
+            "worker",
+            "--until-finished",
+            "--url",
+            docket.url,
+            "--docket",
+            docket.name,
+            "--logging-format",
+            "json",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+
+    # All output lines should be valid JSON
+    for line in result.output.strip().split("\n"):
+        parsed: dict[str, str] = json.loads(line)
+
+        assert isinstance(parsed, dict)
+
+        assert parsed["name"].startswith("docket.")
+        assert parsed["levelname"] in ("INFO", "WARNING", "ERROR", "CRITICAL")
+        assert "message" in parsed
+        assert "exc_info" in parsed
+
+        timestamp = datetime.strptime(parsed["asctime"], "%Y-%m-%d %H:%M:%S,%f")
+        timestamp = timestamp.astimezone()
+        assert timestamp >= start
+        assert timestamp.tzinfo is not None