pydocket 0.1.4__py3-none-any.whl → 0.2.1__py3-none-any.whl

docket/cli.py

@@ -243,6 +243,13 @@ def worker(
             help="Exit after the current docket is finished",
         ),
     ] = False,
+    metrics_port: Annotated[
+        int | None,
+        typer.Option(
+            "--metrics-port",
+            help="The port to serve Prometheus metrics on",
+        ),
+    ] = None,
 ) -> None:
     asyncio.run(
         Worker.run(
@@ -254,6 +261,7 @@ def worker(
             reconnection_delay=reconnection_delay,
             minimum_check_interval=minimum_check_interval,
             until_finished=until_finished,
+            metrics_port=metrics_port,
             tasks=tasks,
         )
     )

docket/dependencies.py

@@ -61,15 +61,14 @@ class _TaskLogger(Dependency):
         self, docket: Docket, worker: Worker, execution: Execution
     ) -> logging.LoggerAdapter[logging.Logger]:
         logger = logging.getLogger(f"docket.task.{execution.function.__name__}")
-
-        extra = {
-            "execution.key": execution.key,
-            "execution.attempt": execution.attempt,
-            "worker.name": worker.name,
-            "docket.name": docket.name,
-        }
-
-        return logging.LoggerAdapter(logger, extra)
+        return logging.LoggerAdapter(
+            logger,
+            {
+                **docket.labels(),
+                **worker.labels(),
+                **execution.specific_labels(),
+            },
+        )
 
 
 def TaskLogger() -> logging.LoggerAdapter[logging.Logger]:

docket/docket.py

