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

docket/annotations.py

@@ -1,6 +1,8 @@
 import abc
 import inspect
-from typing import Any, Iterable, Mapping, Self
+from typing import Any, Iterable, Mapping
+
+from typing_extensions import Self
 
 from .instrumentation import CACHE_SIZE
 

docket/cli.py

@@ -25,7 +25,7 @@ app: typer.Typer = typer.Typer(
 )
 
 
-class LogLevel(enum.StrEnum):
+class LogLevel(str, enum.Enum):
     DEBUG = "DEBUG"
     INFO = "INFO"
     WARNING = "WARNING"
@@ -33,7 +33,7 @@ class LogLevel(enum.StrEnum):
     CRITICAL = "CRITICAL"
 
 
-class LogFormat(enum.StrEnum):
+class LogFormat(str, enum.Enum):
     RICH = "rich"
     PLAIN = "plain"
     JSON = "json"
@@ -111,7 +111,23 @@ def set_logging_format(format: LogFormat) -> None:
 
 
 def set_logging_level(level: LogLevel) -> None:
-    logging.getLogger().setLevel(level)
+    logging.getLogger().setLevel(level.value)
+
+
+def validate_url(url: str) -> str:
+    """
+    Validate that the provided URL is compatible with the CLI.
+
+    The memory:// backend is not compatible with the CLI as it doesn't persist
+    across processes.
+    """
+    if url.startswith("memory://"):
+        raise typer.BadParameter(
+            "The memory:// URL scheme is not supported by the CLI.\n"
+            "The memory backend does not persist across processes.\n"
+            "Please use a persistent backend like Redis or Valkey."
+        )
+    return url
 
 
 def handle_strike_wildcard(value: str) -> str | None:
