wool 0.1rc20__py3-none-any.whl → 0.1rc22__py3-none-any.whl

wool/__init__.py

@@ -5,15 +5,22 @@ from typing import Final
 
 from tblib import pickling_support
 
-from wool._context import AppContext
-from wool._resource_pool import ResourcePool
-from wool._work import WoolTask
-from wool._work import WoolTaskEvent
-from wool._work import WoolTaskEventCallback
-from wool._work import WoolTaskEventType
-from wool._work import WoolTaskException
-from wool._work import current_task as wool_current_task
-from wool._work import work
+from wool.core.context import RuntimeContext
+from wool.core.resourcepool import ResourcePool
+from wool.core.work import WorkTask
+from wool.core.work import WorkTaskEvent
+from wool.core.work import WorkTaskEventCallback
+from wool.core.work import WorkTaskEventType
+from wool.core.work import WorkTaskException
+from wool.core.work import current_task
+from wool.core.work import work
+
+# Backward compatibility aliases (deprecated)
+WoolTask = WorkTask
+WoolTaskEvent = WorkTaskEvent
+WoolTaskEventCallback = WorkTaskEventCallback
+WoolTaskEventType = WorkTaskEventType
+WoolTaskException = WorkTaskException
 from wool.core.discovery.base import Discovery
 from wool.core.discovery.base import DiscoveryEvent
 from wool.core.discovery.base import DiscoveryEventType
