pydocket 0.6.0__tar.gz → 0.6.2__tar.gz

{pydocket-0.6.0 → pydocket-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydocket
-Version: 0.6.0
+Version: 0.6.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

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

@@ -16,7 +16,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=str(i))(i)
+        await docket.add(flood, key=f"item-{i}")(i)
 
 
 async def flood(

{pydocket-0.6.0 → pydocket-0.6.2}/pyproject.toml

@@ -64,6 +64,9 @@ source = "vcs"
 [tool.hatch.build.targets.wheel]
 packages = ["src/docket"]
 
+[tool.ruff]
+target-version = "py312"
+
 [tool.pytest.ini_options]
 addopts = [
     "--numprocesses=logical",

{pydocket-0.6.0 → pydocket-0.6.2}/src/docket/__init__.py

@@ -17,6 +17,7 @@ from .dependencies import (
     ExponentialRetry,
     Perpetual,
     Retry,
+    TaskArgument,
     TaskKey,
     TaskLogger,
     Timeout,
@@ -26,19 +27,20 @@ from .execution import Execution
 from .worker import Worker
 
 __all__ = [
-    "Docket",
-    "Worker",
-    "Execution",
+    "__version__",
     "CurrentDocket",
-    "CurrentWorker",
     "CurrentExecution",
-    "TaskKey",
-    "TaskLogger",
-    "Retry",
+    "CurrentWorker",
+    "Depends",
+    "Docket",
+    "Execution",
     "ExponentialRetry",
     "Logged",
     "Perpetual",
+    "Retry",
+    "TaskArgument",
+    "TaskKey",
+    "TaskLogger",
     "Timeout",
-    "Depends",
-    "__version__",
+    "Worker",
 ]

{pydocket-0.6.0 → pydocket-0.6.2}/src/docket/annotations.py

@@ -4,8 +4,14 @@ from typing import Any, Iterable, Mapping, Self
 
 
 class Annotation(abc.ABC):
+    _cache: dict[tuple[type[Self], inspect.Signature], Mapping[str, Self]] = {}
+
     @classmethod
     def annotated_parameters(cls, signature: inspect.Signature) -> Mapping[str, Self]:
+        key = (cls, signature)
+        if key in cls._cache:
+            return cls._cache[key]
+
         annotated: dict[str, Self] = {}
 
         for param_name, param in signature.parameters.items():
@@ -23,6 +29,7 @@ class Annotation(abc.ABC):
                 elif isinstance(arg_type, type) and issubclass(arg_type, cls):
                     annotated[param_name] = arg_type()
 
+        cls._cache[key] = annotated
         return annotated
 
 

{pydocket-0.6.0 → pydocket-0.6.2}/src/docket/cli.py

@@ -245,6 +245,13 @@ def worker(
             envvar="DOCKET_WORKER_SCHEDULING_RESOLUTION",
         ),
     ] = timedelta(milliseconds=250),
+    schedule_automatic_tasks: Annotated[
+        bool,
+        typer.Option(
+            "--schedule-automatic-tasks",
+            help="Schedule automatic tasks",
+        ),
+    ] = True,
     until_finished: Annotated[
         bool,
         typer.Option(
@@ -270,6 +277,7 @@ def worker(
             reconnection_delay=reconnection_delay,
             minimum_check_interval=minimum_check_interval,
             scheduling_resolution=scheduling_resolution,
+            schedule_automatic_tasks=schedule_automatic_tasks,
             until_finished=until_finished,
             metrics_port=metrics_port,
             tasks=tasks,

{pydocket-0.6.0 → pydocket-0.6.2}/src/docket/dependencies.py

@@ -79,6 +79,22 @@ def TaskKey() -> str:
     return cast(str, _TaskKey())
 
 
+class _TaskArgument(Dependency):
+    parameter: str | None
+
+    def __init__(self, parameter: str | None = None) -> None:
+        self.parameter = parameter
+
+    async def __aenter__(self) -> Any:
+        assert self.parameter is not None
+        execution = self.execution.get()
+        return execution.get_argument(self.parameter)
+
+
+def TaskArgument(parameter: str | None = None) -> Any:
+    return cast(Any, _TaskArgument(parameter))
+
+
 class _TaskLogger(Dependency):
     async def __aenter__(self) -> logging.LoggerAdapter[logging.Logger]:
         execution = self.execution.get()
@@ -275,6 +291,11 @@ class _Depends(Dependency, Generic[R]):
         parameters = get_dependency_parameters(function)
 
         for parameter, dependency in parameters.items():
+            # Special case for TaskArguments, they are "magical" and infer the parameter
+            # they refer to from the parameter name (unless otherwise specified)
+            if isinstance(dependency, _TaskArgument) and not dependency.parameter:
+                dependency.parameter = parameter
+
             arguments[parameter] = await stack.enter_async_context(dependency)
 
         return arguments
@@ -338,6 +359,12 @@ def validate_dependencies(function: TaskFunction) -> None:
             )
 
 
+class FailedDependency:
+    def __init__(self, parameter: str, error: Exception) -> None:
+        self.parameter = parameter
+        self.error = error
+
+
 @asynccontextmanager
 async def resolved_dependencies(
     worker: "Worker", execution: Execution
@@ -361,6 +388,19 @@ async def resolved_dependencies(
                 arguments[parameter] = kwargs[parameter]
                 continue
 
-            arguments[parameter] = await stack.enter_async_context(dependency)
+            # Special case for TaskArguments, they are "magical" and infer the parameter
+            # they refer to from the parameter name (unless otherwise specified).  At
+            # the top-level task function call, it doesn't make sense to specify one
+            # _without_ a parameter name, so we'll call that a failed dependency.
+            if isinstance(dependency, _TaskArgument) and not dependency.parameter:
+                arguments[parameter] = FailedDependency(
+                    parameter, ValueError("No parameter name specified")
+                )
+                continue
+
+            try:
+                arguments[parameter] = await stack.enter_async_context(dependency)
+            except Exception as error:
+                arguments[parameter] = FailedDependency(parameter, error)
 
         yield arguments

{pydocket-0.6.0 → pydocket-0.6.2}/src/docket/execution.py

@@ -7,7 +7,7 @@ from typing import Any, Awaitable, Callable, Hashable, Literal, Mapping, Self, c
 
 import cloudpickle  # type: ignore[import]
 
-from opentelemetry import propagate
+from opentelemetry import trace, propagate
 import opentelemetry.context
 
 from .annotations import Logged
@@ -83,13 +83,17 @@ class Execution:
             "docket.attempt": self.attempt,
         }
 
+    def get_argument(self, parameter: str) -> Any:
+        signature = get_signature(self.function)
+        bound_args = signature.bind(*self.args, **self.kwargs)
+        return bound_args.arguments[parameter]
+
     def call_repr(self) -> str:
         arguments: list[str] = []
-        signature = get_signature(self.function)
         function_name = self.function.__name__
 
+        signature = get_signature(self.function)
         logged_parameters = Logged.annotated_parameters(signature)
-
         parameter_names = list(signature.parameters.keys())
 
         for i, argument in enumerate(self.args[: len(parameter_names)]):
@@ -107,6 +111,11 @@ class Execution:
 
         return f"{function_name}({', '.join(arguments)}){{{self.key}}}"
 
+    def incoming_span_links(self) -> list[trace.Link]:
+        initiating_span = trace.get_current_span(self.trace_context)
+        initiating_context = initiating_span.get_span_context()
+        return [trace.Link(initiating_context)] if initiating_context.is_valid else []
+
 
 class Operator(enum.StrEnum):
     EQUAL = "=="

{pydocket-0.6.0 → pydocket-0.6.2}/src/docket/worker.py

@@ -1,6 +1,7 @@
 import asyncio
 import logging
 import sys
+import time
 from datetime import datetime, timedelta, timezone
 from types import TracebackType
 from typing import (
@@ -21,6 +22,7 @@ from docket.execution import get_signature
 
 from .dependencies import (
     Dependency,
+    FailedDependency,
     Perpetual,
     Retry,
     Timeout,
@@ -70,6 +72,7 @@ class Worker:
     reconnection_delay: timedelta
     minimum_check_interval: timedelta
     scheduling_resolution: timedelta
+    schedule_automatic_tasks: bool
 
     def __init__(
         self,
@@ -80,6 +83,7 @@ class Worker:
         reconnection_delay: timedelta = timedelta(seconds=5),
         minimum_check_interval: timedelta = timedelta(milliseconds=250),
         scheduling_resolution: timedelta = timedelta(milliseconds=250),
+        schedule_automatic_tasks: bool = True,
     ) -> None:
         self.docket = docket
         self.name = name or f"worker:{uuid4()}"
@@ -88,6 +92,7 @@ class Worker:
         self.reconnection_delay = reconnection_delay
         self.minimum_check_interval = minimum_check_interval
         self.scheduling_resolution = scheduling_resolution
+        self.schedule_automatic_tasks = schedule_automatic_tasks
 
     async def __aenter__(self) -> Self:
         self._heartbeat_task = asyncio.create_task(self._heartbeat())
@@ -133,6 +138,7 @@ class Worker:
         reconnection_delay: timedelta = timedelta(seconds=5),
         minimum_check_interval: timedelta = timedelta(milliseconds=100),
         scheduling_resolution: timedelta = timedelta(milliseconds=250),
+        schedule_automatic_tasks: bool = True,
         until_finished: bool = False,
         metrics_port: int | None = None,
         tasks: list[str] = ["docket.tasks:standard_tasks"],
@@ -150,6 +156,7 @@ class Worker:
                     reconnection_delay=reconnection_delay,
                     minimum_check_interval=minimum_check_interval,
                     scheduling_resolution=scheduling_resolution,
+                    schedule_automatic_tasks=schedule_automatic_tasks,
                 ) as worker:
                     if until_finished:
                         await worker.run_until_finished()
@@ -219,7 +226,8 @@ class Worker:
     async def _worker_loop(self, redis: Redis, forever: bool = False):
         worker_stopping = asyncio.Event()
 
-        await self._schedule_all_automatic_perpetual_tasks()
+        if self.schedule_automatic_tasks:
+            await self._schedule_all_automatic_perpetual_tasks()
 
         scheduler_task = asyncio.create_task(
             self._scheduler_loop(redis, worker_stopping)
@@ -228,8 +236,10 @@ class Worker:
         active_tasks: dict[asyncio.Task[None], RedisMessageID] = {}
         available_slots = self.concurrency
 
+        log_context = self._log_context()
+
         async def check_for_work() -> bool:
-            logger.debug("Checking for work", extra=self._log_context())
+            logger.debug("Checking for work", extra=log_context)
             async with redis.pipeline() as pipeline:
                 pipeline.xlen(self.docket.stream_key)
                 pipeline.zcard(self.docket.queue_key)
@@ -239,7 +249,7 @@ class Worker:
                 return stream_len > 0 or queue_len > 0
 
         async def get_redeliveries(redis: Redis) -> RedisReadGroupResponse:
-            logger.debug("Getting redeliveries", extra=self._log_context())
+            logger.debug("Getting redeliveries", extra=log_context)
             _, redeliveries, *_ = await redis.xautoclaim(
                 name=self.docket.stream_key,
                 groupname=self.docket.worker_group_name,
@@ -251,7 +261,7 @@ class Worker:
             return [(b"__redelivery__", redeliveries)]
 
         async def get_new_deliveries(redis: Redis) -> RedisReadGroupResponse:
-            logger.debug("Getting new deliveries", extra=self._log_context())
+            logger.debug("Getting new deliveries", extra=log_context)
             return await redis.xreadgroup(
                 groupname=self.docket.worker_group_name,
                 consumername=self.name,
@@ -261,21 +271,18 @@ class Worker:
             )
 
         def start_task(message_id: RedisMessageID, message: RedisMessage) -> bool:
-            if not message:  # pragma: no cover
-                return False
-
             function_name = message[b"function"].decode()
             if not (function := self.docket.tasks.get(function_name)):
                 logger.warning(
                     "Task function %r not found",
                     function_name,
-                    extra=self._log_context(),
+                    extra=log_context,
                 )
                 return False
 
             execution = Execution.from_message(function, message)
 
-            task = asyncio.create_task(self._execute(execution))
+            task = asyncio.create_task(self._execute(execution), name=execution.key)
             active_tasks[task] = message_id
 
             nonlocal available_slots
@@ -283,8 +290,15 @@ class Worker:
 
             return True
 
+        async def process_completed_tasks() -> None:
+            completed_tasks = {task for task in active_tasks if task.done()}
+            for task in completed_tasks:
+                message_id = active_tasks.pop(task)
+                await task
+                await ack_message(redis, message_id)
+
         async def ack_message(redis: Redis, message_id: RedisMessageID) -> None:
-            logger.debug("Acknowledging message", extra=self._log_context())
+            logger.debug("Acknowledging message", extra=log_context)
             async with redis.pipeline() as pipeline:
                 pipeline.xack(
                     self.docket.stream_key,
@@ -297,13 +311,6 @@ class Worker:
                 )
                 await pipeline.execute()
 
-        async def process_completed_tasks() -> None:
-            completed_tasks = {task for task in active_tasks if task.done()}
-            for task in completed_tasks:
-                message_id = active_tasks.pop(task)
-                await task
-                await ack_message(redis, message_id)
-
         has_work: bool = True
 
         try:
@@ -319,6 +326,9 @@ class Worker:
                 for source in [get_redeliveries, get_new_deliveries]:
                     for _, messages in await source(redis):
                         for message_id, message in messages:
+                            if not message:  # pragma: no cover
+                                continue
+
                             if not start_task(message_id, message):
                                 await self._delete_known_task(redis, message)
                                 await ack_message(redis, message_id)
@@ -334,7 +344,7 @@ class Worker:
                 logger.info(
                     "Shutdown requested, finishing %d active tasks...",
                     len(active_tasks),
-                    extra=self._log_context(),
+                    extra=log_context,
                 )
         finally:
             if active_tasks:
@@ -401,9 +411,11 @@ class Worker:
 
         total_work: int = sys.maxsize
 
+        log_context = self._log_context()
+
         while not worker_stopping.is_set() or total_work:
             try:
-                logger.debug("Scheduling due tasks", extra=self._log_context())
+                logger.debug("Scheduling due tasks", extra=log_context)
                 total_work, due_work = await stream_due_tasks(
                     keys=[self.docket.queue_key, self.docket.stream_key],
                     args=[datetime.now(timezone.utc).timestamp(), self.docket.name],
@@ -416,18 +428,18 @@ class Worker:
                         total_work,
                         self.docket.queue_key,
                         self.docket.stream_key,
-                        extra=self._log_context(),
+                        extra=log_context,
                     )
             except Exception:  # pragma: no cover
                 logger.exception(
                     "Error in scheduler loop",
                     exc_info=True,
-                    extra=self._log_context(),
+                    extra=log_context,
                 )
             finally:
                 await asyncio.sleep(self.scheduling_resolution.total_seconds())
 
-        logger.debug("Scheduler loop finished", extra=self._log_context())
+        logger.debug("Scheduler loop finished", extra=log_context)
 
     async def _schedule_all_automatic_perpetual_tasks(self) -> None:
         async with self.docket.redis() as redis:
@@ -469,38 +481,30 @@ class Worker:
         log_context = {**self._log_context(), **execution.specific_labels()}
         counter_labels = {**self.labels(), **execution.general_labels()}
 
-        arrow = "↬" if execution.attempt > 1 else "↪"
         call = execution.call_repr()
 
         if self.docket.strike_list.is_stricken(execution):
             async with self.docket.redis() as redis:
                 await self._delete_known_task(redis, execution)
 
-            arrow = "🗙"
-            logger.warning("%s %s", arrow, call, extra=log_context)
+            logger.warning("🗙 %s", call, extra=log_context)
             TASKS_STRICKEN.add(1, counter_labels | {"docket.where": "worker"})
             return
 
         if execution.key in self._execution_counts:
             self._execution_counts[execution.key] += 1
 
-        initiating_span = trace.get_current_span(execution.trace_context)
-        initiating_context = initiating_span.get_span_context()
-        links = [trace.Link(initiating_context)] if initiating_context.is_valid else []
-
-        start = datetime.now(timezone.utc)
-        punctuality = start - execution.when
-        log_context = {
-            **log_context,
-            "punctuality": punctuality.total_seconds(),
-        }
-        duration = timedelta(0)
+        start = time.time()
+        punctuality = start - execution.when.timestamp()
+        log_context = {**log_context, "punctuality": punctuality}
+        duration = 0.0
 
         TASKS_STARTED.add(1, counter_labels)
         TASKS_RUNNING.add(1, counter_labels)
-        TASK_PUNCTUALITY.record(punctuality.total_seconds(), counter_labels)
+        TASK_PUNCTUALITY.record(punctuality, counter_labels)
 
-        logger.info("%s [%s] %s", arrow, punctuality, call, extra=log_context)
+        arrow = "↬" if execution.attempt > 1 else "↪"
+        logger.info("%s [%s] %s", arrow, ms(punctuality), call, extra=log_context)
 
         with tracer.start_as_current_span(
             execution.function.__name__,
@@ -510,7 +514,7 @@ class Worker:
                 **execution.specific_labels(),
                 "code.function.name": execution.function.__name__,
             },
-            links=links,
+            links=execution.incoming_span_links(),
         ):
             async with resolved_dependencies(self, execution) as dependencies:
                 # Preemptively reschedule the perpetual task for the future, or clear
@@ -523,6 +527,23 @@ class Worker:
                         await self._delete_known_task(redis, execution)
 
                 try:
+                    dependency_failures = {
+                        k: v
+                        for k, v in dependencies.items()
+                        if isinstance(v, FailedDependency)
+                    }
+                    if dependency_failures:
+                        raise ExceptionGroup(
+                            (
+                                "Failed to resolve dependencies for parameter(s): "
+                                + ", ".join(dependency_failures.keys())
+                            ),
+                            [
+                                dependency.error
+                                for dependency in dependency_failures.values()
+                            ],
+                        )
+
                     if timeout := get_single_dependency_of_type(dependencies, Timeout):
                         await self._run_function_with_timeout(
                             execution, dependencies, timeout
@@ -536,31 +557,35 @@ class Worker:
                             },
                         )
 
+                    duration = log_context["duration"] = time.time() - start
                     TASKS_SUCCEEDED.add(1, counter_labels)
-                    duration = datetime.now(timezone.utc) - start
-                    log_context["duration"] = duration.total_seconds()
+
                     rescheduled = await self._perpetuate_if_requested(
-                        execution, dependencies, duration
+                        execution, dependencies, timedelta(seconds=duration)
                     )
+
                     arrow = "↫" if rescheduled else "↩"
-                    logger.info("%s [%s] %s", arrow, duration, call, extra=log_context)
+                    logger.info(
+                        "%s [%s] %s", arrow, ms(duration), call, extra=log_context
+                    )
                 except Exception:
+                    duration = log_context["duration"] = time.time() - start
                     TASKS_FAILED.add(1, counter_labels)
-                    duration = datetime.now(timezone.utc) - start
-                    log_context["duration"] = duration.total_seconds()
+
                     retried = await self._retry_if_requested(execution, dependencies)
                     if not retried:
                         retried = await self._perpetuate_if_requested(
-                            execution, dependencies, duration
+                            execution, dependencies, timedelta(seconds=duration)
                         )
+
                     arrow = "↫" if retried else "↩"
                     logger.exception(
-                        "%s [%s] %s", arrow, duration, call, extra=log_context
+                        "%s [%s] %s", arrow, ms(duration), call, extra=log_context
                     )
                 finally:
                     TASKS_RUNNING.add(-1, counter_labels)
                     TASKS_COMPLETED.add(1, counter_labels)
-                    TASK_DURATION.record(duration.total_seconds(), counter_labels)
+                    TASK_DURATION.record(duration, counter_labels)
 
     async def _run_function_with_timeout(
         self,
@@ -603,15 +628,15 @@ class Worker:
         if not retry:
             return False
 
-        if retry.attempts is None or execution.attempt < retry.attempts:
-            execution.when = datetime.now(timezone.utc) + retry.delay
-            execution.attempt += 1
-            await self.docket.schedule(execution)
+        if retry.attempts is not None and execution.attempt >= retry.attempts:
+            return False
 
-            TASKS_RETRIED.add(1, {**self.labels(), **execution.specific_labels()})
-            return True
+        execution.when = datetime.now(timezone.utc) + retry.delay
+        execution.attempt += 1
+        await self.docket.schedule(execution)
 
-        return False
+        TASKS_RETRIED.add(1, {**self.labels(), **execution.specific_labels()})
+        return True
 
     async def _perpetuate_if_requested(
         self,
@@ -710,3 +735,10 @@ class Worker:
                     exc_info=True,
                     extra=self._log_context(),
                 )
+
+
+def ms(seconds: float) -> str:
+    if seconds < 100:
+        return f"{seconds * 1000:6.0f}ms"
+    else:
+        return f"{seconds:6.0f}s "

{pydocket-0.6.0 → pydocket-0.6.2}/tests/test_dependencies.py

@@ -1,7 +1,9 @@
+import logging
+
 import pytest
 
 from docket import CurrentDocket, CurrentWorker, Docket, Worker
-from docket.dependencies import Retry
+from docket.dependencies import Depends, Retry, TaskArgument
 
 
 async def test_dependencies_may_be_duplicated(docket: Docket, worker: Worker):
@@ -91,3 +93,48 @@ async def test_user_provide_retries_are_used(docket: Docket, worker: Worker):
     await worker.run_until_finished()
 
     assert calls == 2
+
+
+async def test_dependencies_error_for_missing_task_argument(
+    docket: Docket, worker: Worker, caplog: pytest.LogCaptureFixture
+):
+    """A task will fail when asking for a missing task argument"""
+
+    async def dependency_one(nope: list[str] = TaskArgument()) -> list[str]:
+        raise NotImplementedError("This should not be called")  # pragma: no cover
+
+    async def dependent_task(
+        a: list[str],
+        b: list[str] = TaskArgument("a"),
+        c: list[str] = Depends(dependency_one),
+    ) -> None:
+        raise NotImplementedError("This should not be called")  # pragma: no cover
+
+    await docket.add(dependent_task)(a=["hello", "world"])
+
+    await worker.run_until_finished()
+
+    with caplog.at_level(logging.ERROR):
+        await worker.run_until_finished()
+
+    assert "Failed to resolve dependencies for parameter(s): c" in caplog.text
+    assert "ExceptionGroup" in caplog.text
+    assert "KeyError: 'nope'" in caplog.text
+
+
+async def test_a_task_argument_cannot_ask_for_itself(
+    docket: Docket, worker: Worker, caplog: pytest.LogCaptureFixture
+):
+    """A task argument cannot ask for itself"""
+
+    # This task would be nonsense, because it's asking for itself.
+    async def dependent_task(a: list[str] = TaskArgument()) -> None:
+        raise NotImplementedError("This should not be called")  # pragma: no cover
+
+    await docket.add(dependent_task)()
+
+    with caplog.at_level(logging.ERROR):
+        await worker.run_until_finished()
+
+    assert "Failed to resolve dependencies for parameter(s): a" in caplog.text
+    assert "ValueError: No parameter name specified" in caplog.text

{pydocket-0.6.0 → pydocket-0.6.2}/tests/test_fundamentals.py

@@ -27,6 +27,7 @@ from docket import (
     Logged,
     Perpetual,
     Retry,
+    TaskArgument,
     TaskKey,
     TaskLogger,
     Timeout,
@@ -1383,3 +1384,66 @@ async def test_dependencies_can_ask_for_docket_dependencies(
     await docket.add(dependent_task)()
 
     await worker.run_until_finished()
+
+
+async def test_dependency_failures_are_task_failures(
+    docket: Docket, worker: Worker, caplog: pytest.LogCaptureFixture
+):
+    """A task dependency failure will cause the task to fail"""
+
+    called: bool = False
+
+    async def dependency_one() -> str:
+        raise ValueError("this one is bad")
+
+    async def dependency_two() -> str:
+        raise ValueError("and so is this one")
+
+    async def dependent_task(
+        a: str = Depends(dependency_one),
+        b: str = Depends(dependency_two),
+    ) -> None:
+        nonlocal called
+        called = True  # pragma: no cover
+
+    await docket.add(dependent_task)()
+
+    with caplog.at_level(logging.ERROR):
+        await worker.run_until_finished()
+
+    assert not called
+
+    assert "Failed to resolve dependencies for parameter(s): a, b" in caplog.text
+    assert "ValueError: this one is bad" in caplog.text
+    assert "ValueError: and so is this one" in caplog.text
+
+
+async def test_dependencies_can_ask_for_task_arguments(docket: Docket, worker: Worker):
+    """A task dependency can ask for a task argument"""
+
+    called = 0
+
+    async def dependency_one(a: list[str] = TaskArgument()) -> list[str]:
+        return a
+
+    async def dependency_two(another_name: list[str] = TaskArgument("a")) -> list[str]:
+        return another_name
+
+    async def dependent_task(
+        a: list[str],
+        b: list[str] = TaskArgument("a"),
+        c: list[str] = Depends(dependency_one),
+        d: list[str] = Depends(dependency_two),
+    ) -> None:
+        assert a is b
+        assert a is c
+        assert a is d
+
+        nonlocal called
+        called += 1
+
+    await docket.add(dependent_task)(a=["hello", "world"])
+
+    await worker.run_until_finished()
+
+    assert called == 1

{pydocket-0.6.0 → pydocket-0.6.2}/tests/test_worker.py

@@ -13,6 +13,7 @@ from docket import CurrentWorker, Docket, Worker
 from docket.dependencies import CurrentDocket, Perpetual
 from docket.execution import Execution
 from docket.tasks import standard_tasks
+from docket.worker import ms
 
 
 async def test_worker_acknowledges_messages(
@@ -475,3 +476,40 @@ async def test_worker_can_exit_from_long_horizon_perpetual_tasks(
     await worker.run_at_most({"my-key": 1})
 
     assert calls == 1
+
+
+def test_formatting_durations():
+    assert ms(0.000001) == "     0ms"
+    assert ms(0.000010) == "     0ms"
+    assert ms(0.000100) == "     0ms"
+    assert ms(0.001000) == "     1ms"
+    assert ms(0.010000) == "    10ms"
+    assert ms(0.100000) == "   100ms"
+    assert ms(1.000000) == "  1000ms"
+    assert ms(10.00000) == " 10000ms"
+    assert ms(100.0000) == "   100s "
+    assert ms(1000.000) == "  1000s "
+    assert ms(10000.00) == " 10000s "
+    assert ms(100000.0) == "100000s "
+
+
+async def test_worker_can_be_told_to_skip_automatic_tasks(docket: Docket):
+    """A worker can be told to skip automatic tasks"""
+
+    called = False
+
+    async def perpetual_task(
+        perpetual: Perpetual = Perpetual(
+            every=timedelta(milliseconds=50), automatic=True
+        ),
+    ):
+        nonlocal called
+        called = True  # pragma: no cover
+
+    docket.register(perpetual_task)
+
+    # Without the flag, this would hang because the task would always be scheduled
+    async with Worker(docket, schedule_automatic_tasks=False) as worker:
+        await worker.run_until_finished()
+
+    assert not called