@@ -178,6 +194,7 @@ def worker(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
     name: Annotated[
@@ -336,6 +353,7 @@ def strike(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
 ) -> None:
@@ -347,7 +365,7 @@ def strike(
     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"Striking {function_name} {parameter} {operator.value} {value_!r}")
     else:
         print(f"Striking {function}")
 
@@ -373,6 +391,7 @@ def clear(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
 ) -> None:
@@ -425,6 +444,7 @@ def restore(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
 ) -> None:
@@ -436,7 +456,7 @@ def restore(
     value_ = interpret_python_value(value)
     if parameter:
         function_name = f"{function or '(all tasks)'}"
-        print(f"Restoring {function_name} {parameter} {operator} {value_!r}")
+        print(f"Restoring {function_name} {parameter} {operator.value} {value_!r}")
     else:
         print(f"Restoring {function}")
 
@@ -468,6 +488,7 @@ def trace(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
     message: Annotated[
@@ -511,6 +532,7 @@ def fail(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
     message: Annotated[
@@ -554,6 +576,7 @@ def sleep(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
     seconds: Annotated[
@@ -688,6 +711,7 @@ def snapshot(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
     stats: Annotated[
@@ -746,10 +770,11 @@ def snapshot(
 
     console.print(table)
 
-    # Display task statistics if requested
-    if stats:
+    # Display task statistics if requested. On Linux the Click runner executes
+    # this CLI in a subprocess, so coverage cannot observe it. Mark as no cover.
+    if stats:  # pragma: no cover
         task_stats = get_task_stats(snapshot)
-        if task_stats:
+        if task_stats:  # pragma: no cover
             console.print()  # Add spacing between tables
             stats_table = Table(title="Task Count Statistics by Function")
             stats_table.add_column("Function", style="cyan")
@@ -839,6 +864,7 @@ def list_workers(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
 ) -> None:
@@ -875,6 +901,7 @@ def workers_for_task(
         typer.Option(
             help="The URL of the Redis server",
             envvar="DOCKET_URL",
+            callback=validate_url,
         ),
     ] = "redis://localhost:6379/0",
 ) -> None:

docket/dependencies.py

@@ -1,4 +1,5 @@
 import abc
+import inspect
 import logging
 import time
 from contextlib import AsyncExitStack, asynccontextmanager
@@ -12,6 +13,7 @@ from typing import (
     AsyncGenerator,
     Awaitable,
     Callable,
+    ContextManager,
     Counter,
     Generic,
     NoReturn,
@@ -161,7 +163,7 @@ def TaskArgument(parameter: str | None = None, optional: bool = False) -> Any:
 
 
 class _TaskLogger(Dependency):
-    async def __aenter__(self) -> logging.LoggerAdapter[logging.Logger]:
+    async def __aenter__(self) -> "logging.LoggerAdapter[logging.Logger]":
         execution = self.execution.get()
         logger = logging.getLogger(f"docket.task.{execution.function.__name__}")
         return logging.LoggerAdapter(
@@ -174,7 +176,7 @@ class _TaskLogger(Dependency):
         )
 
 
-def TaskLogger() -> logging.LoggerAdapter[logging.Logger]:
+def TaskLogger() -> "logging.LoggerAdapter[logging.Logger]":
     """A dependency to access a logger for the currently executing task.  The logger
     will automatically inject contextual information such as the worker and docket
     name, the task key, and the current execution attempt number.
@@ -183,11 +185,11 @@ def TaskLogger() -> logging.LoggerAdapter[logging.Logger]:
 
     ```python
     @task
-    async def my_task(logger: LoggerAdapter[Logger] = TaskLogger()) -> None:
+    async def my_task(logger: "LoggerAdapter[Logger]" = TaskLogger()) -> None:
         logger.info("Hello, world!")
     ```
     """
-    return cast(logging.LoggerAdapter[logging.Logger], _TaskLogger())
+    return cast("logging.LoggerAdapter[logging.Logger]", _TaskLogger())
 
 
 class ForcedRetry(Exception):
@@ -403,7 +405,9 @@ class Timeout(Dependency):
 
 R = TypeVar("R")
 
-DependencyFunction = Callable[..., Awaitable[R] | AsyncContextManager[R]]
+DependencyFunction = Callable[
+    ..., R | Awaitable[R] | ContextManager[R] | AsyncContextManager[R]
+]
 
 
 _parameter_cache: dict[
@@ -441,7 +445,10 @@ class _Depends(Dependency, Generic[R]):
     stack: ContextVar[AsyncExitStack] = ContextVar("stack")
 
     def __init__(
-        self, dependency: Callable[[], Awaitable[R] | AsyncContextManager[R]]
+        self,
+        dependency: Callable[
+            [], R | Awaitable[R] | ContextManager[R] | AsyncContextManager[R]
+        ],
     ) -> None:
         self.dependency = dependency
 
@@ -473,33 +480,87 @@ class _Depends(Dependency, Generic[R]):
         stack = self.stack.get()
         arguments = await self._resolve_parameters(self.dependency)
 
-        value = self.dependency(**arguments)
+        raw_value: R | Awaitable[R] | ContextManager[R] | AsyncContextManager[R] = (
+            self.dependency(**arguments)
+        )
 
-        if isinstance(value, AsyncContextManager):
-            value = await stack.enter_async_context(value)
+        # Handle different return types from the dependency function
+        resolved_value: R
+        if isinstance(raw_value, AsyncContextManager):
+            # Async context manager: await enter_async_context
+            resolved_value = await stack.enter_async_context(raw_value)
+        elif isinstance(raw_value, ContextManager):
+            # Sync context manager: use enter_context (no await needed)
+            resolved_value = stack.enter_context(raw_value)
+        elif inspect.iscoroutine(raw_value) or isinstance(raw_value, Awaitable):
+            # Async function returning awaitable: await it
+            resolved_value = await cast(Awaitable[R], raw_value)
         else:
-            value = await value
+            # Sync function returning a value directly, use as-is
+            resolved_value = cast(R, raw_value)
 
-        cache[self.dependency] = value
-        return value
+        cache[self.dependency] = resolved_value
+        return resolved_value
 
 
 def Depends(dependency: DependencyFunction[R]) -> R:
-    """Include a user-defined function as a dependency.  Dependencies may either return
-    a value or an async context manager.  If it returns a context manager, the
-    dependency will be entered and exited around the task, giving an opportunity to
-    control the lifetime of a resource, like a database connection.
+    """Include a user-defined function as a dependency.  Dependencies may be:
+    - Synchronous functions returning a value
+    - Asynchronous functions returning a value (awaitable)
+    - Synchronous context managers (using @contextmanager)
+    - Asynchronous context managers (using @asynccontextmanager)
 
-    Example:
+    If a dependency returns a context manager, it will be entered and exited around
+    the task, giving an opportunity to control the lifetime of a resource.
 
-    ```python
+    **Important**: Synchronous dependencies should NOT include blocking I/O operations
+    (file access, network calls, database queries, etc.). Use async dependencies for
+    any I/O. Sync dependencies are best for:
+    - Pure computations
+    - In-memory data structure access
+    - Configuration lookups from memory
+    - Non-blocking transformations
 
-    async def my_dependency() -> str:
-        return "Hello, world!"
+    Examples:
 
-    @task async def my_task(dependency: str = Depends(my_dependency)) -> None:
-        print(dependency)
+    ```python
+    # Sync dependency - pure computation, no I/O
+    def get_config() -> dict:
+        # Access in-memory config, no I/O
+        return {"api_url": "https://api.example.com", "timeout": 30}
+
+    # Sync dependency - compute value from arguments
+    def build_query_params(
+        user_id: int = TaskArgument(),
+        config: dict = Depends(get_config)
+    ) -> dict:
+        # Pure computation, no I/O
+        return {"user_id": user_id, "timeout": config["timeout"]}
+
+    # Async dependency - I/O operations
+    async def get_user(user_id: int = TaskArgument()) -> User:
+        # Network I/O - must be async
+        return await fetch_user_from_api(user_id)
+
+    # Async context manager - I/O resource management
+    from contextlib import asynccontextmanager
+
+    @asynccontextmanager
+    async def get_db_connection():
+        # I/O operations - must be async
+        conn = await db.connect()
+        try:
+            yield conn
+        finally:
+            await conn.close()
 
+    @task
+    async def my_task(
+        params: dict = Depends(build_query_params),
+        user: User = Depends(get_user),
+        db: Connection = Depends(get_db_connection),
+    ) -> None:
+        await db.execute("UPDATE users SET ...", params)
     ```
     """
     return cast(R, _Depends(dependency))

docket/docket.py

@@ -17,7 +17,6 @@ from typing import (
     NoReturn,
     ParamSpec,
     Protocol,
-    Self,
     Sequence,
     TypedDict,
     TypeVar,
@@ -25,6 +24,8 @@ from typing import (
     overload,
 )
 
+from typing_extensions import Self
+
 import redis.exceptions
 from opentelemetry import propagate, trace
 from redis.asyncio import ConnectionPool, Redis
@@ -156,12 +157,13 @@ class Docket:
         """
         Args:
             name: The name of the docket.
-            url: The URL of the Redis server.  For example:
+            url: The URL of the Redis server or in-memory backend.  For example:
                 - "redis://localhost:6379/0"
                 - "redis://user:password@localhost:6379/0"
                 - "redis://user:password@localhost:6379/0?ssl=true"
                 - "rediss://localhost:6379/0"
                 - "unix:///path/to/redis.sock"
+                - "memory://" (in-memory backend for testing)
             heartbeat_interval: How often workers send heartbeat messages to the docket.
             missed_heartbeats: How many heartbeats a worker can miss before it is
                 considered dead.
@@ -183,7 +185,30 @@ 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
+        # Check if we should use in-memory backend (fakeredis)
+        # Support memory:// URLs for in-memory dockets
+        if self.url.startswith("memory://"):
+            try:
+                from fakeredis.aioredis import FakeConnection, FakeServer
+
+                # All memory:// URLs share a single FakeServer instance
+                # Multiple dockets with different names are isolated by Redis key prefixes
+                # (e.g., docket1:stream vs docket2:stream)
+                if not hasattr(Docket, "_memory_server"):
+                    Docket._memory_server = FakeServer()  # type: ignore
+
+                server = Docket._memory_server  # type: ignore
+                self._connection_pool = ConnectionPool(
+                    connection_class=FakeConnection, server=server
+                )
+            except ImportError as e:
+                raise ImportError(
+                    "fakeredis is required for memory:// URLs. "
+                    "Install with: pip install pydocket[memory]"
+                ) from e
+        else:
+            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

docket/execution.py

@@ -3,16 +3,9 @@ import enum
 import inspect
 import logging
 from datetime import datetime
-from typing import (
-    Any,
-    Awaitable,
-    Callable,
-    Hashable,
-    Literal,
-    Mapping,
-    Self,
-    cast,
-)
+from typing import Any, Awaitable, Callable, Hashable, Literal, Mapping, cast
+
+from typing_extensions import Self
 
 import cloudpickle  # type: ignore[import]
 import opentelemetry.context
@@ -35,6 +28,12 @@ def get_signature(function: Callable[..., Any]) -> inspect.Signature:
         CACHE_SIZE.set(len(_signature_cache), {"cache": "signature"})
         return _signature_cache[function]
 
+    signature_attr = getattr(function, "__signature__", None)
+    if isinstance(signature_attr, inspect.Signature):
+        _signature_cache[function] = signature_attr
+        CACHE_SIZE.set(len(_signature_cache), {"cache": "signature"})
+        return signature_attr
+
     signature = inspect.signature(function)
     _signature_cache[function] = signature
     CACHE_SIZE.set(len(_signature_cache), {"cache": "signature"})
@@ -161,7 +160,7 @@ def compact_signature(signature: inspect.Signature) -> str:
     return ", ".join(parameters)
 
 
-class Operator(enum.StrEnum):
+class Operator(str, enum.Enum):
     EQUAL = "=="
     NOT_EQUAL = "!="
     GREATER_THAN = ">"

docket/instrumentation.py

@@ -193,7 +193,14 @@ def metrics_server(
         yield
         return
 
-    from wsgiref.types import WSGIApplication
+    import sys
+    from typing import Any
+
+    # wsgiref.types was added in Python 3.11
+    if sys.version_info >= (3, 11):  # pragma: no cover
+        from wsgiref.types import WSGIApplication
+    else:  # pragma: no cover
+        WSGIApplication = Any  # type: ignore[misc,assignment]
 
     from prometheus_client import REGISTRY
     from prometheus_client.exposition import (

docket/tasks.py

@@ -16,7 +16,7 @@ from .worker import Worker
 
 async def trace(
     message: str,
-    logger: logging.LoggerAdapter[logging.Logger] = TaskLogger(),
+    logger: "logging.LoggerAdapter[logging.Logger]" = TaskLogger(),
     docket: Docket = CurrentDocket(),
     worker: Worker = CurrentWorker(),
     execution: Execution = CurrentExecution(),
@@ -46,7 +46,7 @@ async def fail(
 
 
 async def sleep(
-    seconds: float, logger: logging.LoggerAdapter[logging.Logger] = TaskLogger()
+    seconds: float, logger: "logging.LoggerAdapter[logging.Logger]" = TaskLogger()
 ) -> None:
     logger.info("Sleeping for %s seconds", seconds)
     await asyncio.sleep(seconds)

docket/worker.py

@@ -6,13 +6,12 @@ import sys
 import time
 from datetime import datetime, timedelta, timezone
 from types import TracebackType
-from typing import (
-    Coroutine,
-    Mapping,
-    Protocol,
-    Self,
-    cast,
-)
+from typing import Coroutine, Mapping, Protocol, cast
+
+if sys.version_info < (3, 11):  # pragma: no cover
+    from exceptiongroup import ExceptionGroup
+
+from typing_extensions import Self
 
 from opentelemetry import trace
 from opentelemetry.trace import Status, StatusCode, Tracer
@@ -167,16 +166,18 @@ class Worker:
                 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,
-                    scheduling_resolution=scheduling_resolution,
-                    schedule_automatic_tasks=schedule_automatic_tasks,
-                ) as worker:
+                async with (
+                    Worker(  # pragma: no branch - context manager exit varies across interpreters
+                        docket=docket,
+                        name=name,
+                        concurrency=concurrency,
+                        redelivery_timeout=redelivery_timeout,
+                        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()
                     else:
@@ -279,13 +280,22 @@ class Worker:
 
         async def get_new_deliveries(redis: Redis) -> RedisReadGroupResponse:
             logger.debug("Getting new deliveries", extra=log_context)
-            return await redis.xreadgroup(
+            # Use non-blocking read with in-memory backend + manual sleep
+            # This is necessary because fakeredis's async blocking operations don't
+            # properly yield control to the asyncio event loop
+            is_memory = self.docket.url.startswith("memory://")
+            result = await redis.xreadgroup(
                 groupname=self.docket.worker_group_name,
                 consumername=self.name,
                 streams={self.docket.stream_key: ">"},
-                block=int(self.minimum_check_interval.total_seconds() * 1000),
+                block=0
+                if is_memory
+                else int(self.minimum_check_interval.total_seconds() * 1000),
                 count=available_slots,
             )
+            if is_memory and not result:
+                await asyncio.sleep(self.minimum_check_interval.total_seconds())
+            return result
 
         def start_task(
             message_id: RedisMessageID,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydocket
-Version: 0.11.1
+Version: 0.12.0
 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
@@ -19,11 +19,15 @@ Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Typing :: Typed
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Requires-Dist: cloudpickle>=3.1.1
+Requires-Dist: exceptiongroup>=1.2.0; python_version < '3.11'
 Requires-Dist: opentelemetry-api>=1.30.0
 Requires-Dist: opentelemetry-exporter-prometheus>=0.51b0
 Requires-Dist: prometheus-client>=0.21.1
@@ -31,6 +35,7 @@ Requires-Dist: python-json-logger>=3.2.1
 Requires-Dist: redis>=4.6
 Requires-Dist: rich>=13.9.4
 Requires-Dist: typer>=0.15.1
+Requires-Dist: typing-extensions>=4.12.0
 Requires-Dist: uuid7>=0.1.0
 Description-Content-Type: text/markdown
 
@@ -69,6 +74,7 @@ from docket import Docket, Worker
 
 async with Docket() as docket:
     async with Worker(docket) as worker:
+        worker.register(greet)
         await worker.run_until_finished()
 ```
 
@@ -98,7 +104,7 @@ reference](https://chrisguidry.github.io/docket/api-reference/).
 ## Installing `docket`
 
 Docket is [available on PyPI](https://pypi.org/project/pydocket/) under the package name
-`pydocket`. It targets Python 3.12 or above.
+`pydocket`. It targets Python 3.10 or above.
 
 With [`uv`](https://docs.astral.sh/uv/):
 
@@ -119,6 +125,18 @@ pip install pydocket
 Docket requires a [Redis](http://redis.io/) server with Streams support (which was
 introduced in Redis 5.0.0). Docket is tested with Redis 6 and 7.
 
+For testing without Redis, Docket includes [fakeredis](https://github.com/cunla/fakeredis-py) for in-memory operation:
+
+```python
+from docket import Docket
+
+async with Docket(name="my-docket", url="memory://my-docket") as docket:
+    # Use docket normally - all operations are in-memory
+    ...
+```
+
+See [Testing with Docket](https://chrisguidry.github.io/docket/testing/#using-in-memory-backend-no-redis-required) for more details.
+
 # Hacking on `docket`
 
 We use [`uv`](https://docs.astral.sh/uv/) for project management, so getting set up

pydocket-0.12.0.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=enTC_b76hxEFbsas3236ihqA8C5Ijvff8PSb2WM8og0,2378
+docket/cli.py,sha256=IyO5kfeQ2NSoBBzxKFKHuTCW-iO321mGVWePNR3tPFg,26800
+docket/dependencies.py,sha256=aPL6dgncRim9Oogi8OfeBGjOabOpMtuaRGkGtdfbvRE,22692
+docket/docket.py,sha256=vU858EENc6pT7cLWHSetLY0e2ObVO0Gr9j0dSyDEcpw,32408
+docket/execution.py,sha256=9aUWNulNSdG2C54UFc-buKM06oiKPvBu4FmM_GVaZEA,15402
+docket/instrumentation.py,sha256=k5yogK3GEGeU6zFWsOv3ENBS2li0jhVQ2BdON8Ov7uM,5908
+docket/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docket/tasks.py,sha256=FzgLNPS_Q370auMSdHmuQxGsHM_GbWuzT-Lja0zAJWs,1441
+docket/worker.py,sha256=emQpdralGmXSNzWthFLjWzTLysAw-jDxWnnAffTyjOc,36127
+pydocket-0.12.0.dist-info/METADATA,sha256=O-TtY_L93hX5m9ghYPoiBiiHpPLvWqXB2xaRfLb47vM,6140
+pydocket-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pydocket-0.12.0.dist-info/entry_points.txt,sha256=4WOk1nUlBsUT5O3RyMci2ImuC5XFswuopElYcLHtD5k,47
+pydocket-0.12.0.dist-info/licenses/LICENSE,sha256=YuVWU_ZXO0K_k2FG8xWKe5RGxV24AhJKTvQmKfqXuyk,1087
+pydocket-0.12.0.dist-info/RECORD,,

pydocket-0.11.1.dist-info/RECORD

@@ -1,17 +0,0 @@
-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,,