wool 0.1rc6__py3-none-any.whl → 0.1rc7__py3-none-any.whl

wool/_client.py

@@ -1,205 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import functools
-import logging
-import threading
-import time
-from contextvars import ContextVar
-from typing import TYPE_CHECKING, Callable, Coroutine, TypeVar
-from uuid import UUID
-from weakref import WeakValueDictionary
-
-import wool
-from wool._future import WoolFuture, fulfill, poll
-from wool._manager import Manager
-
-if TYPE_CHECKING:
-    from wool._queue import TaskQueue
-    from wool._task import AsyncCallable, WoolTask
-    from wool._typing import Positive, Zero
-
-
-def command(fn):
-    @functools.wraps(fn)
-    def wrapper(self: BaseClient, *args, **kwargs):
-        if not self.connected:
-            raise RuntimeError("Client not connected to manager")
-        assert self.manager
-        try:
-            return fn(self, *args, **kwargs)
-        except (ConnectionRefusedError, ConnectionResetError):
-            logging.warning(
-                f"Connection to manager at {self._address} lost. "
-                "Attempting to reconnect..."
-            )
-            self.connect()
-            logging.debug(
-                f"Reconnected to manager at {self._address}. "
-                "Retrying command..."
-            )
-            return fn(self, *args, **kwargs)
-
-    return wrapper
-
-
-class BaseClient:
-    def __init__(
-        self,
-        address: tuple[str, int],
-        *,
-        authkey: bytes | None = None,
-    ):
-        self._address: tuple[str, int] = address
-        self._authkey: bytes | None = authkey
-        self._manager: Manager | None = None
-
-    @property
-    def manager(self) -> Manager | None:
-        return self._manager
-
-    @property
-    def connected(self) -> bool:
-        return self._manager is not None
-
-    def connect(
-        self: Self,
-        *,
-        retries: Zero | Positive[int] = 2,
-        interval: Positive[float] = 1,
-    ) -> Self:
-        """Establish a connection to the manager at the specified address."""
-        if retries < 0:
-            raise ValueError("Retries must be a positive integer")
-        if not interval > 0:
-            raise ValueError("Interval must be a positive float")
-        if not self._manager:
-            self._manager = Manager(
-                address=self._address, authkey=self._authkey
-            )
-            attempts = threading.Semaphore(retries + 1)
-            error = None
-            i = 1
-            while attempts.acquire(blocking=False):
-                logging.debug(
-                    f"Attempt {i} of {retries + 1} to connect to manager at {self._address}..."
-                )
-                try:
-                    self._manager.connect()
-                except (ConnectionRefusedError, ConnectionResetError) as e:
-                    error = e
-                    i += 1
-                    time.sleep(interval)
-                else:
-                    break
-            else:
-                if error:
-                    self._manager = None
-                    raise error
-            logging.info(
-                f"Successfully connected to manager at {self._address}"
-            )
-        else:
-            logging.warning(f"Already connected to manager at {self._address}")
-        return self
-
-    @command
-    def stop(self, wait: bool = False) -> None:
-        """Shut down the worker pool and close the connection to the manager."""
-        assert self._manager
-        self._manager.stop(wait=wait)
-        self._manager = None
-
-
-Self = TypeVar("Self", bound=BaseClient)
-
-
-class WorkerClient(BaseClient):
-    @command
-    def futures(self) -> WeakValueDictionary[UUID, WoolFuture]:
-        assert self.manager
-        return self.manager.futures()
-
-    @command
-    def queue(self) -> TaskQueue[WoolTask]:
-        assert self.manager
-        return self.manager.queue()
-
-
-# PUBLIC
-def client(
-    address: tuple[str, int],
-    *,
-    authkey: bytes | None = None,
-) -> Callable[[AsyncCallable], AsyncCallable]:
-    def _client(fn: AsyncCallable) -> AsyncCallable:
-        @functools.wraps(fn)
-        async def wrapper(*args, **kwargs) -> Coroutine:
-            with WoolClient(address, authkey=authkey):
-                return await fn(*args, **kwargs)
-
-        return wrapper
-
-    return _client
-
-
-# PUBLIC
-def current_client() -> WoolClient | None:
-    return wool.__wool_client__.get()
-
-
-# PUBLIC
-class WoolClient(BaseClient):
-    def __init__(
-        self,
-        address: tuple[str, int],
-        *,
-        authkey: bytes | None = None,
-    ):
-        super().__init__(address, authkey=authkey)
-        self._outer_client: WoolClient | None = None
-
-    def __enter__(self):
-        if not self.connected:
-            self.connect()
-        self._outer_client = self.client_context.get()
-        self.client_context.set(self)
-
-    def __exit__(self, *_):
-        assert self._outer_client
-        self.client_context.set(self._outer_client)
-        self._outer_client = None
-
-    @property
-    def client_context(self) -> ContextVar[WoolClient]:
-        return wool.__wool_client__
-
-    @command
-    def put(self, task: WoolTask) -> WoolFuture:
-        assert self._manager
-        return self._manager.put(task)
-
-
-# PUBLIC
-class NullClient(WoolClient):
-    def __init__(self):
-        pass
-
-    @property
-    def manager(self) -> Manager | None:
-        return None
-
-    @property
-    def connected(self) -> bool:
-        return True
-
-    def connect(self, *args, **kwargs) -> NullClient:
-        return self
-
-    def put(self, wool_task: wool.WoolTask) -> WoolFuture:
-        future = WoolFuture()
-        loop = asyncio.get_event_loop()
-        task = asyncio.run_coroutine_threadsafe(wool_task.run(), loop)
-        task.add_done_callback(fulfill(future))
-        asyncio.run_coroutine_threadsafe(poll(future, task), loop)
-        return future