@@ -65,22 +72,28 @@ __all__ = [
     "UnexpectedResponse",
     "WorkerConnection",
     # Context
-    "AppContext",
+    "RuntimeContext",
     # Load balancing
     "ConnectionResourceFactory",
     "LoadBalancerContext",
     "LoadBalancerLike",
     "NoWorkersAvailable",
     "RoundRobinLoadBalancer",
-    # Work
+    # Work - New names (preferred)
+    "WorkTask",
+    "WorkTaskEvent",
+    "WorkTaskEventCallback",
+    "WorkTaskEventType",
+    "WorkTaskException",
+    "current_task",
+    "routine",
+    "work",
+    # Work - Backward compatibility (deprecated)
     "WoolTask",
     "WoolTaskEvent",
     "WoolTaskEventCallback",
     "WoolTaskEventType",
     "WoolTaskException",
-    "routine",
-    "work",
-    "wool_current_task",
     # Workers
     "LocalWorker",
     "Worker",

wool/{_context.py → core/context.py}

@@ -2,16 +2,16 @@ from contextvars import ContextVar
 from contextvars import Token
 from typing import Final
 
-from wool._undefined import Undefined
-from wool._undefined import UndefinedType
+from wool.core.typing import Undefined
+from wool.core.typing import UndefinedType
 
 dispatch_timeout: Final[ContextVar[float | None]] = ContextVar(
-    "_dispatch_timeout", default=None
+    "dispatch_timeout", default=None
 )
 
 
 # public
-class AppContext:
+class RuntimeContext:
     _dispatch_timeout: float | None | UndefinedType
     _dispatch_timeout_token: Token | UndefinedType
 

wool/core/discovery/local.py

@@ -21,7 +21,6 @@ from watchdog.events import FileSystemEvent
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
 
-from wool._resource_pool import ResourcePool
 from wool.core.discovery.base import Discovery
 from wool.core.discovery.base import DiscoveryEvent
 from wool.core.discovery.base import DiscoveryEventType
@@ -30,6 +29,7 @@ from wool.core.discovery.base import DiscoverySubscriberLike
 from wool.core.discovery.base import PredicateFunction
 from wool.core.discovery.base import WorkerInfo
 from wool.core.protobuf.worker import WorkerInfo as WorkerInfoProtobuf
+from wool.core.resourcepool import ResourcePool
 
 REF_WIDTH: Final = 16
 NULL_REF: Final = b"\x00" * REF_WIDTH

wool/core/loadbalancer/base.py

@@ -9,12 +9,12 @@ from typing import Protocol
 from typing import TypeAlias
 from typing import runtime_checkable
 
-from wool._resource_pool import Resource
 from wool.core.discovery.base import WorkerInfo
+from wool.core.resourcepool import Resource
 from wool.core.worker.connection import WorkerConnection
 
 if TYPE_CHECKING:
-    from wool._work import WoolTask
+    from wool.core.work import WorkTask
 
 
 # public
@@ -40,13 +40,13 @@ class LoadBalancerLike(Protocol):
     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
+    The dispatch method accepts a :class:`WorkTask` and returns an async
     iterator that yields task results from the worker.
     """
 
     async def dispatch(
         self,
-        task: WoolTask,
+        task: WorkTask,
         *,
         context: LoadBalancerContext,
         timeout: float | None = None,

wool/core/loadbalancer/roundrobin.py

@@ -12,7 +12,7 @@ from .base import LoadBalancerLike
 from .base import NoWorkersAvailable
 
 if TYPE_CHECKING:
-    from wool._work import WoolTask
+    from wool.core.work import WorkTask
 
 
 # public
@@ -37,7 +37,7 @@ class RoundRobinLoadBalancer(LoadBalancerLike):
 
     async def dispatch(
         self,
-        task: WoolTask,
+        task: WorkTask,
         *,
         context: LoadBalancerContext,
         timeout: float | None = None,
@@ -49,7 +49,7 @@ class RoundRobinLoadBalancer(LoadBalancerLike):
         removed from the context's worker list.
 
         :param task:
-            The :class:`WoolTask` instance to dispatch to the worker.
+            The :class:`WorkTask` instance to dispatch to the worker.
         :param context:
             The :class:`LoadBalancerContext` containing workers to dispatch to.
         :param timeout:

wool/core/protobuf/task_pb2.py

@@ -24,19 +24,19 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ntask.proto\x12\x17wool.core.protobuf.task\"s\n\x04Task\x12\n\n\x02id\x18\x01 \x01(\t\x12\x10\n\x08\x63\x61llable\x18\x02 \x01(\x0c\x12\x0c\n\x04\x61rgs\x18\x03 \x01(\x0c\x12\x0e\n\x06kwargs\x18\x04 \x01(\x0c\x12\x0e\n\x06\x63\x61ller\x18\x05 \x01(\t\x12\r\n\x05proxy\x18\x07 \x01(\x0c\x12\x10\n\x08proxy_id\x18\x08 \x01(\t\"\x16\n\x06Result\x12\x0c\n\x04\x64ump\x18\x01 \x01(\x0c\"\x19\n\tException\x12\x0c\n\x04\x64ump\x18\x01 \x01(\x0c\"%\n\x06Worker\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\tb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ntask.proto\x12\x17wool.core.protobuf.task\"\xc6\x01\n\x04Task\x12\n\n\x02id\x18\x01 \x01(\t\x12\x10\n\x08\x63\x61llable\x18\x02 \x01(\x0c\x12\x0c\n\x04\x61rgs\x18\x03 \x01(\x0c\x12\x0e\n\x06kwargs\x18\x04 \x01(\x0c\x12\x0e\n\x06\x63\x61ller\x18\x05 \x01(\t\x12\r\n\x05proxy\x18\x07 \x01(\x0c\x12\x10\n\x08proxy_id\x18\x08 \x01(\t\x12\x0f\n\x07timeout\x18\t \x01(\x05\x12\x10\n\x08\x66ilename\x18\n \x01(\t\x12\x10\n\x08\x66unction\x18\x0b \x01(\t\x12\x0f\n\x07line_no\x18\x0c \x01(\x05\x12\x0b\n\x03tag\x18\r \x01(\t\"\x16\n\x06Result\x12\x0c\n\x04\x64ump\x18\x01 \x01(\x0c\"\x19\n\tException\x12\x0c\n\x04\x64ump\x18\x01 \x01(\x0c\"%\n\x06Worker\x12\n\n\x02id\x18\x01 \x01(\t\x12\x0f\n\x07\x61\x64\x64ress\x18\x02 \x01(\tb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
 _builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'task_pb2', _globals)
 if not _descriptor._USE_C_DESCRIPTORS:
   DESCRIPTOR._loaded_options = None
-  _globals['_TASK']._serialized_start=39
-  _globals['_TASK']._serialized_end=154
-  _globals['_RESULT']._serialized_start=156
-  _globals['_RESULT']._serialized_end=178
-  _globals['_EXCEPTION']._serialized_start=180
-  _globals['_EXCEPTION']._serialized_end=205
-  _globals['_WORKER']._serialized_start=207
-  _globals['_WORKER']._serialized_end=244
+  _globals['_TASK']._serialized_start=40
+  _globals['_TASK']._serialized_end=238
+  _globals['_RESULT']._serialized_start=240
+  _globals['_RESULT']._serialized_end=262
+  _globals['_EXCEPTION']._serialized_start=264
+  _globals['_EXCEPTION']._serialized_end=289
+  _globals['_WORKER']._serialized_start=291
+  _globals['_WORKER']._serialized_end=328
 # @@protoc_insertion_point(module_scope)

wool/core/protobuf/task_pb2.pyi

@@ -5,7 +5,7 @@ from typing import ClassVar as _ClassVar, Optional as _Optional
 DESCRIPTOR: _descriptor.FileDescriptor
 
 class Task(_message.Message):
-    __slots__ = ("id", "callable", "args", "kwargs", "caller", "proxy", "proxy_id")
+    __slots__ = ("id", "callable", "args", "kwargs", "caller", "proxy", "proxy_id", "timeout", "filename", "function", "line_no", "tag")
     ID_FIELD_NUMBER: _ClassVar[int]
     CALLABLE_FIELD_NUMBER: _ClassVar[int]
     ARGS_FIELD_NUMBER: _ClassVar[int]
@@ -13,6 +13,11 @@ class Task(_message.Message):
     CALLER_FIELD_NUMBER: _ClassVar[int]
     PROXY_FIELD_NUMBER: _ClassVar[int]
     PROXY_ID_FIELD_NUMBER: _ClassVar[int]
+    TIMEOUT_FIELD_NUMBER: _ClassVar[int]
+    FILENAME_FIELD_NUMBER: _ClassVar[int]
+    FUNCTION_FIELD_NUMBER: _ClassVar[int]
+    LINE_NO_FIELD_NUMBER: _ClassVar[int]
+    TAG_FIELD_NUMBER: _ClassVar[int]
     id: str
     callable: bytes
     args: bytes
@@ -20,7 +25,12 @@ class Task(_message.Message):
     caller: str
     proxy: bytes
     proxy_id: str
-    def __init__(self, id: _Optional[str] = ..., callable: _Optional[bytes] = ..., args: _Optional[bytes] = ..., kwargs: _Optional[bytes] = ..., caller: _Optional[str] = ..., proxy: _Optional[bytes] = ..., proxy_id: _Optional[str] = ...) -> None: ...
+    timeout: int
+    filename: str
+    function: str
+    line_no: int
+    tag: str
+    def __init__(self, id: _Optional[str] = ..., callable: _Optional[bytes] = ..., args: _Optional[bytes] = ..., kwargs: _Optional[bytes] = ..., caller: _Optional[str] = ..., proxy: _Optional[bytes] = ..., proxy_id: _Optional[str] = ..., timeout: _Optional[int] = ..., filename: _Optional[str] = ..., function: _Optional[str] = ..., line_no: _Optional[int] = ..., tag: _Optional[str] = ...) -> None: ...
 
 class Result(_message.Message):
     __slots__ = ("dump",)

wool/{_resource_pool.py → core/resourcepool.py}

@@ -5,15 +5,14 @@ from dataclasses import dataclass
 from typing import Any
 from typing import Awaitable
 from typing import Callable
-from typing import Final
 from typing import Generic
 from typing import TypeVar
 from typing import cast
 
-T = TypeVar("T")
-
+from wool.core.typing import Undefined
+from wool.core.typing import UndefinedType
 
-SENTINEL: Final = object()
+T = TypeVar("T")
 
 
 class Resource(Generic[T]):
@@ -286,15 +285,15 @@ class ResourcePool(Generic[T]):
                     # Immediate cleanup
                     await self._cleanup(key)
 
-    async def clear(self, key=SENTINEL) -> None:
+    async def clear(self, key: Any | UndefinedType = Undefined) -> None:
         """Clear cache entries and cancel pending cleanups.
 
         :param key:
-            Specific key to clear, or SENTINEL to clear all entries.
+            Specific key to clear (clears all entries if not specified).
         """
         async with self._lock:
             # Clean up all entries
-            if key is SENTINEL:
+            if key is Undefined:
                 keys = list(self._cache.keys())
             else:
                 keys = [key]

wool/core/typing.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from enum import Enum
 from typing import AsyncContextManager
 from typing import Awaitable
 from typing import Callable
@@ -7,9 +8,23 @@ from typing import ContextManager
 from typing import Final
 from typing import TypeAlias
 from typing import TypeVar
+from typing import final
+
+F = TypeVar("F", bound=Callable)
+W = TypeVar("W", bound=Callable)
+Wrapper = Callable[[F], W]
+PassthroughWrapper = Callable[[F], F]
+
+
+@final
+class UndefinedType(Enum):
+    Undefined = "Undefined"
 
-T_CO: Final = TypeVar("T_CO", covariant=True)
 
+Undefined: Final = UndefinedType.Undefined
+
+
+T_CO: Final = TypeVar("T_CO", covariant=True)
 
 # public
 Factory: TypeAlias = (

wool/core/work/__init__.py

@@ -0,0 +1,24 @@
+"""Core work distribution functionality.
+
+This module provides task decoration, execution context, and task classes.
+"""
+
+from wool.core.work.task import WorkTask
+from wool.core.work.task import WorkTaskEvent
+from wool.core.work.task import WorkTaskEventCallback
+from wool.core.work.task import WorkTaskEventType
+from wool.core.work.task import WorkTaskException
+from wool.core.work.task import current_task
+from wool.core.work.wrapper import routine
+from wool.core.work.wrapper import work
+
+__all__ = [
+    "WorkTask",
+    "WorkTaskEvent",
+    "WorkTaskEventCallback",
+    "WorkTaskEventType",
+    "WorkTaskException",
+    "current_task",
+    "routine",
+    "work",
+]

wool/{_work.py → core/work/task.py}

@@ -1,7 +1,12 @@
+"""Task execution and lifecycle management.
+
+This module contains classes and functions for managing distributed task
+execution, including WorkTask, WorkTaskEvent, and related functionality.
+"""
+
 from __future__ import annotations
 
 import asyncio
-import inspect
 import logging
 import traceback
 from collections.abc import Callable
@@ -9,205 +14,36 @@ from contextvars import Context
 from contextvars import ContextVar
 from dataclasses import dataclass
 from functools import wraps
-from sys import modules
 from time import perf_counter_ns
-from types import ModuleType
 from types import TracebackType
 from typing import TYPE_CHECKING
 from typing import Coroutine
 from typing import Dict
 from typing import Literal
-from typing import ParamSpec
 from typing import Protocol
 from typing import SupportsInt
 from typing import Tuple
-from typing import Type
-from typing import TypeVar
-from typing import cast
 from uuid import UUID
-from uuid import uuid4
 
 import cloudpickle
 
 import wool
-from wool import _context as ctx
-from wool._typing import PassthroughDecorator
 from wool.core import protobuf as pb
+from wool.core.typing import PassthroughWrapper
 
 if TYPE_CHECKING:
     from wool.core.worker.proxy import WorkerProxy
 
 AsyncCallable = Callable[..., Coroutine]
-C = TypeVar("C", bound=AsyncCallable)
-
 Args = Tuple
 Kwargs = Dict
 Timeout = SupportsInt
 Timestamp = SupportsInt
 
 
-# public
-def work(fn: C) -> C:
-    """Decorator to declare an asynchronous function as remotely executable.
-
-    Converts an asynchronous function into a distributed task that can be
-    executed by a worker pool. When the decorated function is invoked, it
-    is dispatched to the worker pool associated with the current worker
-    pool session context.
-
-    :param fn:
-        The asynchronous function to convert into a distributed routine.
-    :returns:
-        The decorated function that dispatches to the worker pool when
-        called.
-    :raises ValueError:
-        If the decorated function is not a coroutine function.
-
-    .. note::
-        Decorated functions behave like regular coroutines and can
-        be awaited and cancelled normally. Task execution occurs
-        transparently across the distributed worker pool.
-
-    Best practices and considerations for designing tasks:
-
-    1. **Picklability**: Arguments and return values must be picklable for
-       serialization between processes. Avoid unpicklable objects like
-       open file handles, database connections, or lambda functions.
-       Custom objects should implement ``__getstate__`` and
-       ``__setstate__`` methods if needed.
-
-    2. **Synchronization**: Tasks are not guaranteed to execute on the
-       same process between invocations. Standard :mod:`asyncio`
-       synchronization primitives will not work across processes.
-       Use file-based or other distributed synchronization utilities.
-
-    3. **Statelessness**: Design tasks to be stateless and idempotent.
-       Avoid global variables or shared mutable state to ensure
-       predictable behavior and enable safe retries.
-
-    4. **Cancellation**: Task cancellation behaves like standard Python
-       coroutine cancellation and is properly propagated across the
-       distributed system.
-
-    5. **Error propagation**: Unhandled exceptions raised within tasks are
-       transparently propagated to the caller as they would be normally.
-
-    6. **Performance**: Minimize argument and return value sizes to reduce
-       serialization overhead. For large datasets, consider using shared
-       memory or passing references instead of the data itself.
-
-    Example usage:
-
-    .. code-block:: python
-
-        import wool
-
-
-        @wool.work
-        async def fibonacci(n: int) -> int:
-            if n <= 1:
-                return n
-            return await fibonacci(n - 1) + await fibonacci(n - 2)
-
-
-        async def main():
-            async with wool.WorkerPool():
-                result = await fibonacci(10)
-    """
-    if not inspect.iscoroutinefunction(fn):
-        raise ValueError("Expected a coroutine function")
-
-    @wraps(fn)
-    def wrapper(*args, **kwargs) -> Coroutine:
-        # Handle static and class methods in a picklable way.
-        parent, function = _resolve(fn)
-        assert parent is not None
-        assert callable(function)
-
-        if _do_dispatch.get():
-            proxy = wool.__proxy__.get()
-            assert proxy
-            stream = _dispatch(
-                proxy,
-                wrapper.__module__,
-                wrapper.__qualname__,
-                function,
-                *args,
-                **kwargs,
-            )
-            if inspect.iscoroutinefunction(fn):
-                return _stream_to_coroutine(stream)
-            else:
-                raise ValueError("Expected a coroutine function")
-        else:
-            return _execute(fn, parent, *args, **kwargs)
-
-    return cast(C, wrapper)
-
-
-routine = work
-
-
-def _dispatch(
-    proxy: WorkerProxy,
-    module: str,
-    qualname: str,
-    function: AsyncCallable,
-    *args,
-    **kwargs,
-):
-    # Skip self argument if function is a method.
-    args = args[1:] if hasattr(function, "__self__") else args
-    signature = ", ".join(
-        (
-            *(repr(v) for v in args),
-            *(f"{k}={repr(v)}" for k, v in kwargs.items()),
-        )
-    )
-    task = WoolTask(
-        id=uuid4(),
-        callable=function,
-        args=args,
-        kwargs=kwargs,
-        tag=f"{module}.{qualname}({signature})",
-        proxy=proxy,
-    )
-    return proxy.dispatch(task, timeout=ctx.dispatch_timeout.get())
-
-
-async def _execute(fn: AsyncCallable, parent, *args, **kwargs):
-    token = _do_dispatch.set(True)
-    try:
-        if isinstance(fn, classmethod):
-            return await fn.__func__(parent, *args, **kwargs)
-        else:
-            return await fn(*args, **kwargs)
-    finally:
-        _do_dispatch.reset(token)
-
-
-async def _stream_to_coroutine(stream):
-    result = None
-    async for result in await stream:
-        continue
-    return result
-
-
-# public
-def current_task() -> WoolTask | None:
-    """
-    Get the current task from the context variable if we are inside a task
-    context, otherwise return None.
-
-    :returns:
-        The current task or None if no task is active.
-    """
-    return _current_task.get()
-
-
 # public
 @dataclass
-class WoolTask:
+class WorkTask:
     """
     Represents a distributed task to be executed in the worker pool.
 
@@ -249,7 +85,7 @@ class WoolTask:
     proxy: WorkerProxy
     timeout: Timeout = 0
     caller: UUID | None = None
-    exception: WoolTaskException | None = None
+    exception: WorkTaskException | None = None
     filename: str | None = None
     function: str | None = None
     line_no: int | None = None
@@ -267,7 +103,7 @@ class WoolTask:
         """
         if caller := _current_task.get():
             self.caller = caller.id
-        WoolTaskEvent("task-created", task=self).emit()
+        WorkTaskEvent("task-created", task=self).emit()
 
     def __enter__(self) -> Callable[[], Coroutine]:
         """
@@ -303,7 +139,7 @@ class WoolTask:
         if exception_value:
             this = asyncio.current_task()
             assert this
-            self.exception = WoolTaskException(
+            self.exception = WorkTaskException(
                 exception_type.__qualname__,
                 traceback=[
                     y
@@ -318,7 +154,7 @@ class WoolTask:
         return False
 
     @classmethod
-    def from_protobuf(cls, task: pb.task.Task) -> WoolTask:
+    def from_protobuf(cls, task: pb.task.Task) -> WorkTask:
         return cls(
             id=UUID(task.id),
             callable=cloudpickle.loads(task.callable),
@@ -326,6 +162,11 @@ class WoolTask:
             kwargs=cloudpickle.loads(task.kwargs),
             caller=UUID(task.caller) if task.caller else None,
             proxy=cloudpickle.loads(task.proxy),
+            timeout=task.timeout if task.timeout else 0,
+            filename=task.filename if task.filename else None,
+            function=task.function if task.function else None,
+            line_no=task.line_no if task.line_no else None,
+            tag=task.tag if task.tag else None,
         )
 
     def to_protobuf(self) -> pb.task.Task:
@@ -337,6 +178,11 @@ class WoolTask:
             caller=str(self.caller) if self.caller else "",
             proxy=cloudpickle.dumps(self.proxy),
             proxy_id=str(self.proxy.id),
+            timeout=self.timeout if self.timeout else 0,
+            filename=self.filename if self.filename else "",
+            function=self.function if self.function else "",
+            line_no=self.line_no if self.line_no else 0,
+            tag=self.tag if self.tag else "",
         )
 
     async def run(self) -> Coroutine:
@@ -346,10 +192,11 @@ class WoolTask:
         :returns:
             A coroutine representing the routine execution.
         :raises RuntimeError:
-            If no proxy is available for task execution.
+            If no proxy pool is available for task execution.
         """
         proxy_pool = wool.__proxy_pool__.get()
-        assert proxy_pool
+        if not proxy_pool:
+            raise RuntimeError("No proxy pool available for task execution")
         async with proxy_pool.get(self.proxy) as proxy:
             # Set the proxy in context variable for nested task dispatch
             token = wool.__proxy__.set(proxy)
@@ -360,30 +207,28 @@ class WoolTask:
                 wool.__proxy__.reset(token)
 
     def _finish(self, _):
-        WoolTaskEvent("task-completed", task=self).emit()
+        WorkTaskEvent("task-completed", task=self).emit()
 
     def _with_self(self, fn: AsyncCallable) -> AsyncCallable:
         @wraps(fn)
         async def wrapper(*args, **kwargs):
             with self:
                 current_task_token = _current_task.set(self)
-                # Do not re-submit this task, execute it locally
-                local_token = _do_dispatch.set(False)
                 # Yield to event loop with context set
                 await asyncio.sleep(0)
                 try:
-                    result = await fn(*args, **kwargs)
+                    # Execute as worker without re-dispatching
+                    result = await execute_as_worker(fn)(*args, **kwargs)
                     return result
                 finally:
                     _current_task.reset(current_task_token)
-                    _do_dispatch.reset(local_token)
 
         return wrapper
 
 
 # public
 @dataclass
-class WoolTaskException:
+class WorkTaskException:
     """
     Represents an exception that occurred during distributed task execution.
 
@@ -402,7 +247,7 @@ class WoolTaskException:
 
 
 # public
-class WoolTaskEvent:
+class WorkTaskEvent:
     """
     Represents a lifecycle event for a distributed task.
 
@@ -413,30 +258,30 @@ class WoolTaskEvent:
     :param type:
         The type of task event (e.g., "task-created", "task-scheduled").
     :param task:
-        The :class:`WoolTask` instance associated with this event.
+        The :class:`WorkTask` instance associated with this event.
     """
 
-    type: WoolTaskEventType
-    task: WoolTask
+    type: WorkTaskEventType
+    task: WorkTask
 
-    _handlers: dict[str, list[WoolTaskEventCallback]] = {}
+    _handlers: dict[str, list[WorkTaskEventCallback]] = {}
 
-    def __init__(self, type: WoolTaskEventType, /, task: WoolTask) -> None:
+    def __init__(self, type: WorkTaskEventType, /, task: WorkTask) -> None:
         """
-        Initialize a WoolTaskEvent instance.
+        Initialize a WorkTaskEvent instance.
 
         :param type:
             The type of the task event.
         :param task:
-            The :class:`WoolTask` instance associated with the event.
+            The :class:`WorkTask` instance associated with the event.
         """
         self.type = type
         self.task = task
 
     @classmethod
     def handler(
-        cls, *event_types: WoolTaskEventType
-    ) -> PassthroughDecorator[WoolTaskEventCallback]:
+        cls, *event_types: WorkTaskEventType
+    ) -> PassthroughWrapper[WorkTaskEventCallback]:
         """
         Register a handler function for specific task event types.
 
@@ -447,8 +292,8 @@ class WoolTaskEvent:
         """
 
         def _handler(
-            fn: WoolTaskEventCallback,
-        ) -> WoolTaskEventCallback:
+            fn: WorkTaskEventCallback,
+        ) -> WorkTaskEventCallback:
             for event_type in event_types:
                 cls._handlers.setdefault(event_type, []).append(fn)
             return fn
@@ -477,7 +322,7 @@ class WoolTaskEvent:
 
 
 # public
-WoolTaskEventType = Literal[
+WorkTaskEventType = Literal[
     "task-created",
     "task-queued",
     "task-scheduled",
@@ -486,47 +331,62 @@ WoolTaskEventType = Literal[
     "task-completed",
 ]
 """
-Defines the types of events that can occur during the lifecycle of a Wool 
+Defines the types of events that can occur during the lifecycle of a Wool
 task.
 
-- "task-created": 
+- "task-created":
     Emitted when a task is created.
-- "task-queued": 
+- "task-queued":
     Emitted when a task is added to the queue.
-- "task-scheduled": 
+- "task-scheduled":
     Emitted when a task is scheduled for execution in a worker's event
     loop.
-- "task-started": 
+- "task-started":
     Emitted when a task starts execution.
-- "task-stopped": 
+- "task-stopped":
     Emitted when a task stops execution.
-- "task-completed": 
+- "task-completed":
     Emitted when a task completes execution.
 """
 
 
 # public
-class WoolTaskEventCallback(Protocol):
+class WorkTaskEventCallback(Protocol):
     """
-    Protocol for WoolTaskEvent callback functions.
+    Protocol for WorkTaskEvent callback functions.
     """
 
-    def __call__(self, event: WoolTaskEvent, timestamp: Timestamp) -> None: ...
+    def __call__(self, event: WorkTaskEvent, timestamp: Timestamp) -> None: ...
 
 
-_do_dispatch: ContextVar[bool] = ContextVar("_do_dispatch", default=True)
-_current_task: ContextVar[WoolTask | None] = ContextVar("_current_task", default=None)
+# Import from wrapper module (after class definitions to avoid circular import issues)
+from wool.core.work.wrapper import _do_dispatch  # noqa: E402
+from wool.core.work.wrapper import execute_as_worker  # noqa: E402
+
+_current_task: ContextVar[WorkTask | None] = ContextVar("_current_task", default=None)
+
+
+# public
+def current_task() -> WorkTask | None:
+    """
+    Get the current task from the context variable if we are inside a task
+    context, otherwise return None.
+
+    :returns:
+        The current task or None if no task is active.
+    """
+    return _current_task.get()
 
 
 def _run(fn):
     @wraps(fn)
     def wrapper(self, *args, **kwargs):
         if current_task := self._context.get(_current_task):
-            WoolTaskEvent("task-started", task=current_task).emit()
+            WorkTaskEvent("task-started", task=current_task).emit()
             try:
                 result = fn(self, *args, **kwargs)
             finally:
-                WoolTaskEvent("task-stopped", task=current_task).emit()
+                WorkTaskEvent("task-stopped", task=current_task).emit()
             return result
         else:
             return fn(self, *args, **kwargs)
@@ -535,20 +395,3 @@ def _run(fn):
 
 
 asyncio.Handle._run = _run(asyncio.Handle._run)
-
-
-P = ParamSpec("P")
-R = TypeVar("R")
-
-
-def _resolve(
-    method: Callable[P, R],
-) -> Tuple[Type | ModuleType | None, Callable[P, R]]:
-    scope = modules[method.__module__]
-    parent = None
-    for name in method.__qualname__.split("."):
-        parent = scope
-        scope = getattr(scope, name)
-        assert scope
-    assert isinstance(parent, (Type, ModuleType))
-    return parent, cast(Callable[P, R], scope)

wool/core/work/wrapper.py

@@ -0,0 +1,220 @@
+"""Task decorator and dispatch logic.
+
+This module contains the @work decorator and related functions for converting
+async functions into distributed tasks.
+"""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from contextvars import ContextVar
+from functools import wraps
+from sys import modules
+from types import ModuleType
+from typing import TYPE_CHECKING
+from typing import Coroutine
+from typing import ParamSpec
+from typing import Tuple
+from typing import Type
+from typing import TypeVar
+from typing import cast
+from uuid import uuid4
+
+import wool
+from wool.core import context as ctx
+from wool.core.work.task import AsyncCallable
+from wool.core.work.task import WorkTask
+
+if TYPE_CHECKING:
+    from wool.core.worker.proxy import WorkerProxy
+
+C = TypeVar("C", bound=AsyncCallable)
+P = ParamSpec("P")
+R = TypeVar("R")
+
+# Context variable for controlling dispatch behavior
+_do_dispatch: ContextVar[bool] = ContextVar("_do_dispatch", default=True)
+
+
+# public
+def work(fn: C) -> C:
+    """Decorator to declare an asynchronous function as remotely executable.
+
+    Converts an asynchronous function into a distributed task that can be
+    executed by a worker pool. When the decorated function is invoked, it
+    is dispatched to the worker pool associated with the current worker
+    pool session context.
+
+    :param fn:
+        The asynchronous function to convert into a distributed routine.
+    :returns:
+        The decorated function that dispatches to the worker pool when
+        called.
+    :raises ValueError:
+        If the decorated function is not a coroutine function.
+
+    .. note::
+        Decorated functions behave like regular coroutines and can
+        be awaited and cancelled normally. Task execution occurs
+        transparently across the distributed worker pool.
+
+    Best practices and considerations for designing tasks:
+
+    1. **Picklability**: Arguments and return values must be picklable for
+       serialization between processes. Avoid unpicklable objects like
+       open file handles, database connections, or lambda functions.
+       Custom objects should implement ``__getstate__`` and
+       ``__setstate__`` methods if needed.
+
+    2. **Synchronization**: Tasks are not guaranteed to execute on the
+       same process between invocations. Standard :mod:`asyncio`
+       synchronization primitives will not work across processes.
+       Use file-based or other distributed synchronization utilities.
+
+    3. **Statelessness**: Design tasks to be stateless and idempotent.
+       Avoid global variables or shared mutable state to ensure
+       predictable behavior and enable safe retries.
+
+    4. **Cancellation**: Task cancellation behaves like standard Python
+       coroutine cancellation and is properly propagated across the
+       distributed system.
+
+    5. **Error propagation**: Unhandled exceptions raised within tasks are
+       transparently propagated to the caller as they would be normally.
+
+    6. **Performance**: Minimize argument and return value sizes to reduce
+       serialization overhead. For large datasets, consider using shared
+       memory or passing references instead of the data itself.
+
+    Example usage:
+
+    .. code-block:: python
+
+        import wool
+
+
+        @wool.work
+        async def fibonacci(n: int) -> int:
+            if n <= 1:
+                return n
+            return await fibonacci(n - 1) + await fibonacci(n - 2)
+
+
+        async def main():
+            async with wool.WorkerPool():
+                result = await fibonacci(10)
+    """
+    if not inspect.iscoroutinefunction(fn):
+        raise ValueError("Expected a coroutine function")
+
+    @wraps(fn)
+    def wrapper(*args, **kwargs) -> Coroutine:
+        # Handle static and class methods in a picklable way.
+        parent, function = _resolve(fn)
+        assert parent is not None
+        assert callable(function)
+
+        if _do_dispatch.get():
+            proxy = wool.__proxy__.get()
+            assert proxy
+            stream = _dispatch(
+                proxy,
+                wrapper.__module__,
+                wrapper.__qualname__,
+                function,
+                *args,
+                **kwargs,
+            )
+            if inspect.iscoroutinefunction(fn):
+                return _stream_to_coroutine(stream)
+            else:
+                raise ValueError("Expected a coroutine function")
+        else:
+            return _execute(fn, parent, *args, **kwargs)
+
+    return cast(C, wrapper)
+
+
+routine = work
+
+
+def execute_as_worker(fn: AsyncCallable):
+    """Execute a coroutine as a worker without re-dispatching.
+
+    This closure wraps a coroutine execution to run in worker mode,
+    preventing the task from being re-dispatched to the worker pool.
+    Used when executing tasks locally within a worker process.
+
+    :param fn:
+        The async callable to execute as a worker.
+    :returns:
+        A coroutine that executes the callable with dispatch disabled.
+    """
+
+    async def _executor(*args, **kwargs):
+        token = _do_dispatch.set(False)
+        try:
+            return await fn(*args, **kwargs)
+        finally:
+            _do_dispatch.reset(token)
+
+    return _executor
+
+
+def _dispatch(
+    proxy: WorkerProxy,
+    module: str,
+    qualname: str,
+    function: AsyncCallable,
+    *args,
+    **kwargs,
+):
+    # Skip self argument if function is a method.
+    args = args[1:] if hasattr(function, "__self__") else args
+    signature = ", ".join(
+        (
+            *(repr(v) for v in args),
+            *(f"{k}={repr(v)}" for k, v in kwargs.items()),
+        )
+    )
+    task = WorkTask(
+        id=uuid4(),
+        callable=function,
+        args=args,
+        kwargs=kwargs,
+        tag=f"{module}.{qualname}({signature})",
+        proxy=proxy,
+    )
+    return proxy.dispatch(task, timeout=ctx.dispatch_timeout.get())
+
+
+async def _execute(fn: AsyncCallable, parent, *args, **kwargs):
+    token = _do_dispatch.set(True)
+    try:
+        if isinstance(fn, classmethod):
+            return await fn.__func__(parent, *args, **kwargs)
+        else:
+            return await fn(*args, **kwargs)
+    finally:
+        _do_dispatch.reset(token)
+
+
+async def _stream_to_coroutine(stream):
+    result = None
+    async for result in await stream:
+        continue
+    return result
+
+
+def _resolve(
+    method: Callable[P, R],
+) -> Tuple[Type | ModuleType | None, Callable[P, R]]:
+    scope = modules[method.__module__]
+    parent = None
+    for name in method.__qualname__.split("."):
+        parent = scope
+        scope = getattr(scope, name)
+        assert scope
+    assert isinstance(parent, (Type, ModuleType))
+    return parent, cast(Callable[P, R], scope)

wool/core/worker/connection.py

@@ -10,8 +10,8 @@ from typing import TypeVar
 import cloudpickle
 import grpc.aio
 
-from wool._work import WoolTask
 from wool.core import protobuf as pb
+from wool.core.work import WorkTask
 
 _DispatchCall: TypeAlias = grpc.aio.UnaryStreamCall[pb.task.Task, pb.worker.Response]
 
@@ -161,7 +161,7 @@ class WorkerConnection:
 
     async def dispatch(
         self,
-        task: WoolTask,
+        task: WorkTask,
         *,
         timeout: float | None = None,
     ) -> AsyncIterator[pb.task.Result]:
@@ -173,7 +173,7 @@ class WorkerConnection:
         (semaphore acquisition and acknowledgment).
 
         :param task:
-            The :class:`WoolTask` instance to dispatch to the worker.
+            The :class:`WorkTask` 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

wool/core/worker/process.py

@@ -12,8 +12,8 @@ from typing import TYPE_CHECKING
 import grpc.aio
 
 import wool
-from wool._resource_pool import ResourcePool
 from wool.core import protobuf as pb
+from wool.core.resourcepool import ResourcePool
 from wool.core.worker.service import WorkerService
 
 if TYPE_CHECKING:

wool/core/worker/proxy.py

@@ -14,7 +14,6 @@ from typing import TypeVar
 from typing import overload
 
 import wool
-from wool._resource_pool import ResourcePool
 from wool.core.discovery.base import DiscoveryEvent
 from wool.core.discovery.base import DiscoverySubscriberLike
 from wool.core.discovery.base import WorkerInfo
@@ -22,11 +21,12 @@ from wool.core.discovery.local import LocalDiscovery
 from wool.core.loadbalancer.base import LoadBalancerContext
 from wool.core.loadbalancer.base import LoadBalancerLike
 from wool.core.loadbalancer.roundrobin import RoundRobinLoadBalancer
+from wool.core.resourcepool import ResourcePool
 from wool.core.typing import Factory
 from wool.core.worker.connection import WorkerConnection
 
 if TYPE_CHECKING:
-    from wool._work import WoolTask
+    from wool.core.work import WorkTask
 
 T = TypeVar("T")
 
@@ -348,7 +348,7 @@ class WorkerProxy:
         self._loadbalancer_context = None
         self._started = False
 
-    async def dispatch(self, task: WoolTask, *, timeout: float | None = None):
+    async def dispatch(self, task: WorkTask, *, timeout: float | None = None):
         """Dispatches a task to an available worker in the pool.
 
         This method selects a worker using a round-robin strategy. If no
@@ -356,7 +356,7 @@ class WorkerProxy:
         exception.
 
         :param task:
-            The :class:`WoolTask` object to be dispatched.
+            The :class:`WorkTask` object to be dispatched.
         :param timeout:
             Timeout in seconds for getting a worker.
         :returns:

wool/core/worker/service.py

@@ -9,9 +9,9 @@ from grpc import StatusCode
 from grpc.aio import ServicerContext
 
 import wool
-from wool._work import WoolTask
-from wool._work import WoolTaskEvent
 from wool.core import protobuf as pb
+from wool.core.work import WorkTask
+from wool.core.work import WorkTaskEvent
 
 
 class ReadOnlyEvent:
@@ -86,7 +86,7 @@ class WorkerService(pb.worker.WorkerServicer):
     ) -> AsyncIterator[pb.worker.Response]:
         """Execute a task in the current event loop.
 
-        Deserializes the incoming task into a :class:`WoolTask`
+        Deserializes the incoming task into a :class:`WorkTask`
         instance, schedules it for execution in the current asyncio
         event loop, and yields responses for acknowledgment and result.
 
@@ -100,7 +100,7 @@ class WorkerService(pb.worker.WorkerServicer):
             then yields a Response containing the task result.
 
         .. note::
-            Emits a :class:`WoolTaskEvent` when the task is
+            Emits a :class:`WorkTaskEvent` when the task is
             scheduled for execution.
         """
         if self._stopping.is_set():
@@ -108,7 +108,7 @@ class WorkerService(pb.worker.WorkerServicer):
                 StatusCode.UNAVAILABLE, "Worker service is shutting down"
             )
 
-        with self._tracker(WoolTask.from_protobuf(request)) as task:
+        with self._tracker(WorkTask.from_protobuf(request)) as task:
             try:
                 yield pb.worker.Response(ack=pb.worker.Ack())
                 try:
@@ -143,7 +143,7 @@ class WorkerService(pb.worker.WorkerServicer):
         return pb.worker.Void()
 
     @contextmanager
-    def _tracker(self, wool_task: WoolTask):
+    def _tracker(self, wool_task: WorkTask):
         """Context manager for tracking running tasks.
 
         Manages the lifecycle of a task execution, adding it to the
@@ -151,15 +151,15 @@ class WorkerService(pb.worker.WorkerServicer):
         proper cleanup when the task completes or fails.
 
         :param wool_task:
-            The :class:`WoolTask` instance to execute and track.
+            The :class:`WorkTask` instance to execute and track.
         :yields:
             The :class:`asyncio.Task` created for the wool task.
 
         .. note::
-            Emits a :class:`WoolTaskEvent` with type "task-scheduled"
+            Emits a :class:`WorkTaskEvent` with type "task-scheduled"
             when the task begins execution.
         """
-        WoolTaskEvent("task-scheduled", task=wool_task).emit()
+        WorkTaskEvent("task-scheduled", task=wool_task).emit()
         task = asyncio.create_task(wool_task.run())
         self._tasks.add(task)
         try:

{wool-0.1rc20.dist-info → wool-0.1rc22.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wool
-Version: 0.1rc20
+Version: 0.1rc22
 Summary: A Python framework for distributed multiprocessing.
 Author-email: Conrad Bzura <conrad@wool.io>
 Maintainer-email: maintainers@wool.io

wool-0.1rc22.dist-info/RECORD

@@ -0,0 +1,37 @@
+wool/__init__.py,sha256=RICe6LuFczMtfcJLFeGq0SJAuHbGdcYFZ_-P6-cVdo8,4263
+wool/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wool/core/context.py,sha256=xQAWxGaypUWkAoTcdEccvykJIG6CcTRiW51PGHwuHRI,936
+wool/core/resourcepool.py,sha256=TlYCYbdKm6zurTgZa9-SzeEmmub_me4EBW0xRtr0MSc,11608
+wool/core/typing.py,sha256=h0bYIl61e8qWL_Clkg2Hu7dhPIzOioVgPeNT4SOZyX8,805
+wool/core/discovery/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wool/core/discovery/base.py,sha256=yw3eKT4hVjBKYMJGGGorbkafRsodaSUJiKToKgCctrI,7103
+wool/core/discovery/lan.py,sha256=CbMf-cRsQQK_yaRcjl0y2EE6Qz_2vPmhHZ38P7pCths,20082
+wool/core/discovery/local.py,sha256=z1LSN9hncRGvrodRwzYn77Vjw2bfNaB4VSIZt_F4OvY,31167
+wool/core/loadbalancer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wool/core/loadbalancer/base.py,sha256=-pFYKQptoZNz-zNWaQ3J_RYcAZE0KwwSAWRsNl5vfnw,4040
+wool/core/loadbalancer/roundrobin.py,sha256=31ebR7gGlvSFC2r9ytWwj7n43VU-0vDHRZ74vT-DE18,3581
+wool/core/protobuf/__init__.py,sha256=61kDOGjPz9FwZpEygbItQdJY1y2QK-ogEtUtwvsOEZQ,435
+wool/core/protobuf/exception.py,sha256=rBm4bpWBt9Pq6Ry-WyxSG9RSE3FBuUt1JF-HBR0TK7w,174
+wool/core/protobuf/task.py,sha256=ZsKOCTPaPQ23n5koy3WTDSCLE0vcW8FWAJintaxm8H8,404
+wool/core/protobuf/task_pb2.py,sha256=SzhkWBkmTVCab7y2xPIVX8JYhy6EA4uTf-Z5lMfj9lg,2143
+wool/core/protobuf/task_pb2.pyi,sha256=QBno73GBloHk9OW7aU4RqyqOrdRHXZhPyYjeMo1-o-o,2085
+wool/core/protobuf/task_pb2_grpc.py,sha256=-be_fUpBt6g7xCvqVWnKZnzsYqYqu6IAk1wGV_1mWl8,884
+wool/core/protobuf/worker.py,sha256=dQwMBzeg1r-G667iYnJHwDQ4QaH43kYAeHTI5JGMpVM,845
+wool/core/protobuf/worker_pb2.py,sha256=Dgx8fO6bRA3n6FtipcpNOnTGXOhij2Eg5bp8wUDYWH8,3191
+wool/core/protobuf/worker_pb2.pyi,sha256=IXmVeIcdyWxZIa8LIqbGK4rpxOE_c7YHjBHtYq40psk,2633
+wool/core/protobuf/worker_pb2_grpc.py,sha256=X1J86-yaMVBilBfoDdXri8L4QtcEC5nnBpui9xB5Dnk,5015
+wool/core/work/__init__.py,sha256=0ntyhXGhF8GkuuWLnBhhYEJceXORwaInNUjxvplOTrY,669
+wool/core/work/task.py,sha256=Imf_Z7uXekX7BJBpctogat70D3c7jWMxUfGUsyyC77Y,12343
+wool/core/work/wrapper.py,sha256=jYe5Tp2iP30Y-9dZm746iMWpTlPlmQ2mCNIiL3lu4yI,6694
+wool/core/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+wool/core/worker/base.py,sha256=f-61cnyszmHkOITCSr2W3KAaRTZzd-XL7vI9i3yFjiM,8224
+wool/core/worker/connection.py,sha256=NjdXc6y8iWCIJvYY4BeggasZ46VnPDHmTqe8VUvcY1s,8265
+wool/core/worker/local.py,sha256=g1_CDXjFQHPGrBYK3DPMkMOSE64hJcW59lY8ckXTp3Y,4531
+wool/core/worker/pool.py,sha256=Y_JsJu3RPAT1YuPxY-gQ2sm9iRgaedlT0YHwuK31AlU,12629
+wool/core/worker/process.py,sha256=Xh_eBV8-8upOMfavZxw3NR-1gT3hWstLV290OdBf5rs,7844
+wool/core/worker/proxy.py,sha256=-ZupIc43tWWwy12DZJwfPrbuXq-R6zLTYzKs5ZTVTN8,14009
+wool/core/worker/service.py,sha256=hVY3wGR-YvxCX5q2aG4tyvkc4tXZnFGHgFdoE62n4jM,8146
+wool-0.1rc22.dist-info/METADATA,sha256=WhHZuds6ytXLnRo30J-6tCBsMIy0QkxzCtalgviSWQk,21064
+wool-0.1rc22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wool-0.1rc22.dist-info/entry_points.txt,sha256=U3V7wWNc3KLw4AOjJRpbcZcLJIdiA-7y1eqxn-Xa5rY,38
+wool-0.1rc22.dist-info/RECORD,,

wool/_protobuf/worker.py

@@ -1,26 +0,0 @@
-try:
-    from wool._protobuf.worker_pb2 import Ack
-    from wool._protobuf.worker_pb2 import Nack
-    from wool._protobuf.worker_pb2 import Response
-    from wool._protobuf.worker_pb2 import StopRequest
-    from wool._protobuf.worker_pb2 import Void
-    from wool._protobuf.worker_pb2 import WorkerInfo
-    from wool._protobuf.worker_pb2_grpc import WorkerServicer
-    from wool._protobuf.worker_pb2_grpc import WorkerStub
-    from wool._protobuf.worker_pb2_grpc import add_WorkerServicer_to_server
-except ImportError as e:
-    from wool._protobuf.exception import ProtobufImportError
-
-    raise ProtobufImportError(e) from e
-
-__all__ = [
-    "Ack",
-    "Nack",
-    "Response",
-    "StopRequest",
-    "Void",
-    "WorkerInfo",
-    "WorkerServicer",
-    "WorkerStub",
-    "add_WorkerServicer_to_server",
-]

wool/_typing.py

@@ -1,7 +0,0 @@
-from typing import Callable
-from typing import TypeVar
-
-F = TypeVar("F", bound=Callable)
-W = TypeVar("W", bound=Callable)
-Decorator = Callable[[F], W]
-PassthroughDecorator = Callable[[F], F]

wool/_undefined.py

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

wool-0.1rc20.dist-info/RECORD

@@ -1,38 +0,0 @@
-wool/__init__.py,sha256=IyrqcyjVoXOQjDNBwLvv3jxQHKEQ-MctibCfJvvh7sA,3838
-wool/_context.py,sha256=bbMGt8if3Fq_YpQVszqA8dqTdIoRP-Q7u1MIQfsnP8c,931
-wool/_resource_pool.py,sha256=qjPoKpDgg_bH6GpzEFkUSIuPJAU5XJCjIonWqQ42NIU,11550
-wool/_typing.py,sha256=tZDbQN8DZqGf34fRfgnqITsCgAvXA02bgB_9uTaNACQ,191
-wool/_undefined.py,sha256=NDZXOYCsUvDVKQ0HHMWzkJOY7ijNRD-pxxQQK-et4eY,181
-wool/_work.py,sha256=VrmrWAeH7i5XcRr4ytsPdO5Sj_ZCjpQsYcao0m-ydXE,16767
-wool/_protobuf/worker.py,sha256=l_LwIiui-A7n9-pY4uvIDaw_ubizlZI6XPEeVazGd6U,805
-wool/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wool/core/typing.py,sha256=jM52ICWQp2P-lzTFSOs46OGcOqLVGPTYPn8gmO-fxEI,517
-wool/core/discovery/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wool/core/discovery/base.py,sha256=yw3eKT4hVjBKYMJGGGorbkafRsodaSUJiKToKgCctrI,7103
-wool/core/discovery/lan.py,sha256=CbMf-cRsQQK_yaRcjl0y2EE6Qz_2vPmhHZ38P7pCths,20082
-wool/core/discovery/local.py,sha256=OxRxU4BU0wZrYESL31WtTe4EQbAeTJKjp7ryJKBmzjk,31164
-wool/core/loadbalancer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wool/core/loadbalancer/base.py,sha256=xkF61Dy3DpJuk79E-CNwbGz_l6PF3lhc1tYzp5jVmdc,4033
-wool/core/loadbalancer/roundrobin.py,sha256=5nuMhCGES0sl1Docm1wLxq7-rTxEnjhk9zpcEwm1ISI,3577
-wool/core/protobuf/__init__.py,sha256=61kDOGjPz9FwZpEygbItQdJY1y2QK-ogEtUtwvsOEZQ,435
-wool/core/protobuf/exception.py,sha256=rBm4bpWBt9Pq6Ry-WyxSG9RSE3FBuUt1JF-HBR0TK7w,174
-wool/core/protobuf/task.py,sha256=ZsKOCTPaPQ23n5koy3WTDSCLE0vcW8FWAJintaxm8H8,404
-wool/core/protobuf/task_pb2.py,sha256=cclvObRoWfxSgOTDTZLT0xjOdBamlQRnJRKGdCb0GIY,1949
-wool/core/protobuf/task_pb2.pyi,sha256=mssrgYgww2n_3J05OtwIAgYHzLSu__3ngXV8CjIKoiU,1593
-wool/core/protobuf/task_pb2_grpc.py,sha256=-be_fUpBt6g7xCvqVWnKZnzsYqYqu6IAk1wGV_1mWl8,884
-wool/core/protobuf/worker.py,sha256=dQwMBzeg1r-G667iYnJHwDQ4QaH43kYAeHTI5JGMpVM,845
-wool/core/protobuf/worker_pb2.py,sha256=Dgx8fO6bRA3n6FtipcpNOnTGXOhij2Eg5bp8wUDYWH8,3191
-wool/core/protobuf/worker_pb2.pyi,sha256=IXmVeIcdyWxZIa8LIqbGK4rpxOE_c7YHjBHtYq40psk,2633
-wool/core/protobuf/worker_pb2_grpc.py,sha256=X1J86-yaMVBilBfoDdXri8L4QtcEC5nnBpui9xB5Dnk,5015
-wool/core/worker/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wool/core/worker/base.py,sha256=f-61cnyszmHkOITCSr2W3KAaRTZzd-XL7vI9i3yFjiM,8224
-wool/core/worker/connection.py,sha256=0hDi5Shc8LeQhx0hIVZ7H9IoP_Xc4_UW3AtGUlD9n70,8261
-wool/core/worker/local.py,sha256=g1_CDXjFQHPGrBYK3DPMkMOSE64hJcW59lY8ckXTp3Y,4531
-wool/core/worker/pool.py,sha256=Y_JsJu3RPAT1YuPxY-gQ2sm9iRgaedlT0YHwuK31AlU,12629
-wool/core/worker/process.py,sha256=J4VDKYCKZef6FDI7DpiZulLUsiyWITFeERWa3w1KD1I,7841
-wool/core/worker/proxy.py,sha256=VXc7-ea5MsaWN0_2gA_e7hmZvc_USfKg36GIbeDo-Cg,14002
-wool/core/worker/service.py,sha256=yTwvYqZZi7SVBppfZ48g-j46IYuulT5j-37BtcZ6PkI,8138
-wool-0.1rc20.dist-info/METADATA,sha256=WnLhHvhWZvX4QjlUFGBcmp-AwZaGlmHdvu0wwquQji4,21064
-wool-0.1rc20.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wool-0.1rc20.dist-info/entry_points.txt,sha256=U3V7wWNc3KLw4AOjJRpbcZcLJIdiA-7y1eqxn-Xa5rY,38
-wool-0.1rc20.dist-info/RECORD,,