pydocket 0.10.0__py3-none-any.whl → 0.11.1__py3-none-any.whl

docket/__init__.py

@@ -8,6 +8,7 @@ from importlib.metadata import version
 
 __version__ = version("pydocket")
 
+from .agenda import Agenda
 from .annotations import Logged
 from .dependencies import (
     ConcurrencyLimit,
@@ -29,6 +30,7 @@ from .worker import Worker
 
 __all__ = [
     "__version__",
+    "Agenda",
     "ConcurrencyLimit",
     "CurrentDocket",
     "CurrentExecution",

docket/agenda.py

@@ -0,0 +1,201 @@
+"""
+Agenda - A collection of tasks that can be scheduled together.
+
+The Agenda class provides a way to collect multiple tasks and then scatter them
+evenly over a time period to avoid overwhelming the system with immediate work.
+"""
+
+import random
+from datetime import datetime, timedelta, timezone
+from typing import Any, Awaitable, Callable, Iterator, ParamSpec, TypeVar, overload
+
+from uuid_extensions import uuid7
+
+from .docket import Docket
+from .execution import Execution, TaskFunction
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class Agenda:
+    """A collection of tasks to be scheduled together on a Docket.
+
+    The Agenda allows you to build up a collection of tasks with their arguments,
+    then schedule them all at once using various timing strategies like scattering.
+
+    Example:
+        >>> agenda = Agenda()
+        >>> agenda.add(process_item)(item1)
+        >>> agenda.add(process_item)(item2)
+        >>> agenda.add(send_email)(email)
+        >>> await agenda.scatter(docket, over=timedelta(minutes=50))
+    """
+
+    def __init__(self) -> None:
+        """Initialize an empty Agenda."""
+        self._tasks: list[
+            tuple[TaskFunction | str, tuple[Any, ...], dict[str, Any]]
+        ] = []
+
+    def __len__(self) -> int:
+        """Return the number of tasks in the agenda."""
+        return len(self._tasks)
+
+    def __iter__(
+        self,
+    ) -> Iterator[tuple[TaskFunction | str, tuple[Any, ...], dict[str, Any]]]:
+        """Iterate over tasks in the agenda."""
+        return iter(self._tasks)
+
+    @overload
+    def add(
+        self,
+        function: Callable[P, Awaitable[R]],
+    ) -> Callable[P, None]:
+        """Add a task function to the agenda.
+
+        Args:
+            function: The task function to add.
+
+        Returns:
+            A callable that accepts the task arguments.
+        """
+
+    @overload
+    def add(
+        self,
+        function: str,
+    ) -> Callable[..., None]:
+        """Add a task by name to the agenda.
+
+        Args:
+            function: The name of a registered task.
+
+        Returns:
+            A callable that accepts the task arguments.
+        """
+
+    def add(
+        self,
+        function: Callable[P, Awaitable[R]] | str,
+    ) -> Callable[..., None]:
+        """Add a task to the agenda.
+
+        Args:
+            function: The task function or name to add.
+
+        Returns:
+            A callable that accepts the task arguments and adds them to the agenda.
+        """
+
+        def scheduler(*args: Any, **kwargs: Any) -> None:
+            self._tasks.append((function, args, kwargs))
+
+        return scheduler
+
+    def clear(self) -> None:
+        """Clear all tasks from the agenda."""
+        self._tasks.clear()
+
+    async def scatter(
+        self,
+        docket: Docket,
+        over: timedelta,
+        start: datetime | None = None,
+        jitter: timedelta | None = None,
+    ) -> list[Execution]:
+        """Scatter the tasks in this agenda over a time period.
+
+        Tasks are distributed evenly across the specified time window,
+        optionally with random jitter to prevent thundering herd effects.
+
+        If an error occurs during scheduling, some tasks may have already been
+        scheduled successfully before the failure occurred.
+
+        Args:
+            docket: The Docket to schedule tasks on.
+            over: Time period to scatter tasks over (required).
+            start: When to start scattering from. Defaults to now.
+            jitter: Maximum random offset to add/subtract from each scheduled time.
+
+        Returns:
+            List of Execution objects for the scheduled tasks.
+
+        Raises:
+            KeyError: If any task name is not registered with the docket.
+            ValueError: If any task is stricken or 'over' is not positive.
+        """
+        if over.total_seconds() <= 0:
+            raise ValueError("'over' parameter must be a positive duration")
+
+        if not self._tasks:
+            return []
+
+        if start is None:
+            start = datetime.now(timezone.utc)
+
+        # Calculate even distribution over the time period
+        task_count = len(self._tasks)
+
+        if task_count == 1:
+            # Single task goes in the middle of the window
+            schedule_times = [start + over / 2]
+        else:
+            # Distribute tasks evenly across the window
+            # For n tasks, we want n points from start to start+over inclusive
+            interval = over / (task_count - 1)
+            schedule_times = [start + interval * i for i in range(task_count)]
+
+        # Apply jitter if specified
+        if jitter:
+            jittered_times: list[datetime] = []
+            for schedule_time in schedule_times:
+                # Random offset between -jitter and +jitter
+                offset = timedelta(
+                    seconds=random.uniform(
+                        -jitter.total_seconds(), jitter.total_seconds()
+                    )
+                )
+                # Ensure the jittered time doesn't go before start
+                jittered_time = max(schedule_time + offset, start)
+                jittered_times.append(jittered_time)
+            schedule_times = jittered_times
+
+        # Build all Execution objects first, validating as we go
+        executions: list[Execution] = []
+        for (task_func, args, kwargs), schedule_time in zip(
+            self._tasks, schedule_times
+        ):
+            # Resolve task function if given by name
+            if isinstance(task_func, str):
+                if task_func not in docket.tasks:
+                    raise KeyError(f"Task '{task_func}' is not registered")
+                resolved_func = docket.tasks[task_func]
+            else:
+                # Ensure task is registered
+                if task_func not in docket.tasks.values():
+                    docket.register(task_func)
+                resolved_func = task_func
+
+            # Create execution with unique key
+            key = str(uuid7())
+            execution = Execution(
+                function=resolved_func,
+                args=args,
+                kwargs=kwargs,
+                when=schedule_time,
+                key=key,
+                attempt=1,
+            )
+            executions.append(execution)
+
+        # Schedule all tasks - if any fail, some tasks may have been scheduled
+        for execution in executions:
+            scheduler = docket.add(
+                execution.function, when=execution.when, key=execution.key
+            )
+            # Actually schedule the task - if this fails, earlier tasks remain scheduled
+            await scheduler(*execution.args, **execution.kwargs)
+
+        return executions

docket/docket.py

@@ -16,6 +16,7 @@ from typing import (
     Mapping,
     NoReturn,
     ParamSpec,
+    Protocol,
     Self,
     Sequence,
     TypedDict,
@@ -27,7 +28,6 @@ from typing import (
 import redis.exceptions
 from opentelemetry import propagate, trace
 from redis.asyncio import ConnectionPool, Redis
-from redis.asyncio.client import Pipeline
 from uuid_extensions import uuid7
 
 from .execution import (
@@ -55,6 +55,18 @@ logger: logging.Logger = logging.getLogger(__name__)
 tracer: trace.Tracer = trace.get_tracer(__name__)
 
 
+class _schedule_task(Protocol):
+    async def __call__(
+        self, keys: list[str], args: list[str | float | bytes]
+    ) -> str: ...  # pragma: no cover
+
+
+class _cancel_task(Protocol):
+    async def __call__(
+        self, keys: list[str], args: list[str]
+    ) -> str: ...  # pragma: no cover
+
+
 P = ParamSpec("P")
 R = TypeVar("R")
 
@@ -131,6 +143,8 @@ class Docket:
 
     _monitor_strikes_task: asyncio.Task[None]
     _connection_pool: ConnectionPool
+    _schedule_task_script: _schedule_task | None
+    _cancel_task_script: _cancel_task | None
 
     def __init__(
         self,
@@ -156,6 +170,8 @@ class Docket:
         self.url = url
         self.heartbeat_interval = heartbeat_interval
         self.missed_heartbeats = missed_heartbeats
+        self._schedule_task_script = None
+        self._cancel_task_script = None
 
     @property
     def worker_group_name(self) -> str:
@@ -300,9 +316,7 @@ class Docket:
             execution = Execution(function, args, kwargs, when, key, attempt=1)
 
             async with self.redis() as redis:
-                async with redis.pipeline() as pipeline:
-                    await self._schedule(redis, pipeline, execution, replace=False)
-                    await pipeline.execute()
+                await self._schedule(redis, execution, replace=False)
 
             TASKS_ADDED.add(1, {**self.labels(), **execution.general_labels()})
             TASKS_SCHEDULED.add(1, {**self.labels(), **execution.general_labels()})
@@ -361,9 +375,7 @@ class Docket:
             execution = Execution(function, args, kwargs, when, key, attempt=1)
 
             async with self.redis() as redis:
-                async with redis.pipeline() as pipeline:
-                    await self._schedule(redis, pipeline, execution, replace=True)
-                    await pipeline.execute()
+                await self._schedule(redis, execution, replace=True)
 
             TASKS_REPLACED.add(1, {**self.labels(), **execution.general_labels()})
             TASKS_CANCELLED.add(1, {**self.labels(), **execution.general_labels()})
@@ -383,9 +395,7 @@ class Docket:
             },
         ):
             async with self.redis() as redis:
-                async with redis.pipeline() as pipeline:
-                    await self._schedule(redis, pipeline, execution, replace=False)
-                    await pipeline.execute()
+                await self._schedule(redis, execution, replace=False)
 
         TASKS_SCHEDULED.add(1, {**self.labels(), **execution.general_labels()})
 
@@ -400,9 +410,7 @@ class Docket:
             attributes={**self.labels(), "docket.key": key},
         ):
             async with self.redis() as redis:
-                async with redis.pipeline() as pipeline:
-                    await self._cancel(pipeline, key)
-                    await pipeline.execute()
+                await self._cancel(redis, key)
 
         TASKS_CANCELLED.add(1, self.labels())
 
@@ -420,13 +428,23 @@ class Docket:
     def parked_task_key(self, key: str) -> str:
         return f"{self.name}:{key}"
 
+    def stream_id_key(self, key: str) -> str:
+        return f"{self.name}:stream-id:{key}"
+
     async def _schedule(
         self,
         redis: Redis,
-        pipeline: Pipeline,
         execution: Execution,
         replace: bool = False,
     ) -> None:
+        """Schedule a task atomically.
+
+        Handles:
+        - Checking for task existence
+        - Cancelling existing tasks when replacing
+        - Adding tasks to stream (immediate) or queue (future)
+        - Tracking stream message IDs for later cancellation
+        """
         if self.strike_list.is_stricken(execution):
             logger.warning(
                 "%r is stricken, skipping schedule of %r",
@@ -437,7 +455,7 @@ class Docket:
                 1,
                 {
                     **self.labels(),
-                    **execution.specific_labels(),
+                    **execution.general_labels(),
                     "docket.where": "docket",
                 },
             )
@@ -449,32 +467,138 @@ class Docket:
         key = execution.key
         when = execution.when
         known_task_key = self.known_task_key(key)
+        is_immediate = when <= datetime.now(timezone.utc)
 
+        # Lock per task key to prevent race conditions between concurrent operations
         async with redis.lock(f"{known_task_key}:lock", timeout=10):
-            if replace:
-                await self._cancel(pipeline, key)
-            else:
-                # if the task is already in the queue or stream, retain it
-                if await redis.exists(known_task_key):
-                    logger.debug(
-                        "Task %r is already in the queue or stream, not scheduling",
-                        key,
-                        extra=self.labels(),
-                    )
-                    return
+            if self._schedule_task_script is None:
+                self._schedule_task_script = cast(
+                    _schedule_task,
+                    redis.register_script(
+                        # KEYS: stream_key, known_key, parked_key, queue_key, stream_id_key
+                        # ARGV: task_key, when_timestamp, is_immediate, replace, ...message_fields
+                        """
+                        local stream_key = KEYS[1]
+                        local known_key = KEYS[2]
+                        local parked_key = KEYS[3]
+                        local queue_key = KEYS[4]
+                        local stream_id_key = KEYS[5]
+
+                        local task_key = ARGV[1]
+                        local when_timestamp = ARGV[2]
+                        local is_immediate = ARGV[3] == '1'
+                        local replace = ARGV[4] == '1'
+
+                        -- Extract message fields from ARGV[5] onwards
+                        local message = {}
+                        for i = 5, #ARGV, 2 do
+                            message[#message + 1] = ARGV[i]     -- field name
+                            message[#message + 1] = ARGV[i + 1] -- field value
+                        end
+
+                        -- Handle replacement: cancel existing task if needed
+                        if replace then
+                            local existing_message_id = redis.call('GET', stream_id_key)
+                            if existing_message_id then
+                                redis.call('XDEL', stream_key, existing_message_id)
+                            end
+                            redis.call('DEL', known_key, parked_key, stream_id_key)
+                            redis.call('ZREM', queue_key, task_key)
+                        else
+                            -- Check if task already exists
+                            if redis.call('EXISTS', known_key) == 1 then
+                                return 'EXISTS'
+                            end
+                        end
+
+                        if is_immediate then
+                            -- Add to stream and store message ID for later cancellation
+                            local message_id = redis.call('XADD', stream_key, '*', unpack(message))
+                            redis.call('SET', known_key, when_timestamp)
+                            redis.call('SET', stream_id_key, message_id)
+                            return message_id
+                        else
+                            -- Add to queue with task data in parked hash
+                            redis.call('SET', known_key, when_timestamp)
+                            redis.call('HSET', parked_key, unpack(message))
+                            redis.call('ZADD', queue_key, when_timestamp, task_key)
+                            return 'QUEUED'
+                        end
+                        """
+                    ),
+                )
+            schedule_task = self._schedule_task_script
 
-            pipeline.set(known_task_key, when.timestamp())
+            await schedule_task(
+                keys=[
+                    self.stream_key,
+                    known_task_key,
+                    self.parked_task_key(key),
+                    self.queue_key,
+                    self.stream_id_key(key),
+                ],
+                args=[
+                    key,
+                    str(when.timestamp()),
+                    "1" if is_immediate else "0",
+                    "1" if replace else "0",
+                    *[
+                        item
+                        for field, value in message.items()
+                        for item in (field, value)
+                    ],
+                ],
+            )
 
-            if when <= datetime.now(timezone.utc):
-                pipeline.xadd(self.stream_key, message)  # type: ignore[arg-type]
-            else:
-                pipeline.hset(self.parked_task_key(key), mapping=message)  # type: ignore[arg-type]
-                pipeline.zadd(self.queue_key, {key: when.timestamp()})
+    async def _cancel(self, redis: Redis, key: str) -> None:
+        """Cancel a task atomically.
 
-    async def _cancel(self, pipeline: Pipeline, key: str) -> None:
-        pipeline.delete(self.known_task_key(key))
-        pipeline.delete(self.parked_task_key(key))
-        pipeline.zrem(self.queue_key, key)
+        Handles cancellation regardless of task location:
+        - From the stream (using stored message ID)
+        - From the queue (scheduled tasks)
+        - Cleans up all associated metadata keys
+        """
+        if self._cancel_task_script is None:
+            self._cancel_task_script = cast(
+                _cancel_task,
+                redis.register_script(
+                    # KEYS: stream_key, known_key, parked_key, queue_key, stream_id_key
+                    # ARGV: task_key
+                    """
+                    local stream_key = KEYS[1]
+                    local known_key = KEYS[2]
+                    local parked_key = KEYS[3]
+                    local queue_key = KEYS[4]
+                    local stream_id_key = KEYS[5]
+                    local task_key = ARGV[1]
+
+                    -- Delete from stream if message ID exists
+                    local message_id = redis.call('GET', stream_id_key)
+                    if message_id then
+                        redis.call('XDEL', stream_key, message_id)
+                    end
+
+                    -- Clean up all task-related keys
+                    redis.call('DEL', known_key, parked_key, stream_id_key)
+                    redis.call('ZREM', queue_key, task_key)
+
+                    return 'OK'
+                    """
+                ),
+            )
+        cancel_task = self._cancel_task_script
+
+        # Execute the cancellation script
+        await cancel_task(
+            keys=[
+                self.stream_key,
+                self.known_task_key(key),
+                self.parked_task_key(key),
+                self.queue_key,
+                self.stream_id_key(key),
+            ],
+            args=[key],
+        )
 
     @property
     def strike_key(self) -> str:
@@ -781,6 +905,7 @@ class Docket:
                         key = key_bytes.decode()
                         pipeline.delete(self.parked_task_key(key))
                         pipeline.delete(self.known_task_key(key))
+                        pipeline.delete(self.stream_id_key(key))
 
                     await pipeline.execute()
 

docket/execution.py

@@ -51,6 +51,7 @@ class Execution:
         key: str,
         attempt: int,
         trace_context: opentelemetry.context.Context | None = None,
+        redelivered: bool = False,
     ) -> None:
         self.function = function
         self.args = args
@@ -59,6 +60,7 @@ class Execution:
         self.key = key
         self.attempt = attempt
         self.trace_context = trace_context
+        self.redelivered = redelivered
 
     def as_message(self) -> Message:
         return {
@@ -80,6 +82,7 @@ class Execution:
             key=message[b"key"].decode(),
             attempt=int(message[b"attempt"].decode()),
             trace_context=propagate.extract(message, getter=message_getter),
+            redelivered=False,  # Default to False, will be set to True in worker if it's a redelivery
         )
 
     def general_labels(self) -> Mapping[str, str]:

docket/instrumentation.py

@@ -40,6 +40,12 @@ TASKS_STARTED = meter.create_counter(
     unit="1",
 )
 
+TASKS_REDELIVERED = meter.create_counter(
+    "docket_tasks_redelivered",
+    description="How many tasks started that were redelivered from another worker",
+    unit="1",
+)
+
 TASKS_STRICKEN = meter.create_counter(
     "docket_tasks_stricken",
     description="How many tasks have been stricken from executing",

docket/worker.py

@@ -47,6 +47,7 @@ from .instrumentation import (
     TASKS_COMPLETED,
     TASKS_FAILED,
     TASKS_PERPETUATED,
+    TASKS_REDELIVERED,
     TASKS_RETRIED,
     TASKS_RUNNING,
     TASKS_STARTED,
@@ -286,7 +287,11 @@ class Worker:
                 count=available_slots,
             )
 
-        def start_task(message_id: RedisMessageID, message: RedisMessage) -> bool:
+        def start_task(
+            message_id: RedisMessageID,
+            message: RedisMessage,
+            is_redelivery: bool = False,
+        ) -> bool:
             function_name = message[b"function"].decode()
             if not (function := self.docket.tasks.get(function_name)):
                 logger.warning(
@@ -297,6 +302,7 @@ class Worker:
                 return False
 
             execution = Execution.from_message(function, message)
+            execution.redelivered = is_redelivery
 
             task = asyncio.create_task(self._execute(execution), name=execution.key)
             active_tasks[task] = message_id
@@ -342,12 +348,15 @@ class Worker:
                     continue
 
                 for source in [get_redeliveries, get_new_deliveries]:
-                    for _, messages in await source(redis):
+                    for stream_key, messages in await source(redis):
+                        is_redelivery = stream_key == b"__redelivery__"
                         for message_id, message in messages:
                             if not message:  # pragma: no cover
                                 continue
 
-                            task_started = start_task(message_id, message)
+                            task_started = start_task(
+                                message_id, message, is_redelivery
+                            )
                             if not task_started:
                                 # Other errors - delete and ack
                                 await self._delete_known_task(redis, message)
@@ -495,7 +504,8 @@ class Worker:
 
         logger.debug("Deleting known task", extra=self._log_context())
         known_task_key = self.docket.known_task_key(key)
-        await redis.delete(known_task_key)
+        stream_id_key = self.docket.stream_id_key(key)
+        await redis.delete(known_task_key, stream_id_key)
 
     async def _execute(self, execution: Execution) -> None:
         log_context = {**self._log_context(), **execution.specific_labels()}
@@ -520,6 +530,8 @@ class Worker:
         duration = 0.0
 
         TASKS_STARTED.add(1, counter_labels)
+        if execution.redelivered:
+            TASKS_REDELIVERED.add(1, counter_labels)
         TASKS_RUNNING.add(1, counter_labels)
         TASK_PUNCTUALITY.record(punctuality, counter_labels)
 
@@ -720,7 +732,7 @@ class Worker:
         execution.attempt += 1
         await self.docket.schedule(execution)
 
-        TASKS_RETRIED.add(1, {**self.labels(), **execution.specific_labels()})
+        TASKS_RETRIED.add(1, {**self.labels(), **execution.general_labels()})
         return True
 
     async def _perpetuate_if_requested(
@@ -746,7 +758,7 @@ class Worker:
         )
 
         if duration is not None:
-            TASKS_PERPETUATED.add(1, {**self.labels(), **execution.specific_labels()})
+            TASKS_PERPETUATED.add(1, {**self.labels(), **execution.general_labels()})
 
         return True
 

{pydocket-0.10.0.dist-info → pydocket-0.11.1.dist-info}/METADATA

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

pydocket-0.11.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+docket/__init__.py,sha256=ChJS2JRyruj22Vi504eXrmQNPQ97L_Sj52OJCuhjoeM,956
+docket/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
+docket/agenda.py,sha256=RqrVkCuWAvwn_q6graCU-lLRQltbJ0QQheJ34T-Gjck,6667
+docket/annotations.py,sha256=wttix9UOeMFMAWXAIJUfUw5GjESJZsACb4YXJCozP7Q,2348
+docket/cli.py,sha256=rTfri2--u4Q5PlXyh7Ub_F5uh3-TtZOWLUp9WY_TvAE,25750
+docket/dependencies.py,sha256=BC0bnt10cr9_S1p5JAP_bnC9RwZkTr9ulPBrxC7eZnA,20247
+docket/docket.py,sha256=NWyulaZYfcNeaqZSJMG54bHqTC5gVggzYFHjpTTY90A,31240
+docket/execution.py,sha256=Lqzgj5EO3v5OD0w__5qBut7WnlEcHZfAYj-BYRdiJf8,15138
+docket/instrumentation.py,sha256=zLYgtuXbNOcotcSlD9pgLVdNp2rPddyxj9JwM3K19Go,5667
+docket/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docket/tasks.py,sha256=RIlSM2omh-YDwVnCz6M5MtmK8T_m_s1w2OlRRxDUs6A,1437
+docket/worker.py,sha256=P4j9uHXt5KcU5e9S4SmQ9v6OCRFMLjYwbMR9PeRvVXc,35390
+pydocket-0.11.1.dist-info/METADATA,sha256=zl27q0Qf9js2bjyDHEjVWighIGWd4me36FLqY3yt5MI,5419
+pydocket-0.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydocket-0.11.1.dist-info/entry_points.txt,sha256=4WOk1nUlBsUT5O3RyMci2ImuC5XFswuopElYcLHtD5k,47
+pydocket-0.11.1.dist-info/licenses/LICENSE,sha256=YuVWU_ZXO0K_k2FG8xWKe5RGxV24AhJKTvQmKfqXuyk,1087
+pydocket-0.11.1.dist-info/RECORD,,

pydocket-0.10.0.dist-info/RECORD

@@ -1,16 +0,0 @@
-docket/__init__.py,sha256=onwZzh73tESWoFBukbcW-7gjxoXb-yI7dutRD7tPN6g,915
-docket/__main__.py,sha256=wcCrL4PjG51r5wVKqJhcoJPTLfHW0wNbD31DrUN0MWI,28
-docket/annotations.py,sha256=wttix9UOeMFMAWXAIJUfUw5GjESJZsACb4YXJCozP7Q,2348
-docket/cli.py,sha256=rTfri2--u4Q5PlXyh7Ub_F5uh3-TtZOWLUp9WY_TvAE,25750
-docket/dependencies.py,sha256=BC0bnt10cr9_S1p5JAP_bnC9RwZkTr9ulPBrxC7eZnA,20247
-docket/docket.py,sha256=Cw7QB1d0eDwSgwn0Rj26WjFsXSe7MJtfsUBBHGalL7A,26262
-docket/execution.py,sha256=r_2RGC1qhtAcBUg7E6wewLEgftrf3hIxNbH0HnYPbek,14961
-docket/instrumentation.py,sha256=ogvzrfKbWsdPGfdg4hByH3_r5d3b5AwwQkSrmXw0hRg,5492
-docket/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-docket/tasks.py,sha256=RIlSM2omh-YDwVnCz6M5MtmK8T_m_s1w2OlRRxDUs6A,1437
-docket/worker.py,sha256=pOBRoEbakUwAGVKAuCNPSMyHRBSalUxtMc93QZewX7M,34928
-pydocket-0.10.0.dist-info/METADATA,sha256=Tsm_S5NTj5yOPmt-q4KAKjdEDjH6ZRzz_ITVapnFk64,5419
-pydocket-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydocket-0.10.0.dist-info/entry_points.txt,sha256=4WOk1nUlBsUT5O3RyMci2ImuC5XFswuopElYcLHtD5k,47
-pydocket-0.10.0.dist-info/licenses/LICENSE,sha256=YuVWU_ZXO0K_k2FG8xWKe5RGxV24AhJKTvQmKfqXuyk,1087
-pydocket-0.10.0.dist-info/RECORD,,