wool 0.1rc13__py3-none-any.whl → 0.1rc15__py3-none-any.whl

wool/_worker_service.py

@@ -0,0 +1,243 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import contextmanager
+from typing import AsyncIterator
+
+import cloudpickle
+from grpc import StatusCode
+from grpc.aio import ServicerContext
+
+import wool
+from wool import _protobuf as pb
+from wool._work import WoolTask
+from wool._work import WoolTaskEvent
+
+
+class ReadOnlyEvent:
+    """A read-only wrapper around :class:`asyncio.Event`.
+
+    Provides access to check if an event is set and wait for it to be
+    set, but prevents external code from setting or clearing the event.
+
+    :param event:
+        The underlying :class:`asyncio.Event` to wrap.
+    """
+
+    def __init__(self, event: asyncio.Event):
+        self._event = event
+
+    def is_set(self) -> bool:
+        """Check if the event is set.
+
+        :returns:
+            ``True`` if the event is set, ``False`` otherwise.
+        """
+        return self._event.is_set()
+
+    async def wait(self) -> None:
+        """Wait until the underlying event is set."""
+        await self._event.wait()
+
+
+class WorkerService(pb.worker.WorkerServicer):
+    """gRPC service implementation for executing distributed wool tasks.
+
+    :class:`WorkerService` implements the gRPC WorkerServicer
+    interface, providing remote procedure calls for task scheduling
+    and worker lifecycle management. Tasks are executed in the same
+    asyncio event loop as the gRPC server.
+
+    .. note::
+        Tasks are executed asynchronously in the current event loop
+        and results are serialized for transport back to the client.
+        The service maintains a set of running tasks for proper
+        lifecycle management during shutdown.
+
+        During shutdown, the service stops accepting new requests
+        immediately when the :meth:`stop` RPC is called, returning
+        UNAVAILABLE errors to new :meth:`dispatch` requests while
+        allowing existing tasks to complete gracefully.
+
+        The service provides :attr:`stopping` and
+        :attr:`stopped` properties to access the internal shutdown
+        state events.
+    """
+
+    _tasks: set[asyncio.Task]
+    _stopped: asyncio.Event
+    _stopping: asyncio.Event
+    _task_completed: asyncio.Event
+
+    def __init__(self):
+        self._stopped = asyncio.Event()
+        self._stopping = asyncio.Event()
+        self._task_completed = asyncio.Event()
+        self._tasks = set()
+
+    @property
+    def stopping(self) -> ReadOnlyEvent:
+        """Read-only event signaling that the service is stopping.
+
+        :returns:
+            A :class:`ReadOnlyEvent`.
+        """
+        return ReadOnlyEvent(self._stopping)
+
+    @property
+    def stopped(self) -> ReadOnlyEvent:
+        """Read-only event signaling that the service has stopped.
+
+        :returns:
+            A :class:`ReadOnlyEvent`.
+        """
+        return ReadOnlyEvent(self._stopped)
+
+    async def dispatch(
+        self, request: pb.task.Task, context: ServicerContext
+    ) -> AsyncIterator[pb.worker.Response]:
+        """Execute a task in the current event loop.
+
+        Deserializes the incoming task into a :class:`WoolTask`
+        instance, schedules it for execution in the current asyncio
+        event loop, and yields responses for acknowledgment and result.
+
+        :param request:
+            The protobuf task message containing the serialized task
+            data.
+        :param context:
+            The :class:`grpc.aio.ServicerContext` for this request.
+        :yields:
+            First yields an Ack Response when task processing begins,
+            then yields a Response containing the task result.
+
+        .. note::
+            Emits a :class:`WoolTaskEvent` when the task is
+            scheduled for execution.
+        """
+        if self._stopping.is_set():
+            await context.abort(
+                StatusCode.UNAVAILABLE, "Worker service is shutting down"
+            )
+
+        with self._tracker(WoolTask.from_protobuf(request)) as task:
+            try:
+                yield pb.worker.Response(ack=pb.worker.Ack())
+                try:
+                    result = pb.task.Result(dump=cloudpickle.dumps(await task))
+                    yield pb.worker.Response(result=result)
+                except Exception as e:
+                    exception = pb.task.Exception(dump=cloudpickle.dumps(e))
+                    yield pb.worker.Response(exception=exception)
+            except asyncio.CancelledError as e:
+                exception = pb.task.Exception(dump=cloudpickle.dumps(e))
+                yield pb.worker.Response(exception=exception)
+
+    async def stop(
+        self, request: pb.worker.StopRequest, context: ServicerContext | None
+    ) -> pb.worker.Void:
+        """Stop the worker service and its thread.
+
+        Gracefully shuts down the worker thread and signals the server
+        to stop accepting new requests. This method is idempotent and
+        can be called multiple times safely.
+
+        :param request:
+            The protobuf stop request containing the wait timeout.
+        :param context:
+            The :class:`grpc.aio.ServicerContext` for this request.
+        :returns:
+            An empty protobuf response indicating completion.
+        """
+        if self._stopping.is_set():
+            return pb.worker.Void()
+        await self._stop(timeout=request.timeout)
+        return pb.worker.Void()
+
+    @contextmanager
+    def _tracker(self, wool_task: WoolTask):
+        """Context manager for tracking running tasks.
+
+        Manages the lifecycle of a task execution, adding it to the
+        active tasks set and emitting appropriate events. Ensures
+        proper cleanup when the task completes or fails.
+
+        :param wool_task:
+            The :class:`WoolTask` instance to execute and track.
+        :yields:
+            The :class:`asyncio.Task` created for the wool task.
+
+        .. note::
+            Emits a :class:`WoolTaskEvent` with type "task-scheduled"
+            when the task begins execution.
+        """
+        WoolTaskEvent("task-scheduled", task=wool_task).emit()
+        task = asyncio.create_task(wool_task.run())
+        self._tasks.add(task)
+        try:
+            yield task
+        finally:
+            self._tasks.remove(task)
+
+    async def _stop(self, *, timeout: float | None = 0) -> None:
+        self._stopping.set()
+        await self._await_or_cancel_tasks(timeout=timeout)
+        try:
+            if proxy_pool := wool.__proxy_pool__.get():
+                await proxy_pool.clear()
+        finally:
+            self._stopped.set()
+
+    async def _await_or_cancel_tasks(self, *, timeout: float | None = 0) -> None:
+        """Stop the worker service gracefully.
+
+        Gracefully shuts down the worker service by canceling or waiting
+        for running tasks. This method is idempotent and can be called
+        multiple times safely.
+
+        :param timeout:
+            Maximum time to wait for tasks to complete. If 0 (default),
+            tasks are canceled immediately. If None, waits indefinitely.
+            If a positive number, waits for that many seconds before
+            canceling tasks.
+
+        .. note::
+            If a timeout occurs while waiting for tasks to complete,
+            the method recursively calls itself with a timeout of 0
+            to cancel all remaining tasks immediately.
+        """
+        if self._tasks and timeout == 0:
+            await self._cancel(*self._tasks)
+        elif self._tasks:
+            try:
+                await asyncio.wait_for(
+                    asyncio.gather(*self._tasks, return_exceptions=True),
+                    timeout=timeout,
+                )
+            except asyncio.TimeoutError:
+                return await self._await_or_cancel_tasks(timeout=0)
+
+    async def _cancel(self, *tasks: asyncio.Task):
+        """Cancel multiple tasks safely.
+
+        Cancels the provided tasks while performing safety checks to
+        avoid canceling the current task or already completed tasks.
+        Waits for all cancelled tasks to complete in parallel and handles
+        cancellation exceptions.
+
+        :param tasks:
+            The :class:`asyncio.Task` instances to cancel.
+
+        .. note::
+            This method performs the following safety checks:
+            - Avoids canceling the current task (would cause deadlock)
+            - Only cancels tasks that are not already done
+            - Properly handles :exc:`asyncio.CancelledError`
+              exceptions.
+        """
+        current = asyncio.current_task()
+        to_cancel = [task for task in tasks if not task.done() and task != current]
+        for task in to_cancel:
+            task.cancel()
+        if to_cancel:
+            await asyncio.gather(*to_cancel, return_exceptions=True)

