wool 0.1rc14__tar.gz → 0.1rc15__tar.gz

{wool-0.1rc14 → wool-0.1rc15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wool
-Version: 0.1rc14
+Version: 0.1rc15
 Summary: A Python framework for distributed multiprocessing.
 Author-email: Conrad Bzura <conrad@wool.io>
 Maintainer-email: maintainers@wool.io
@@ -222,7 +222,7 @@ Requires-Dist: hypothesis; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
 Requires-Dist: pytest-cov; extra == 'dev'
-Requires-Dist: pytest-grpc-aio~=0.2.0; extra == 'dev'
+Requires-Dist: pytest-grpc-aio~=0.3.0; extra == 'dev'
 Requires-Dist: pytest-mock; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Description-Content-Type: text/markdown

{wool-0.1rc14 → wool-0.1rc15}/pyproject.toml

@@ -41,7 +41,7 @@ dev = [
     "pytest",
     "pytest-asyncio",
     "pytest-cov",
-    "pytest-grpc-aio~=0.2.0",
+    "pytest-grpc-aio~=0.3.0",
     "pytest-mock",
     "ruff",
 ]

{wool-0.1rc14 → wool-0.1rc15}/wool/__init__.py

@@ -2,9 +2,6 @@ from contextvars import ContextVar
 from importlib.metadata import PackageNotFoundError
 from importlib.metadata import version
 from typing import Final
-from typing import Generic
-from typing import TypeVar
-from typing import cast
 
 from tblib import pickling_support
 
@@ -29,26 +26,6 @@ from wool._worker_proxy import WorkerProxy
 pickling_support.install()
 
 
-SENTINEL = object()
-
-T = TypeVar("T")
-
-
-class GlobalVar(Generic[T]):
-    def __init__(self, default: T | None = None) -> None:
-        self._default = default
-        self._value = SENTINEL
-
-    def get(self) -> T | None:
-        if self._value is SENTINEL:
-            return self._default
-        else:
-            return cast(T, self._value)
-
-    def set(self, value: T):
-        self._value = value
-
-
 try:
     __version__ = version("wool")
 except PackageNotFoundError:

wool-0.1rc15/wool/_connection.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncIterator
+from typing import Final
+from typing import Generic
+from typing import TypeAlias
+from typing import TypeVar
+
+import cloudpickle
+import grpc.aio
+
+from wool import _protobuf as pb
+from wool._work import WoolTask
+
+_DispatchCall: TypeAlias = grpc.aio.UnaryStreamCall[pb.task.Task, pb.worker.Response]
+
+_T = TypeVar("_T")
+
+
+class _DispatchStream(Generic[_T]):
+    """Async iterator wrapper for streaming task results from workers.
+
+    Handles iteration over gRPC response streams and deserializes
+    task results or raises exceptions received from remote workers.
+
+    :param call:
+        The underlying gRPC response stream.
+    """
+
+    def __init__(self, call: _DispatchCall):
+        self._call = call
+        self._iter = aiter(call)
+
+    def __aiter__(self) -> AsyncIterator[_T]:
+        """Return self as the async iterator."""
+        return self
+
+    async def __anext__(self) -> _T:
+        """Get the next response from the stream.
+
+        :returns:
+            The next task result from the worker.
+        :raises StopAsyncIteration:
+            When the stream is exhausted.
+        :raises UnexpectedResponse:
+            If the response is neither a result nor an exception.
+        :raises Exception:
+            Any exception raised by the task execution is re-raised.
+        """
+        try:
+            response = await anext(self._iter)
+            if response.HasField("result"):
+                return cloudpickle.loads(response.result.dump)
+            elif response.HasField("exception"):
+                raise cloudpickle.loads(response.exception.dump)
+            else:
+                raise UnexpectedResponse(
+                    f"Expected 'result' or 'exception' response, "
+                    f"received '{response.WhichOneof('payload')}'"
+                )
+        except Exception:
+            try:
+                self._call.cancel()
+            except Exception:
+                pass
+            raise
+
+
+# public
+class UnexpectedResponse(Exception):
+    """Raised when a worker returns an unexpected response type.
+
+    This exception indicates a protocol violation where the worker's
+    response doesn't match the expected format (e.g., missing acknowledgment
+    or returning an unrecognized payload type).
+    """
+
+
+# public
+class RpcError(Exception):
+    """Raised when a gRPC call to a worker fails with a non-transient error.
+
+    Non-transient errors indicate persistent issues with the worker that
+    are unlikely to be resolved by retrying (e.g., invalid arguments,
+    unimplemented methods, permission denied).
+    """
+
+
+# public
+class TransientRpcError(RpcError):
+    """Raised when a gRPC call to a worker fails with a transient error.
+
+    Transient errors indicate temporary issues that may be resolved by
+    retrying the operation, such as:
+
+    - ``UNAVAILABLE``: Worker temporarily unavailable
+    - ``DEADLINE_EXCEEDED``: Request took too long
+    - ``RESOURCE_EXHAUSTED``: Worker temporarily overloaded
+    """
+
+
+# public
+class Connection:
+    """Connection to a remote worker service used for dispatching tasks.
+
+    Maintains a persistent gRPC channel to a single worker and manages
+    the channel lifecycle. Provides task dispatch functionality with
+    concurrency control.
+
+    :param target:
+        The target URI for the worker service to connect to. Can be specified
+        in several formats:
+
+        - ``host:port`` - DNS name or IP with port (defaults to dns scheme)
+        - ``dns://host:port`` - Explicit DNS resolution
+        - ``ipv4:address:port`` - IPv4 address
+        - ``ipv6:[address]:port`` - IPv6 address (brackets required)
+        - ``unix:path`` or ``unix:///path`` - Unix domain socket
+
+        If no scheme is specified, the dns scheme is used by default.
+        Examples: ``localhost:50051``, ``dns://example.com:8080``,
+        ``ipv4:192.0.2.1:50051``.
+
+        See https://github.com/grpc/grpc/blob/master/doc/naming.md for
+        complete URI format specifications.
+    :param limit:
+        Maximum number of concurrent task dispatches allowed.
+    """
+
+    TRANSIENT_ERRORS: Final = {
+        grpc.StatusCode.UNAVAILABLE,
+        grpc.StatusCode.DEADLINE_EXCEEDED,
+        grpc.StatusCode.RESOURCE_EXHAUSTED,
+    }
+
+    def __init__(
+        self,
+        target: str,
+        *,
+        limit: int = 100,
+    ):
+        if limit <= 0:
+            raise ValueError("Limit must be positive")
+        self._channel = grpc.aio.insecure_channel(
+            target,
+            options=[
+                ("grpc.keepalive_time_ms", 10000),
+                ("grpc.keepalive_timeout_ms", 5000),
+                ("grpc.http2.max_pings_without_data", 0),
+                ("grpc.http2.min_time_between_pings_ms", 10000),
+                ("grpc.max_receive_message_length", 100 * 1024 * 1024),
+                ("grpc.max_send_message_length", 100 * 1024 * 1024),
+            ],
+        )
+        self._stub = pb.worker.WorkerStub(self._channel)
+        self._semaphore = asyncio.Semaphore(limit)
+
+    async def dispatch(
+        self,
+        task: WoolTask,
+        *,
+        timeout: float | None = None,
+    ) -> AsyncIterator[pb.task.Result]:
+        """Dispatch a task to the remote worker for execution.
+
+        Sends the task to the worker via gRPC, waits for acknowledgment,
+        and returns an async iterator that streams back results. Respects
+        concurrency limits and applies timeout to the dispatch phase only
+        (semaphore acquisition and acknowledgment).
+
+        :param task:
+            The :class:`WoolTask` instance to dispatch to the worker.
+        :param timeout:
+            Timeout in seconds for semaphore acquisition and task
+            acknowledgment. If ``None``, no timeout is applied. Does not
+            apply to the execution phase.
+        :returns:
+            An async iterator that yields task results from the worker.
+        :raises TransientRpcError:
+            If the worker returns a transient RPC error (UNAVAILABLE,
+            DEADLINE_EXCEEDED, or RESOURCE_EXHAUSTED).
+        :raises RpcError:
+            If the worker returns a non-transient RPC error.
+        :raises UnexpectedResponse:
+            If the worker doesn't acknowledge the task.
+        :raises TimeoutError:
+            If the timeout is exceeded during dispatch phase.
+        :raises ValueError:
+            If the timeout value is not positive.
+        """
+        if timeout is not None and timeout <= 0:
+            raise ValueError("Dispatch timeout must be positive")
+
+        try:
+            call = await self._dispatch(task, timeout)
+        except grpc.RpcError as error:
+            if error.code() in self.TRANSIENT_ERRORS:
+                raise TransientRpcError from error
+            else:
+                raise RpcError from error
+
+        return self._execute(call)
+
+    async def close(self):
+        """Close the connection and release all resources.
+
+        Gracefully closes the underlying gRPC channel to the remote
+        worker and cleans up any associated resources.
+        """
+        await self._channel.close()
+
+    async def _dispatch(self, task, timeout):
+        async with asyncio.timeout(timeout):
+            await self._semaphore.acquire()
+            try:
+                call: _DispatchCall = self._stub.dispatch(task.to_protobuf())
+                try:
+                    response = await anext(aiter(call))
+                    if not response.HasField("ack"):
+                        raise UnexpectedResponse(
+                            f"Expected 'ack' response, "
+                            f"received '{response.WhichOneof('payload')}'"
+                        )
+                except (Exception, asyncio.CancelledError):
+                    try:
+                        call.cancel()
+                    except Exception:
+                        pass
+                    raise
+            except (Exception, asyncio.CancelledError):
+                self._semaphore.release()
+                raise
+        return call
+
+    async def _execute(self, call):
+        try:
+            async for result in _DispatchStream(call):
+                yield result
+        except (Exception, asyncio.CancelledError):
+            try:
+                call.cancel()
+            except Exception:
+                pass
+            raise
+        finally:
+            self._semaphore.release()

wool-0.1rc15/wool/_context.py

@@ -0,0 +1,29 @@
+from contextvars import ContextVar
+from contextvars import Token
+from typing import Final
+
+from wool._undefined import Undefined
+from wool._undefined import UndefinedType
+
+dispatch_timeout: Final[ContextVar[float | None]] = ContextVar(
+    "_dispatch_timeout", default=None
+)
+
+
+# public
+class AppContext:
+    _dispatch_timeout: float | None | UndefinedType
+    _dispatch_timeout_token: Token | UndefinedType
+
+    def __init__(self, *, dispatch_timeout: float | None | UndefinedType = Undefined):
+        self._dispatch_timeout = dispatch_timeout
+
+    def __enter__(self):
+        if self._dispatch_timeout is not Undefined:
+            self._dispatch_timeout_token = dispatch_timeout.set(self._dispatch_timeout)
+        else:
+            self._dispatch_timeout_token = Undefined
+
+    def __exit__(self, *_):
+        if self._dispatch_timeout_token is not Undefined:
+            dispatch_timeout.reset(self._dispatch_timeout_token)

wool-0.1rc15/wool/_loadbalancer.py

@@ -0,0 +1,213 @@
+from __future__ import annotations
+
+import itertools
+from types import MappingProxyType
+from typing import TYPE_CHECKING
+from typing import AsyncIterator
+from typing import Callable
+from typing import Final
+from typing import Protocol
+from typing import TypeAlias
+from typing import runtime_checkable
+
+from wool._connection import Connection
+from wool._connection import TransientRpcError
+from wool._resource_pool import Resource
+from wool._worker_discovery import WorkerInfo
+
+if TYPE_CHECKING:
+    from wool._work import WoolTask
+
+
+# public
+ConnectionResourceFactory: TypeAlias = Callable[[], Resource[Connection]]
+
+
+# public
+class NoWorkersAvailable(Exception):
+    """Raised when no workers are available for task dispatch.
+
+    This exception indicates that either no workers exist in the worker pool
+    or all available workers have been tried and failed.
+    """
+
+
+# public
+@runtime_checkable
+class LoadBalancerLike(Protocol):
+    """Protocol for load balancers that dispatch tasks to workers.
+
+    Load balancers implementing this protocol operate on a
+    :class:`LoadBalancerContext` to access workers and their connection
+    factories. The context provides isolation, allowing a single load balancer
+    instance to service multiple worker pools with independent state.
+
+    The dispatch method accepts a :class:`WoolTask` and returns an async
+    iterator that yields task results from the worker.
+    """
+
+    async def dispatch(
+        self,
+        task: WoolTask,
+        *,
+        context: LoadBalancerContext,
+        timeout: float | None = None,
+    ) -> AsyncIterator: ...
+
+
+# public
+class LoadBalancerContext:
+    """Isolated load balancing context for a single worker pool.
+
+    Manages workers and their connection resource factories for a specific
+    worker pool, enabling load balancer instances to service multiple pools
+    with independent state and worker lists.
+    """
+
+    _workers: Final[dict[WorkerInfo, ConnectionResourceFactory]]
+
+    def __init__(self):
+        self._workers = {}
+
+    @property
+    def workers(self) -> MappingProxyType[WorkerInfo, ConnectionResourceFactory]:
+        """Read-only view of workers in this context.
+
+        :returns:
+            Immutable mapping of worker information to connection resource
+            factories. Changes to the underlying context are reflected in
+            the returned proxy.
+        """
+        return MappingProxyType(self._workers)
+
+    def add_worker(
+        self,
+        worker_info: WorkerInfo,
+        connection_resource_factory: ConnectionResourceFactory,
+    ):
+        """Add a worker to this context.
+
+        :param worker_info:
+            Information about the worker to add.
+        :param connection_resource_factory:
+            Factory function that creates connection resources for this worker.
+        """
+        self._workers[worker_info] = connection_resource_factory
+
+    def update_worker(
+        self,
+        worker_info: WorkerInfo,
+        connection_resource_factory: ConnectionResourceFactory,
+        *,
+        upsert: bool = False,
+    ):
+        """Update an existing worker's connection resource factory.
+
+        :param worker_info:
+            Information about the worker to update. If the worker is not
+            present in the context, this method does nothing.
+        :param connection_resource_factory:
+            New factory function that creates connection resources for this
+            worker.
+        :param upsert:
+            Flag indicating whether or not to add the worker if it's not
+            already in the context.
+        """
+        if upsert or worker_info in self._workers:
+            self._workers[worker_info] = connection_resource_factory
+
+    def remove_worker(self, worker_info: WorkerInfo):
+        """Remove a worker from this context.
+
+        :param worker_info:
+            Information about the worker to remove. If the worker is not
+            present in the context, this method does nothing.
+        """
+        if worker_info in self._workers:
+            del self._workers[worker_info]
+
+
+# public
+class RoundRobinLoadBalancer(LoadBalancerLike):
+    """Round-robin load balancer for distributing tasks across workers.
+
+    Distributes tasks evenly across available workers using a simple round-robin
+    algorithm. Workers are managed through :class:`LoadBalancerContext` instances
+    passed to the dispatch method, enabling a single load balancer to service
+    multiple worker pools with independent state.
+
+    Automatically handles worker failures by trying the next worker in the
+    round-robin cycle. Workers that encounter transient errors remain in the
+    context, while workers that fail with non-transient errors are removed from
+    the context's worker list.
+    """
+
+    _index: Final[dict[LoadBalancerContext, int]]
+
+    def __init__(self):
+        self._index = {}
+
+    async def dispatch(
+        self,
+        task: WoolTask,
+        *,
+        context: LoadBalancerContext,
+        timeout: float | None = None,
+    ) -> AsyncIterator:
+        """Dispatch a task to the next available worker using round-robin.
+
+        Tries workers in one round-robin cycle until dispatch succeeds.
+        Workers that fail to schedule the task with a non-transient error are
+        removed from the context's worker list.
+
+        :param task:
+            The :class:`WoolTask` instance to dispatch to the worker.
+        :param context:
+            The :class:`LoadBalancerContext` containing workers to dispatch to.
+        :param timeout:
+            Timeout in seconds for each dispatch attempt. If ``None``, no
+            timeout is applied.
+        :returns:
+            A streaming dispatch result that yields worker responses.
+        :raises NoWorkersAvailable:
+            If no healthy workers are available to schedule the task.
+        """
+        checkpoint = None
+
+        # Initialize index for this context if not present
+        if context not in self._index:
+            self._index[context] = 0
+
+        while context.workers:
+            if self._index[context] >= len(context.workers):
+                self._index[context] = 0
+
+            worker_info, connection_resource_factory = next(
+                itertools.islice(
+                    context.workers.items(),
+                    self._index[context],
+                    self._index[context] + 1,
+                )
+            )
+
+            if checkpoint is None:
+                checkpoint = worker_info.uid
+            elif worker_info.uid == checkpoint:
+                break
+
+            async with connection_resource_factory() as connection:
+                try:
+                    result = await connection.dispatch(task, timeout=timeout)
+                except TransientRpcError:
+                    self._index[context] = self._index[context] + 1
+                    continue
+                except Exception:
+                    context.remove_worker(worker_info)
+                    if worker_info.uid == checkpoint:
+                        checkpoint = None
+                    continue
+                else:
+                    self._index[context] = self._index[context] + 1
+                    return result
+
+        raise NoWorkersAvailable("No healthy workers available for dispatch")

{wool-0.1rc14 → wool-0.1rc15}/wool/_protobuf/task_pb2_grpc.py

@@ -4,7 +4,7 @@ import grpc
 import warnings
 
 
-GRPC_GENERATED_VERSION = '1.75.1'
+GRPC_GENERATED_VERSION = '1.76.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 
@@ -17,7 +17,7 @@ except ImportError:
 if _version_not_supported:
     raise RuntimeError(
         f'The grpc package installed is at version {GRPC_VERSION},'
-        + f' but the generated code in task_pb2_grpc.py depends on'
+        + ' but the generated code in task_pb2_grpc.py depends on'
         + f' grpcio>={GRPC_GENERATED_VERSION}.'
         + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
         + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'

{wool-0.1rc14 → wool-0.1rc15}/wool/_protobuf/worker_pb2.py

@@ -25,7 +25,7 @@ _sym_db = _symbol_database.Default()
 import task_pb2 as task__pb2
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cworker.proto\x12\x15wool._protobuf.worker\x1a\ntask.proto\"\xd1\x01\n\x08Response\x12)\n\x03\x61\x63k\x18\x01 \x01(\x0b\x32\x1a.wool._protobuf.worker.AckH\x00\x12+\n\x04nack\x18\x02 \x01(\x0b\x32\x1b.wool._protobuf.worker.NackH\x00\x12-\n\x06result\x18\x03 \x01(\x0b\x32\x1b.wool._protobuf.task.ResultH\x00\x12\x33\n\texception\x18\x04 \x01(\x0b\x32\x1e.wool._protobuf.task.ExceptionH\x00\x42\t\n\x07payload\"\x05\n\x03\x41\x63k\"\x16\n\x04Nack\x12\x0e\n\x06reason\x18\x01 \x01(\t\"\x1b\n\x0bStopRequest\x12\x0c\n\x04wait\x18\x01 \x01(\x05\"\x06\n\x04Void2\x9b\x01\n\x06Worker\x12H\n\x08\x64ispatch\x12\x19.wool._protobuf.task.Task\x1a\x1f.wool._protobuf.worker.Response0\x01\x12G\n\x04stop\x12\".wool._protobuf.worker.StopRequest\x1a\x1b.wool._protobuf.worker.Voidb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cworker.proto\x12\x15wool._protobuf.worker\x1a\ntask.proto\"\xd1\x01\n\x08Response\x12)\n\x03\x61\x63k\x18\x01 \x01(\x0b\x32\x1a.wool._protobuf.worker.AckH\x00\x12+\n\x04nack\x18\x02 \x01(\x0b\x32\x1b.wool._protobuf.worker.NackH\x00\x12-\n\x06result\x18\x03 \x01(\x0b\x32\x1b.wool._protobuf.task.ResultH\x00\x12\x33\n\texception\x18\x04 \x01(\x0b\x32\x1e.wool._protobuf.task.ExceptionH\x00\x42\t\n\x07payload\"\x05\n\x03\x41\x63k\"\x16\n\x04Nack\x12\x0e\n\x06reason\x18\x01 \x01(\t\"\x1e\n\x0bStopRequest\x12\x0f\n\x07timeout\x18\x01 \x01(\x02\"\x06\n\x04Void2\x9b\x01\n\x06Worker\x12H\n\x08\x64ispatch\x12\x19.wool._protobuf.task.Task\x1a\x1f.wool._protobuf.worker.Response0\x01\x12G\n\x04stop\x12\".wool._protobuf.worker.StopRequest\x1a\x1b.wool._protobuf.worker.Voidb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -39,9 +39,9 @@ if not _descriptor._USE_C_DESCRIPTORS:
   _globals['_NACK']._serialized_start=270
   _globals['_NACK']._serialized_end=292
   _globals['_STOPREQUEST']._serialized_start=294
-  _globals['_STOPREQUEST']._serialized_end=321
-  _globals['_VOID']._serialized_start=323
-  _globals['_VOID']._serialized_end=329
-  _globals['_WORKER']._serialized_start=332
-  _globals['_WORKER']._serialized_end=487
+  _globals['_STOPREQUEST']._serialized_end=324
+  _globals['_VOID']._serialized_start=326
+  _globals['_VOID']._serialized_end=332
+  _globals['_WORKER']._serialized_start=335
+  _globals['_WORKER']._serialized_end=490
 # @@protoc_insertion_point(module_scope)

{wool-0.1rc14 → wool-0.1rc15}/wool/_protobuf/worker_pb2.pyi

@@ -29,10 +29,10 @@ class Nack(_message.Message):
     def __init__(self, reason: _Optional[str] = ...) -> None: ...
 
 class StopRequest(_message.Message):
-    __slots__ = ("wait",)
-    WAIT_FIELD_NUMBER: _ClassVar[int]
-    wait: int
-    def __init__(self, wait: _Optional[int] = ...) -> None: ...
+    __slots__ = ("timeout",)
+    TIMEOUT_FIELD_NUMBER: _ClassVar[int]
+    timeout: float
+    def __init__(self, timeout: _Optional[float] = ...) -> None: ...
 
 class Void(_message.Message):
     __slots__ = ()

{wool-0.1rc14 → wool-0.1rc15}/wool/_protobuf/worker_pb2_grpc.py

@@ -6,7 +6,7 @@ import warnings
 from . import task_pb2 as task__pb2
 from . import worker_pb2 as worker__pb2
 
-GRPC_GENERATED_VERSION = '1.75.1'
+GRPC_GENERATED_VERSION = '1.76.0'
 GRPC_VERSION = grpc.__version__
 _version_not_supported = False
 
@@ -19,7 +19,7 @@ except ImportError:
 if _version_not_supported:
     raise RuntimeError(
         f'The grpc package installed is at version {GRPC_VERSION},'
-        + f' but the generated code in worker_pb2_grpc.py depends on'
+        + ' but the generated code in worker_pb2_grpc.py depends on'
         + f' grpcio>={GRPC_GENERATED_VERSION}.'
         + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
         + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'

{wool-0.1rc14 → wool-0.1rc15}/wool/_resource_pool.py

@@ -25,7 +25,7 @@ class Resource(Generic[T]):
     released again.
 
     :param pool:
-        The :py:class:`ResourcePool` this resource belongs to.
+        The :class:`ResourcePool` this resource belongs to.
     :param key:
         The cache key for this resource.
     """
@@ -185,7 +185,7 @@ class ResourcePool(Generic[T]):
             when not concurrently modifying the cache.
 
         :returns:
-            :py:class:`ResourcePool.Stats` containing current statistics.
+            :class:`ResourcePool.Stats` containing current statistics.
         """
         pending_cleanup = sum(
             1 for c in self.pending_cleanup.values() if c is not None and not c.done()
@@ -219,7 +219,7 @@ class ResourcePool(Generic[T]):
         :param key:
             The cache key.
         :returns:
-            :py:class:`Resource` that can be awaited or used with 'async with'.
+            :class:`Resource` that can be awaited or used with 'async with'.
         """
         return Resource(self, key)
 

wool-0.1rc15/wool/_undefined.py

@@ -0,0 +1,11 @@
+from enum import Enum
+from typing import Final
+from typing import final
+
+
+@final
+class UndefinedType(Enum):
+    Undefined = "Undefined"
+
+
+Undefined: Final = UndefinedType.Undefined