@@ -13,6 +13,7 @@ from typing import (
     Collection,
     Hashable,
     Iterable,
+    Mapping,
     NoReturn,
     ParamSpec,
     Self,
@@ -26,7 +27,7 @@ from uuid import uuid4
 
 import redis.exceptions
 from opentelemetry import propagate, trace
-from redis.asyncio import Redis
+from redis.asyncio import ConnectionPool, Redis
 
 from .execution import (
     Execution,
@@ -112,11 +113,14 @@ class Docket:
     tasks: dict[str, Callable[..., Awaitable[Any]]]
     strike_list: StrikeList
 
+    _monitor_strikes_task: asyncio.Task[None]
+    _connection_pool: ConnectionPool
+
     def __init__(
         self,
         name: str = "docket",
         url: str = "redis://localhost:6379/0",
-        heartbeat_interval: timedelta = timedelta(seconds=1),
+        heartbeat_interval: timedelta = timedelta(seconds=2),
         missed_heartbeats: int = 5,
     ) -> None:
         """
@@ -144,6 +148,7 @@ class Docket:
         self.tasks = {fn.__name__: fn for fn in standard_tasks}
         self.strike_list = StrikeList()
 
+        self._connection_pool = ConnectionPool.from_url(self.url)  # type: ignore
         self._monitor_strikes_task = asyncio.create_task(self._monitor_strikes())
 
         # Ensure that the stream and worker group exist
@@ -176,23 +181,17 @@ class Docket:
         except asyncio.CancelledError:
             pass
 
+        await asyncio.shield(self._connection_pool.disconnect())
+        del self._connection_pool
+
     @asynccontextmanager
     async def redis(self) -> AsyncGenerator[Redis, None]:
-        redis: Redis | None = None
+        r = Redis(connection_pool=self._connection_pool)
+        await r.__aenter__()
         try:
-            redis = await Redis.from_url(
-                self.url,
-                single_connection_client=True,
-            )
-            await redis.__aenter__()
-            try:
-                yield redis
-            finally:
-                await asyncio.shield(redis.__aexit__(None, None, None))
+            yield r
         finally:
-            # redis 4.6.0 doesn't automatically disconnect and leaves connections open
-            if redis:
-                await asyncio.shield(redis.connection_pool.disconnect())
+            await asyncio.shield(r.__aexit__(None, None, None))
 
     def register(self, function: Callable[..., Awaitable[Any]]) -> None:
         from .dependencies import validate_dependencies
@@ -214,6 +213,11 @@ class Docket:
         for function in collection:
             self.register(function)
 
+    def labels(self) -> Mapping[str, str]:
+        return {
+            "docket.name": self.name,
+        }
+
     @overload
     def add(
         self,
@@ -251,7 +255,7 @@ class Docket:
             execution = Execution(function, args, kwargs, when, key, attempt=1)
             await self.schedule(execution)
 
-            TASKS_ADDED.add(1, {"docket": self.name, "task": function.__name__})
+            TASKS_ADDED.add(1, {**self.labels(), **execution.general_labels()})
 
             return execution
 
@@ -287,7 +291,7 @@ class Docket:
             await self.cancel(key)
             await self.schedule(execution)
 
-            TASKS_REPLACED.add(1, {"docket": self.name, "task": function.__name__})
+            TASKS_REPLACED.add(1, {**self.labels(), **execution.general_labels()})
 
             return execution
 
@@ -314,9 +318,9 @@ class Docket:
             TASKS_STRICKEN.add(
                 1,
                 {
-                    "docket": self.name,
-                    "task": execution.function.__name__,
-                    "where": "docket",
+                    **self.labels(),
+                    **execution.specific_labels(),
+                    "docket.where": "docket",
                 },
             )
             return
@@ -327,10 +331,8 @@ class Docket:
         with tracer.start_as_current_span(
             "docket.schedule",
             attributes={
-                "docket.name": self.name,
-                "docket.execution.when": execution.when.isoformat(),
-                "docket.execution.key": execution.key,
-                "docket.execution.attempt": execution.attempt,
+                **self.labels(),
+                **execution.specific_labels(),
                 "code.function.name": execution.function.__name__,
             },
         ):
@@ -350,16 +352,14 @@ class Docket:
                         pipe.zadd(self.queue_key, {key: when.timestamp()})
                         await pipe.execute()
 
-        TASKS_SCHEDULED.add(
-            1, {"docket": self.name, "task": execution.function.__name__}
-        )
+        TASKS_SCHEDULED.add(1, {**self.labels(), **execution.general_labels()})
 
     async def cancel(self, key: str) -> None:
         with tracer.start_as_current_span(
             "docket.cancel",
             attributes={
-                "docket.name": self.name,
-                "docket.execution.key": key,
+                **self.labels(),
+                "docket.key": key,
             },
         ):
             async with self.redis() as redis:
@@ -368,7 +368,7 @@ class Docket:
                     pipe.zrem(self.queue_key, key)
                     await pipe.execute()
 
-        TASKS_CANCELLED.add(1, {"docket": self.name})
+        TASKS_CANCELLED.add(1, self.labels())
 
     @property
     def strike_key(self) -> str:
@@ -408,8 +408,8 @@ class Docket:
         with tracer.start_as_current_span(
             f"docket.{instruction.direction}",
             attributes={
-                "docket.name": self.name,
-                **instruction.as_span_attributes(),
+                **self.labels(),
+                **instruction.labels(),
             },
         ):
             async with self.redis() as redis:
@@ -441,18 +441,15 @@ class Docket:
                                         else "Restoring"
                                     ),
                                     instruction.call_repr(),
-                                    extra={"docket": self.name},
+                                    extra=self.labels(),
                                 )
 
-                                counter_labels = {"docket": self.name}
-                                if instruction.function:
-                                    counter_labels["task"] = instruction.function
-                                if instruction.parameter:
-                                    counter_labels["parameter"] = instruction.parameter
-
                                 STRIKES_IN_EFFECT.add(
                                     1 if instruction.direction == "strike" else -1,
-                                    counter_labels,
+                                    {
+                                        **self.labels(),
+                                        **instruction.labels(),
+                                    },
                                 )
 
             except redis.exceptions.ConnectionError:  # pragma: no cover

docket/execution.py

@@ -3,7 +3,7 @@ import enum
 import inspect
 import logging
 from datetime import datetime
-from typing import Any, Awaitable, Callable, Hashable, Literal, Self, cast
+from typing import Any, Awaitable, Callable, Hashable, Literal, Mapping, Self, cast
 
 import cloudpickle  # type: ignore[import]
 
@@ -55,6 +55,17 @@ class Execution:
             attempt=int(message[b"attempt"].decode()),
         )
 
+    def general_labels(self) -> Mapping[str, str]:
+        return {"docket.task": self.function.__name__}
+
+    def specific_labels(self) -> Mapping[str, str | int]:
+        return {
+            "docket.task": self.function.__name__,
+            "docket.key": self.key,
+            "docket.when": self.when.isoformat(),
+            "docket.attempt": self.attempt,
+        }
+
     def call_repr(self) -> str:
         arguments: list[str] = []
         signature = inspect.signature(self.function)
@@ -131,17 +142,17 @@ class StrikeInstruction(abc.ABC):
         else:
             return Restore(function, parameter, operator, value)
 
-    def as_span_attributes(self) -> dict[str, str]:
-        span_attributes: dict[str, str] = {}
+    def labels(self) -> Mapping[str, str]:
+        labels: dict[str, str] = {}
         if self.function:
-            span_attributes["docket.function"] = self.function
+            labels["docket.task"] = self.function
 
         if self.parameter:
-            span_attributes["docket.parameter"] = self.parameter
-            span_attributes["docket.operator"] = self.operator
-            span_attributes["docket.value"] = repr(self.value)
+            labels["docket.parameter"] = self.parameter
+            labels["docket.operator"] = self.operator
+            labels["docket.value"] = repr(self.value)
 
-        return span_attributes
+        return labels
 
     def call_repr(self) -> str:
         return (

docket/instrumentation.py

@@ -1,5 +1,12 @@
+import threading
+from contextlib import contextmanager
+from typing import Generator, cast
+
 from opentelemetry import metrics
+from opentelemetry.exporter.prometheus import PrometheusMetricReader
+from opentelemetry.metrics import set_meter_provider
 from opentelemetry.propagators.textmap import Getter, Setter
+from opentelemetry.sdk.metrics import MeterProvider
 
 meter: metrics.Meter = metrics.get_meter("docket")
 
@@ -93,6 +100,17 @@ STRIKES_IN_EFFECT = meter.create_up_down_counter(
     unit="1",
 )
 
+QUEUE_DEPTH = meter.create_gauge(
+    "docket_queue_depth",
+    description="How many tasks are due to be executed now",
+    unit="1",
+)
+SCHEDULE_DEPTH = meter.create_gauge(
+    "docket_schedule_depth",
+    description="How many tasks are scheduled to be executed in the future",
+    unit="1",
+)
+
 Message = dict[bytes, bytes]
 
 
@@ -119,3 +137,38 @@ class MessageSetter(Setter[Message]):
 
 message_getter: MessageGetter = MessageGetter()
 message_setter: MessageSetter = MessageSetter()
+
+
+@contextmanager
+def metrics_server(
+    host: str = "0.0.0.0", port: int | None = None
+) -> Generator[None, None, None]:
+    if port is None:
+        yield
+        return
+
+    from wsgiref.types import WSGIApplication
+
+    from prometheus_client import REGISTRY
+    from prometheus_client.exposition import (
+        ThreadingWSGIServer,
+        _SilentHandler,  # type: ignore[member-access]
+        make_server,  # type: ignore[import]
+        make_wsgi_app,  # type: ignore[import]
+    )
+
+    set_meter_provider(MeterProvider(metric_readers=[PrometheusMetricReader()]))
+
+    server = make_server(
+        host,
+        port,
+        cast(WSGIApplication, make_wsgi_app(registry=REGISTRY)),
+        ThreadingWSGIServer,
+        handler_class=_SilentHandler,
+    )
+    with server:
+        t = threading.Thread(target=server.serve_forever)
+        t.daemon = True
+        t.start()
+
+        yield

docket/tasks.py

@@ -2,16 +2,21 @@ import asyncio
 import logging
 from datetime import datetime, timezone
 
-from .dependencies import CurrentDocket, CurrentExecution, CurrentWorker, Retry
+from .dependencies import (
+    CurrentDocket,
+    CurrentExecution,
+    CurrentWorker,
+    Retry,
+    TaskLogger,
+)
 from .docket import Docket, TaskCollection
 from .execution import Execution
 from .worker import Worker
 
-logger: logging.Logger = logging.getLogger(__name__)
-
 
 async def trace(
     message: str,
+    logger: logging.LoggerAdapter[logging.Logger] = TaskLogger(),
     docket: Docket = CurrentDocket(),
     worker: Worker = CurrentWorker(),
     execution: Execution = CurrentExecution(),
@@ -23,11 +28,6 @@ async def trace(
         docket.name,
         (datetime.now(timezone.utc) - execution.when),
         worker.name,
-        extra={
-            "docket.name": docket.name,
-            "worker.name": worker.name,
-            "execution.key": execution.key,
-        },
     )
 
 
@@ -45,7 +45,9 @@ async def fail(
     )
 
 
-async def sleep(seconds: float) -> None:
+async def sleep(
+    seconds: float, logger: logging.LoggerAdapter[logging.Logger] = TaskLogger()
+) -> None:
     logger.info("Sleeping for %s seconds", seconds)
     await asyncio.sleep(seconds)
 

docket/worker.py

@@ -7,6 +7,8 @@ from types import TracebackType
 from typing import (
     TYPE_CHECKING,
     Any,
+    Callable,
+    Mapping,
     Protocol,
     Self,
     TypeVar,
@@ -27,7 +29,9 @@ from .docket import (
     RedisReadGroupResponse,
 )
 from .instrumentation import (
+    QUEUE_DEPTH,
     REDIS_DISRUPTIONS,
+    SCHEDULE_DEPTH,
     TASK_DURATION,
     TASK_PUNCTUALITY,
     TASKS_COMPLETED,
@@ -38,6 +42,7 @@ from .instrumentation import (
     TASKS_STRICKEN,
     TASKS_SUCCEEDED,
     message_getter,
+    metrics_server,
 )
 
 logger: logging.Logger = logging.getLogger(__name__)
@@ -59,6 +64,11 @@ class _stream_due_tasks(Protocol):
 class Worker:
     docket: Docket
     name: str
+    concurrency: int
+    redelivery_timeout: timedelta
+    reconnection_delay: timedelta
+    minimum_check_interval: timedelta
+    _strike_conditions: list[Callable[[Execution], bool]] = []
 
     def __init__(
         self,
@@ -76,6 +86,10 @@ class Worker:
         self.reconnection_delay = reconnection_delay
         self.minimum_check_interval = minimum_check_interval
 
+        self._strike_conditions = [
+            docket.strike_list.is_stricken,
+        ]
+
     async def __aenter__(self) -> Self:
         self._heartbeat_task = asyncio.create_task(self._heartbeat())
 
@@ -94,11 +108,17 @@ class Worker:
             pass
         del self._heartbeat_task
 
-    @property
-    def _log_context(self) -> dict[str, str]:
+    def labels(self) -> Mapping[str, str]:
         return {
-            "queue_key": self.docket.queue_key,
-            "stream_key": self.docket.stream_key,
+            **self.docket.labels(),
+            "docket.worker": self.name,
+        }
+
+    def _log_context(self) -> Mapping[str, str]:
+        return {
+            **self.labels(),
+            "docket.queue_key": self.docket.queue_key,
+            "docket.stream_key": self.docket.stream_key,
         }
 
     @classmethod
@@ -112,24 +132,26 @@ class Worker:
         reconnection_delay: timedelta = timedelta(seconds=5),
         minimum_check_interval: timedelta = timedelta(milliseconds=100),
         until_finished: bool = False,
+        metrics_port: int | None = None,
         tasks: list[str] = ["docket.tasks:standard_tasks"],
     ) -> None:
-        async with Docket(name=docket_name, url=url) as docket:
-            for task_path in tasks:
-                docket.register_collection(task_path)
-
-            async with Worker(
-                docket=docket,
-                name=name,
-                concurrency=concurrency,
-                redelivery_timeout=redelivery_timeout,
-                reconnection_delay=reconnection_delay,
-                minimum_check_interval=minimum_check_interval,
-            ) as worker:
-                if until_finished:
-                    await worker.run_until_finished()
-                else:
-                    await worker.run_forever()  # pragma: no cover
+        with metrics_server(port=metrics_port):
+            async with Docket(name=docket_name, url=url) as docket:
+                for task_path in tasks:
+                    docket.register_collection(task_path)
+
+                async with Worker(
+                    docket=docket,
+                    name=name,
+                    concurrency=concurrency,
+                    redelivery_timeout=redelivery_timeout,
+                    reconnection_delay=reconnection_delay,
+                    minimum_check_interval=minimum_check_interval,
+                ) as worker:
+                    if until_finished:
+                        await worker.run_until_finished()
+                    else:
+                        await worker.run_forever()  # pragma: no cover
 
     async def run_until_finished(self) -> None:
         """Run the worker until there are no more tasks to process."""
@@ -139,6 +161,35 @@ class Worker:
         """Run the worker indefinitely."""
         return await self._run(forever=True)  # pragma: no cover
 
+    async def run_at_most(self, iterations_by_key: Mapping[str, int]) -> None:
+        """
+        Run the worker until there are no more tasks to process, but limit specified
+        task keys to a maximum number of iterations.
+
+        This is particularly useful for testing self-perpetuating tasks that would
+        otherwise run indefinitely.
+
+        Args:
+            iterations_by_key: Maps task keys to their maximum allowed executions
+        """
+        execution_counts: dict[str, int] = {key: 0 for key in iterations_by_key}
+
+        def has_reached_max_iterations(execution: Execution) -> bool:
+            if execution.key not in iterations_by_key:
+                return False
+
+            if execution_counts[execution.key] >= iterations_by_key[execution.key]:
+                return True
+
+            execution_counts[execution.key] += 1
+            return False
+
+        self._strike_conditions.insert(0, has_reached_max_iterations)
+        try:
+            await self.run_until_finished()
+        finally:
+            self._strike_conditions.remove(has_reached_max_iterations)
+
     async def _run(self, forever: bool = False) -> None:
         logger.info("Starting worker %r with the following tasks:", self.name)
         for task_name, task in self.docket.tasks.items():
@@ -149,9 +200,7 @@ class Worker:
             try:
                 return await self._worker_loop(forever=forever)
             except redis.exceptions.ConnectionError:
-                REDIS_DISRUPTIONS.add(
-                    1, {"docket": self.docket.name, "worker": self.name}
-                )
+                REDIS_DISRUPTIONS.add(1, self.labels())
                 logger.warning(
                     "Error connecting to redis, retrying in %s...",
                     self.reconnection_delay,
@@ -263,7 +312,7 @@ class Worker:
                             future_work,
                             self.docket.queue_key,
                             self.docket.stream_key,
-                            extra=self._log_context,
+                            extra=self._log_context(),
                         )
 
                     redeliveries: RedisMessages
@@ -304,7 +353,7 @@ class Worker:
                     logger.info(
                         "Shutdown requested, finishing %d active tasks...",
                         len(active_tasks),
-                        extra=self._log_context,
+                        extra=self._log_context(),
                     )
             finally:
                 if active_tasks:
@@ -312,36 +361,28 @@ class Worker:
                     await process_completed_tasks()
 
     async def _execute(self, message: RedisMessage) -> None:
+        log_context: Mapping[str, str | float] = self._log_context()
+
         function_name = message[b"function"].decode()
         function = self.docket.tasks.get(function_name)
         if function is None:
             logger.warning(
-                "Task function %r not found", function_name, extra=self._log_context
+                "Task function %r not found", function_name, extra=log_context
             )
             return
 
         execution = Execution.from_message(function, message)
-        name = execution.function.__name__
-        key = execution.key
 
-        log_context: dict[str, str | float] = {
-            **self._log_context,
-            "task": name,
-            "key": key,
-        }
-        counter_labels = {
-            "docket": self.docket.name,
-            "worker": self.name,
-            "task": name,
-        }
+        log_context = {**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):
+        if any(condition(execution) for condition in self._strike_conditions):
             arrow = "🗙"
             logger.warning("%s %s", arrow, call, extra=log_context)
-            TASKS_STRICKEN.add(1, counter_labels | {"where": "worker"})
+            TASKS_STRICKEN.add(1, counter_labels | {"docket.where": "worker"})
             return
 
         dependencies = self._get_dependencies(execution)
@@ -352,7 +393,7 @@ class Worker:
 
         start = datetime.now(timezone.utc)
         punctuality = start - execution.when
-        log_context["punctuality"] = punctuality.total_seconds()
+        log_context = {**log_context, "punctuality": punctuality.total_seconds()}
         duration = timedelta(0)
 
         TASKS_STARTED.add(1, counter_labels)
@@ -366,11 +407,8 @@ class Worker:
                 execution.function.__name__,
                 kind=trace.SpanKind.CONSUMER,
                 attributes={
-                    "docket.name": self.docket.name,
-                    "docket.execution.when": execution.when.isoformat(),
-                    "docket.execution.key": execution.key,
-                    "docket.execution.attempt": execution.attempt,
-                    "docket.execution.punctuality": punctuality.total_seconds(),
+                    **self.labels(),
+                    **execution.specific_labels(),
                     "code.function.name": execution.function.__name__,
                 },
                 links=links,
@@ -438,12 +476,7 @@ class Worker:
             execution.attempt += 1
             await self.docket.schedule(execution)
 
-            counter_labels = {
-                "docket": self.docket.name,
-                "worker": self.name,
-                "task": execution.function.__name__,
-            }
-            TASKS_RETRIED.add(1, counter_labels)
+            TASKS_RETRIED.add(1, {**self.labels(), **execution.specific_labels()})
             return True
 
         return False
@@ -487,12 +520,35 @@ class Worker:
                         )
 
                         await pipeline.execute()
+
+                    async with r.pipeline() as pipeline:
+                        pipeline.xlen(self.docket.stream_key)
+                        pipeline.zcount(self.docket.queue_key, 0, now)
+                        pipeline.zcount(self.docket.queue_key, now, "+inf")
+
+                        (
+                            stream_depth,
+                            overdue_depth,
+                            schedule_depth,
+                        ) = await pipeline.execute()
+
+                        QUEUE_DEPTH.set(
+                            stream_depth + overdue_depth, self.docket.labels()
+                        )
+                        SCHEDULE_DEPTH.set(schedule_depth, self.docket.labels())
+
             except asyncio.CancelledError:  # pragma: no cover
                 return
             except redis.exceptions.ConnectionError:
-                REDIS_DISRUPTIONS.add(
-                    1, {"docket": self.docket.name, "worker": self.name}
+                REDIS_DISRUPTIONS.add(1, self.labels())
+                logger.exception(
+                    "Error sending worker heartbeat",
+                    exc_info=True,
+                    extra=self._log_context(),
                 )
-                logger.exception("Error sending worker heartbeat", exc_info=True)
             except Exception:
-                logger.exception("Error sending worker heartbeat", exc_info=True)
+                logger.exception(
+                    "Error sending worker heartbeat",
+                    exc_info=True,
+                    extra=self._log_context(),
+                )

{pydocket-0.1.4.dist-info → pydocket-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydocket
-Version: 0.1.4
+Version: 0.2.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.2.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+docket/__init__.py,sha256=GoJYpyuO6QFeBB8GNaxGGvMMuai55Eaw_8u-o1PM3hk,743
+docket/__main__.py,sha256=Vkuh7aJ-Bl7QVpVbbkUksAd_hn05FiLmWbc-8kbhZQ4,34
+docket/annotations.py,sha256=GZwOPtPXyeIhnsLh3TQMBnXrjtTtSmF4Ratv4vjPx8U,950
+docket/cli.py,sha256=EseF0Sj7IEgd9QDC-FSbHSffvF7DNsrmDGYGgZBdJc8,19413
+docket/dependencies.py,sha256=gIDwcBUhrLk7xGh0ZxdqpsnSeX-hZzGMNvUrVFfqbJI,4281
+docket/docket.py,sha256=zva6ofTm7i5hRwAaAnNtlgIqoMPaNLqCTs2PXGka_8s,19723
+docket/execution.py,sha256=ShP8MoLmxEslk2pAuhKi6KEEKbHdneyQukR9oQwXdjQ,11732
+docket/instrumentation.py,sha256=SUVhVFf8AX2HAfmi0HPTT_QvQezlGPJEKs_1YAmrCbA,4454
+docket/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docket/tasks.py,sha256=RIlSM2omh-YDwVnCz6M5MtmK8T_m_s1w2OlRRxDUs6A,1437
+docket/worker.py,sha256=DH15hW8QBGHaZdOdkpH7bjYtLEydi4sGh-Ei8lEXGOo,20556
+pydocket-0.2.1.dist-info/METADATA,sha256=9DxwXrPzeTCOlxDGn9JUOzQN-k6OjhAJbiRPeMhcNNo,13092
+pydocket-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydocket-0.2.1.dist-info/entry_points.txt,sha256=4WOk1nUlBsUT5O3RyMci2ImuC5XFswuopElYcLHtD5k,47
+pydocket-0.2.1.dist-info/licenses/LICENSE,sha256=YuVWU_ZXO0K_k2FG8xWKe5RGxV24AhJKTvQmKfqXuyk,1087
+pydocket-0.2.1.dist-info/RECORD,,

pydocket-0.1.4.dist-info/RECORD

@@ -1,16 +0,0 @@
-docket/__init__.py,sha256=GoJYpyuO6QFeBB8GNaxGGvMMuai55Eaw_8u-o1PM3hk,743
-docket/__main__.py,sha256=Vkuh7aJ-Bl7QVpVbbkUksAd_hn05FiLmWbc-8kbhZQ4,34
-docket/annotations.py,sha256=GZwOPtPXyeIhnsLh3TQMBnXrjtTtSmF4Ratv4vjPx8U,950
-docket/cli.py,sha256=N0vp1zO5Wau4nBDMJOU34hYn11HR3PaYY3Ybk1gS8XY,19188
-docket/dependencies.py,sha256=Vht3qKbik-HQ7jsAU5k-eig4_yuru56-ZewjBVVu4yM,4325
-docket/docket.py,sha256=TWeZ63NfN6Eq4lFzKoQTJz88ECZsH3-gqYszhQl-bXs,20124
-docket/execution.py,sha256=rHsQ60BbNREzcpUC_RvbGUctdLaprYp1x46sT6jTrdc,11416
-docket/instrumentation.py,sha256=USo8ptCFcwQj_YaUpJvsUHPb0QfQr50i9dF4tYgYde4,2992
-docket/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-docket/tasks.py,sha256=K1f_W1z4m9RVz1GJ1ymWY5ZaRmqHO1SebNBVENlkelU,1471
-docket/worker.py,sha256=8wnWxHj7ctHPxEGSRxPTsHksZ6OWRoG5dKpSkvIZP88,18479
-pydocket-0.1.4.dist-info/METADATA,sha256=y8PTR9Xwh8MeMr7ZhPJzUQGtQUjQXN3QRpYTvxtKfv0,13092
-pydocket-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydocket-0.1.4.dist-info/entry_points.txt,sha256=4WOk1nUlBsUT5O3RyMci2ImuC5XFswuopElYcLHtD5k,47
-pydocket-0.1.4.dist-info/licenses/LICENSE,sha256=YuVWU_ZXO0K_k2FG8xWKe5RGxV24AhJKTvQmKfqXuyk,1087
-pydocket-0.1.4.dist-info/RECORD,,