wool-0.1rc6.dist-info/METADATA

@@ -1,138 +0,0 @@
-Metadata-Version: 2.4
-Name: wool
-Version: 0.1rc6
-Summary: A Python framework for distributed multiprocessing.
-Author-email: Conrad Bzura <conrad@wool.io>
-Maintainer-email: maintainers@wool.io
-Classifier: Intended Audience :: Developers
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: annotated-types
-Requires-Dist: click
-Requires-Dist: debugpy
-Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
-Requires-Dist: ruff; extra == "dev"
-Provides-Extra: locking
-Requires-Dist: wool-locking; extra == "locking"
-
-# Wool
-
-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
-
-### Using pip
-
-To install the package using pip, run the following command:
-
-```sh
-[uv] pip install --pre wool
-```
-
-### Cloning from GitHub
-
-To install the package by cloning from GitHub, run the following commands:
-
-```sh
-git clone https://github.com/wool-labs/wool.git
-cd wool
-[uv] pip install ./wool
-```
-
-## Usage
-
-### CLI Commands
-
-Wool provides a command-line interface (CLI) for managing the worker pool.
-
-To list the available commands:
-
-```sh
-wool --help
-```
-
-#### Start the Worker Pool
-
-To start the worker pool, use the `up` command:
-
-```sh
-wool pool up --host <host> --port <port> --authkey <authkey> --breadth <breadth> --module <module>
-```
-
-- `--host`: The host address (default: `localhost`).
-- `--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
-
-To stop the worker pool, use the `down` command:
-
-```sh
-wool pool down --host <host> --port <port> --authkey <authkey> --wait
-```
-
-- `--host`: The host address (default: `localhost`).
-- `--port`: The port number (required).
-- `--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:
-
-```sh
-wool ping --host <host> --port <port> --authkey <authkey>
-```
-
-- `--host`: The host address (default: `localhost`).
-- `--port`: The port number (required).
-- `--authkey`: The authentication key (default: `b""`).
-
-### Sample Python Application
-
-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:
-
-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):
-    await asyncio.sleep(1)
-    return x + y
-```
-
-Module executing remote workflow:
-`main.py`
-```python
-import asyncio, wool
-from tasks import sample_task
-
-# Execute the decorated function in an external worker pool
-async def main():
-    with wool.WoolClient(port=5050, authkey=b"deadbeef"):
-        result = await sample_task(1, 2)
-        print(f"Result: {result}")
-
-asyncio.new_event_loop().run_until_complete(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
-```
-
-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
-```
-
-## License
-
-This project is licensed under the Apache License Version 2.0.

wool-0.1rc6.dist-info/RECORD

@@ -1,17 +0,0 @@
-wool/__init__.py,sha256=0W39YauJFvADmbkgaESmlCnhVMGPfvipf2cYSwrBh7w,1599
-wool/_cli.py,sha256=_XnD-pPRIZcjUl3zsTAx9mrOI_Vusmt_45wDjrMNr4Y,5418
-wool/_client.py,sha256=PY1hYar1XcUuhIhXIYWeAAbI08XKRBxvZKZOWqf_dgY,5754
-wool/_future.py,sha256=HDLEarPpIMpGbyclkGHeCK-uk1_QwGzcjP37Cow7Dug,2823
-wool/_logging.py,sha256=r__hUA8wnYfLwxUAMSgX6QTCkZB3XZsrjthfMkg0sMk,1028
-wool/_manager.py,sha256=ZE0nKz-kzk-fSfrVNVCkeVFFWCPKSjG2p76R6aXBRzU,3758
-wool/_pool.py,sha256=pYV10zSszB8CbFoe0yvs4X37V5ZpKi5Xn1l8oXfSX4A,9538
-wool/_queue.py,sha256=V_xlY95ba7jDuEzFTOvsizLp4bXCEpaDKw3e4sfXISM,960
-wool/_task.py,sha256=sIUO5RIT26-mXueyFMYzSdURSVmttcruzA7XoeThQIY,8569
-wool/_typing.py,sha256=-ScOIf14D_l8HYG_QZ3NgzsTeRLZvpiQ1txWef2-taU,325
-wool/_utils.py,sha256=hx9v6p1LV3-SkR_pH0jfqAVtjOzMKLuZLoLd8e7GnfU,1831
-wool/_worker.py,sha256=Tkhbu6eTcDNZ1LYgb0fGNDuSVKbl5ZTdWQHAGfRzAUo,4734
-wool-0.1rc6.dist-info/METADATA,sha256=9Mhnqdu7uGqvWd19rGGMv4BbSnDT6J1WUeFQlvr62vM,3748
-wool-0.1rc6.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-wool-0.1rc6.dist-info/entry_points.txt,sha256=ybzb5TYXou-2cKC8HP5p0X8bw6Iyv7UMasqml6zlO1k,39
-wool-0.1rc6.dist-info/top_level.txt,sha256=K0EPaZfk825mzy0W1dOkRkitbqFdtiacj3GQfnI9_-E,5
-wool-0.1rc6.dist-info/RECORD,,

wool-0.1rc6.dist-info/top_level.txt

@@ -1 +0,0 @@
-wool