{wool-0.1rc13.dist-info → wool-0.1rc15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wool
-Version: 0.1rc13
+Version: 0.1rc15
 Summary: A Python framework for distributed multiprocessing.
 Author-email: Conrad Bzura <conrad@wool.io>
 Maintainer-email: maintainers@wool.io
@@ -222,14 +222,14 @@ 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
+![](https://raw.githubusercontent.com/wool-labs/wool/refs/heads/main/assets/woolly-transparent-bg-2048.png)
 
-Wool is a native Python package for transparently executing tasks in a horizontally scalable, distributed network of agnostic worker processes. Any picklable async function or method can be converted into a task with a simple decorator and a client connection.
+**Wool** is a native Python package for transparently executing tasks in a horizontally scalable, distributed network of agnostic worker processes. Any picklable async function or method can be converted into a task with a simple decorator and a client connection.
 
 ## Installation
 
@@ -253,19 +253,73 @@ cd wool
 
 ## Usage
 
-### CLI Commands
+### Declaring tasks
 
-Wool provides a command-line interface (CLI) for managing the worker pool.
+Wool tasks are coroutine functions that are executed in a remote `asyncio` event loop within a worker process. To declare a task, use the `@wool.task` decorator:
 
-To list the available commands:
+```python
+import wool
 
-```sh
-wool --help
+@wool.task
+async def sample_task(x, y):
+    return x + y
 ```
 
-#### Start the Worker Pool
+Tasks must be picklable, stateless, and idempotent. Avoid passing unpicklable objects as arguments or return values.
+
+### Worker pools
+
+Worker pools are responsible for executing tasks. Wool provides two types of pools:
+
+#### Ephemeral pools
+
+Ephemeral pools are created and destroyed within the scope of a context manager. Use `wool.pool` to declare an ephemeral pool:
+
+```python
+import asyncio, wool
+
+@wool.task
+async def sample_task(x, y):
+    return x + y
+
+async def main():
+    with wool.pool():
+        result = await sample_task(1, 2)
+        print(f"Result: {result}")
+
+asyncio.run(main())
+```
+
+#### Durable pools
+
+Durable pools are started independently and persist beyond the scope of a single application. Use the `wool` CLI to manage durable pools:
+
+```bash
+wool pool up --port 5050 --authkey deadbeef --module tasks
+```
+
+Connect to a durable pool using `wool.session`:
+
+```python
+import asyncio, wool
+
+@wool.task
+async def sample_task(x, y):
+    return x + y
+
+async def main():
+    with wool.session(port=5050, authkey=b"deadbeef"):
+        result = await sample_task(1, 2)
+        print(f"Result: {result}")
+
+asyncio.run(main())
+```
 
-To start the worker pool, use the `up` command:
+### CLI commands
+
+Wool provides a command-line interface (CLI) for managing worker pools.
+
+#### Start the worker pool
 
 ```sh
 wool pool up --host <host> --port <port> --authkey <authkey> --breadth <breadth> --module <module>
@@ -275,11 +329,9 @@ wool pool up --host <host> --port <port> --authkey <authkey> --breadth <breadth>
 - `--port`: The port number (default: `0`).
 - `--authkey`: The authentication key (default: `b""`).
 - `--breadth`: The number of worker processes (default: number of CPU cores).
-- `--module`: Python module containing Wool task definitions to be executed by this pool (optional, can be specified multiple times).
-
-#### Stop the Worker Pool
+- `--module`: Python module containing Wool task definitions (optional, can be specified multiple times).
 
-To stop the worker pool, use the `down` command:
+#### Stop the worker pool
 
 ```sh
 wool pool down --host <host> --port <port> --authkey <authkey> --wait
@@ -290,9 +342,7 @@ wool pool down --host <host> --port <port> --authkey <authkey> --wait
 - `--authkey`: The authentication key (default: `b""`).
 - `--wait`: Wait for in-flight tasks to complete before shutting down.
 
-#### Ping the Worker Pool
-
-To ping the worker pool, use the `ping` command:
+#### Ping the worker pool
 
 ```sh
 wool ping --host <host> --port <port> --authkey <authkey>
@@ -302,46 +352,108 @@ wool ping --host <host> --port <port> --authkey <authkey>
 - `--port`: The port number (required).
 - `--authkey`: The authentication key (default: `b""`).
 
-### Sample Python Application
+### Advanced usage
+
+#### Nested pools and sessions
 
-Below is an example of how to create a Wool client connection, decorate an async function using the `task` decorator, and execute the function remotely:
+Wool supports nesting pools and sessions to achieve complex workflows. Tasks can be dispatched to specific pools by nesting contexts:
 
-Module defining remote tasks:
-`tasks.py`
 ```python
 import asyncio, wool
 
-# Decorate an async function using the `task` decorator
 @wool.task
-async def sample_task(x, y):
+async def task_a():
     await asyncio.sleep(1)
-    return x + y
+
+@wool.task
+async def task_b():
+    with wool.pool(port=5051):
+        await task_a()
+
+async def main():
+    with wool.pool(port=5050):
+        await task_a()
+        await task_b()
+
+asyncio.run(main())
 ```
 
-Module executing remote workflow:
-`main.py`
+In this example, `task_a` is executed by two different pools, while `task_b` is executed by the pool on port 5050.
+
+### Best practices
+
+#### Sizing worker pools
+
+When configuring worker pools, it is important to balance the number of processes with the available system resources:
+
+- **CPU-bound tasks**: Size the worker pool to match the number of CPU cores. This is the default behavior when spawning a pool.
+- **I/O-bound tasks**: For workloads involving significant I/O, consider oversizing the pool slightly to maximize the system's I/O capacity utilization.
+- **Mixed workloads**: Monitor memory usage and system load to avoid oversubscription, especially for memory-intensive tasks. Use profiling tools to determine the optimal pool size.
+
+#### Defining tasks
+
+Wool tasks are coroutine functions that execute asynchronously in a remote `asyncio` event loop. To ensure smooth execution and scalability, prioritize:
+
+- **Picklability**: Ensure all task arguments and return values are picklable. Avoid passing unpicklable objects such as open file handles, database connections, or lambda functions.
+- **Statelessness and idempotency**: Design tasks to be stateless and idempotent. Avoid relying on global variables or shared mutable state. This ensures predictable behavior and safe retries.
+- **Non-blocking operations**: To achieve higher concurrency, avoid blocking calls within tasks. Use `asyncio`-compatible libraries for I/O operations.
+- **Inter-process synchronization**: Use Wool's synchronization primitives (e.g., `wool.locking`) for inter-worker and inter-pool coordination. Standard `asyncio` primitives will not behave as expected in a multi-process environment.
+
+#### Debugging and logging
+
+- Enable detailed logging during development to trace task execution and worker pool behavior:
+  ```python
+  import logging
+  logging.basicConfig(level=logging.DEBUG)
+  ```
+- Use Wool's built-in logging configuration to capture worker-specific logs.
+
+#### Nested pools and sessions
+
+Wool supports nesting pools and sessions to achieve complex workflows. Tasks can be dispatched to specific pools by nesting contexts. This is useful for workflows requiring task segregation or resource isolation.
+
+Example:
 ```python
 import asyncio, wool
-from tasks import sample_task
 
-# Execute the decorated function in an external worker pool
+@wool.task
+async def task_a():
+    await asyncio.sleep(1)
+
+@wool.task
+async def task_b():
+    with wool.pool(port=5051):
+        await task_a()
+
 async def main():
-    with wool.PoolSession(port=5050, authkey=b"deadbeef"):
-        result = await sample_task(1, 2)
-        print(f"Result: {result}")
+    with wool.pool(port=5050):
+        await task_a()
+        await task_b()
 
-asyncio.new_event_loop().run_until_complete(main())
+asyncio.run(main())
 ```
 
-To run the demo, first start a worker pool specifying the module defining the tasks to be executed:
-```bash
-wool pool up --port 5050 --authkey deadbeef --breadth 1 --module tasks
-```
+#### Performance optimization
 
-Next, in a separate terminal, execute the application defined in `main.py` and, finally, stop the worker pool:
-```bash
-python main.py
-wool pool down --port 5050 --authkey deadbeef
+- Minimize the size of arguments and return values to reduce serialization overhead.
+- For large datasets, consider using shared memory or passing references (e.g., file paths) instead of transferring the entire data.
+- Profile tasks to identify and optimize performance bottlenecks.
+
+#### Task cancellation
+
+- Handle task cancellations gracefully by cleaning up resources and rolling back partial changes.
+- Use `asyncio.CancelledError` to detect and respond to cancellations.
+
+#### Error propagation
+
+- Wool propagates exceptions raised within tasks to the caller. Use this feature to handle errors centrally in your application.
+
+Example:
+```python
+try:
+    result = await some_task()
+except Exception as e:
+    print(f"Task failed with error: {e}")
 ```
 
 ## License

wool-0.1rc15.dist-info/RECORD

@@ -0,0 +1,27 @@
+wool/__init__.py,sha256=I2tysRZBjPHMt8rVigYLx_R4wafXMIYq9A69_MPAPQA,2109
+wool/_connection.py,sha256=EMF80cJla6nMeE6rSq7NL6-QpzjXCAjfRuXqE5O7Pjs,8434
+wool/_context.py,sha256=bbMGt8if3Fq_YpQVszqA8dqTdIoRP-Q7u1MIQfsnP8c,931
+wool/_loadbalancer.py,sha256=CbdbPgdC0tbIdcKT5KEaPlj2xsKjPxdcYeEGYE1AgyU,7280
+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=Qa5XC4KypORSGAB-THkA_nc6iEUggMNWju0Ckr5u7ts,16759
+wool/_worker.py,sha256=7IoCJDb7GjdI_xg3g_I2J0CXAdgzmG5n0bLmWGTETY0,20300
+wool/_worker_discovery.py,sha256=qd5KPqhbCz7JQ6ohyfiJjS8HFmjCTOlCyP2NaaUReqg,42763
+wool/_worker_pool.py,sha256=D3kpGGkrW-5uWTyyj3HhGTRstZptbOieO5TJbWBtQEI,11500
+wool/_worker_proxy.py,sha256=O1IkWY7_pbcDM48cjAvydzQ5Z1lc5MEtgsed9Tg8M4c,12882
+wool/_worker_service.py,sha256=t6Y7-xeZ1WIqxi97R18iBRhhpV520D8a6_8z_Y58CAk,8713
+wool/_protobuf/__init__.py,sha256=61kDOGjPz9FwZpEygbItQdJY1y2QK-ogEtUtwvsOEZQ,435
+wool/_protobuf/exception.py,sha256=rBm4bpWBt9Pq6Ry-WyxSG9RSE3FBuUt1JF-HBR0TK7w,174
+wool/_protobuf/task.py,sha256=YTBKhUgUAXF-wEecEYmieN87l9f4aYPhkqrm7hyVNDU,384
+wool/_protobuf/task_pb2.py,sha256=Fb7z2Ox-9ImXHwNKFYvxuBbMsrWFo9lsitEctzk4ARE,1945
+wool/_protobuf/task_pb2.pyi,sha256=mssrgYgww2n_3J05OtwIAgYHzLSu__3ngXV8CjIKoiU,1593
+wool/_protobuf/task_pb2_grpc.py,sha256=-be_fUpBt6g7xCvqVWnKZnzsYqYqu6IAk1wGV_1mWl8,884
+wool/_protobuf/worker.py,sha256=gmB-wowcCig9a_EIZB8eLYmfCvF7aAu4Zm2sZLTVYi4,734
+wool/_protobuf/worker_pb2.py,sha256=smrpC187d9NxzbEp1XlTMaUOvlqO5-r_JUKRptmmgN4,2396
+wool/_protobuf/worker_pb2.pyi,sha256=YR0mHH4ojlTv6J5Kwsan8E3PU2BSwwN1870bNEAfX8s,1444
+wool/_protobuf/worker_pb2_grpc.py,sha256=JXgPLxPnvcfrKaCEmE5989-v691F80mPUDNWr849CIg,4991
+wool-0.1rc15.dist-info/METADATA,sha256=YMeV6dmrg59BRWkdyoflkhKuSsVSxsOIq0xpCvSuHrY,21021
+wool-0.1rc15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wool-0.1rc15.dist-info/entry_points.txt,sha256=U3V7wWNc3KLw4AOjJRpbcZcLJIdiA-7y1eqxn-Xa5rY,38
+wool-0.1rc15.dist-info/RECORD,,

wool-0.1rc13.dist-info/RECORD

@@ -1,22 +0,0 @@
-wool/__init__.py,sha256=m0DUFtEqDqOY9Ct1FVapGqIHnftq6uDccgCSFCdM7w8,2598
-wool/_resource_pool.py,sha256=B4Zk9kbspMY6V-H6unzup666alhI81YMBCyGvW-R5Ho,11559
-wool/_typing.py,sha256=tZDbQN8DZqGf34fRfgnqITsCgAvXA02bgB_9uTaNACQ,191
-wool/_work.py,sha256=I4eyCEWDFkfoRXhBvNcKuA1fGS55JMw4WEZhwU0DExM,16690
-wool/_worker.py,sha256=W59hu44KQ45tn0H4gDZgAxpO65ah_Waqi7-NfCXzoZI,31238
-wool/_worker_discovery.py,sha256=FFrc8ZuJfBjyySwaAMYTzbelwrdbxs77u7VWupdFtj8,43371
-wool/_worker_pool.py,sha256=jfD5qXg78CfKEm-cPFpfFFzFJ6OF3_S8Je_8YEHycYg,10705
-wool/_worker_proxy.py,sha256=j8SaVM2yx4kEFq6l7EQox6L55NpMySYgj1ZkqR1FvgA,17325
-wool/_protobuf/__init__.py,sha256=61kDOGjPz9FwZpEygbItQdJY1y2QK-ogEtUtwvsOEZQ,435
-wool/_protobuf/exception.py,sha256=rBm4bpWBt9Pq6Ry-WyxSG9RSE3FBuUt1JF-HBR0TK7w,174
-wool/_protobuf/task.py,sha256=YTBKhUgUAXF-wEecEYmieN87l9f4aYPhkqrm7hyVNDU,384
-wool/_protobuf/task_pb2.py,sha256=Fb7z2Ox-9ImXHwNKFYvxuBbMsrWFo9lsitEctzk4ARE,1945
-wool/_protobuf/task_pb2.pyi,sha256=mssrgYgww2n_3J05OtwIAgYHzLSu__3ngXV8CjIKoiU,1593
-wool/_protobuf/task_pb2_grpc.py,sha256=84njmLo1mCquhxPVaRNeW6MNptH0CYClzbBvBorUnk4,885
-wool/_protobuf/worker.py,sha256=gmB-wowcCig9a_EIZB8eLYmfCvF7aAu4Zm2sZLTVYi4,734
-wool/_protobuf/worker_pb2.py,sha256=LiotSqTMtFdVmjG3svVsSYfDyuJdsf-KwHPtRDNeluo,2393
-wool/_protobuf/worker_pb2.pyi,sha256=TjLjxwAsr_NpWw1JLGUz77ANCPIwWoJJ5WmkX8CfnfU,1428
-wool/_protobuf/worker_pb2_grpc.py,sha256=XxGA7JLZ4B6uBgQD2uRZaGIsM4H118Z-CLBrBk5yPZ8,4992
-wool-0.1rc13.dist-info/METADATA,sha256=Am7W6xzSGPbWBxpRXsZ0XWc5ycIjYLYYNtZO1YlxEuQ,17093
-wool-0.1rc13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wool-0.1rc13.dist-info/entry_points.txt,sha256=U3V7wWNc3KLw4AOjJRpbcZcLJIdiA-7y1eqxn-Xa5rY,38
-wool-0.1rc13.dist-info/RECORD,,