pintel 0.3.0.dev0__py3-none-any.whl

pintel/__init__.py

@@ -0,0 +1,7 @@
+from loguru import logger
+
+from .hub import Hub, UserCodeException
+from .worker import Worker
+
+
+logger.disable("pintel")

pintel/hub.py

@@ -0,0 +1,317 @@
+import asyncio
+import time
+import uuid
+from collections import namedtuple
+from typing import Any, Tuple
+
+import msgpack
+import zmq
+import zmq.asyncio
+from loguru import logger
+
+from pintel.worker import CODE_FAILURE, DEFAULT_HEARTBEAT_INTERVAL, DEFAULT_PORT, PONG
+
+
+RESPONSE_BUFFER_SIZE: int = 4096
+
+
+class UserCodeException(Exception):
+    """Custom Exception for user-defined catched errors.
+
+    Args:
+        t (str): Traceback returned by the worker.
+    """
+
+    def __init__(self, t: str):
+        super().__init__(f"Exception raised in user-defined code. Traceback :\n{t}")
+
+
+class WorkerManager:
+    """A helper class that takes care of managing workers.
+    Workers' address can be registered as available, and this class will make
+    sure to return address of workers that are available and alive.
+
+    A worker is considered as dead if we didn't receive any heartbeat within a
+    given interval.
+
+    Args:
+        heartbeat_interval (float): Interval of time (in seconds) after which we
+            consider a worker to be dead.
+    """
+
+    def __init__(self, heartbeat_interval: float):
+        super().__init__()
+
+        self.heartbeat_t = heartbeat_interval
+
+        self.w_ts = {}
+        self.w_access = asyncio.Condition()
+
+    async def reckon(self, address: str):
+        """Register the given address as available.
+
+        Args:
+            address (str): Address of the worker to register as available.
+        """
+        async with self.w_access:
+            self.w_ts[address] = time.time()
+            self.w_access.notify()
+
+    async def get_next_worker(self) -> str:
+        """Retrieve the next available and alive worker's address.
+
+        Returns:
+            str: Address of the available and alive worker.
+        """
+        async with self.w_access:
+            # Iterate workers until we find one that was alive recently
+            w_alive = False
+            while not w_alive:
+                # If no workers are available, wait...
+                if not self.w_ts:
+                    await self.w_access.wait()
+
+                address, ts = self.w_ts.popitem()
+                w_alive = time.time() - ts < self.heartbeat_t
+
+            return address
+
+
+Response = namedtuple("Response", ["code", "content"])
+
+
+class RequestManager:
+    """A helper class that takes care of storing responses and waiting for the
+    right response.
+
+    Args:
+        resp_buffer_size (int): Maximum size of the response buffer.
+    """
+
+    def __init__(self, resp_buffer_size: int):
+        super().__init__()
+
+        self.resp_buffer_size = resp_buffer_size
+
+        self.responses = {}
+        self.req_states = {}
+
+    def pin(self, req_id: str):
+        """Pin a request ID. This is a necessary step when sending a request,
+        so that the request can be awaited until a response is received.
+        This method should be called for each `req_id` before calling `wait_for`.
+
+        Args:
+            req_id (str): Request unique identifier.
+        """
+        self.req_states[req_id] = asyncio.Event()
+
+        # Ensure we don't store too many requests
+        if len(self.req_states) > self.resp_buffer_size:
+            # If it's the case, forget the oldest one
+            k = list(self.req_states.keys())[0]
+            logger.warning(f"Response buffer overflow (>{self.resp_buffer_size}). Forgetting oldest request : {k}")
+            self.req_states.pop(k)
+            self.responses.pop(k, None)
+
+    async def wait_for(self, req_id: str) -> Tuple[int, Any]:
+        """Async method that waits until we received the response corresponding
+        to the given request ID.
+
+        The method `pin` should be called before waiting with this method.
+
+        Args:
+            req_id (str): Request unique identifier.
+
+        Raises:
+            KeyError: Exception raised if the request wasn't registered previously.
+
+        Returns:
+            Tuple[int, Any]: Code and content of the received response.
+        """
+        if req_id not in self.req_states:
+            raise KeyError(f"Request #{req_id} was not pinned, or was removed because of buffer overflow")
+
+        # Wait for the receiving loop to receive the response
+        await self.req_states[req_id].wait()
+
+        # Once we get it, access the result
+        r = self.responses.pop(req_id)
+
+        # Don't forget to remove the event
+        self.req_states.pop(req_id)
+
+        return r.code, r.content
+
+    def store(self, req_id: str, code: int, response: Any):
+        """Store a response, to be consumed later.
+
+        Args:
+            req_id (str): Request unique identifier.
+            code (int): Code of the response.
+            response (Any): Content of the response.
+        """
+        # Store the response if the req_id is recognized
+        if req_id in self.req_states:
+            self.responses[req_id] = Response(code, response)
+
+            # Notify that we received the response
+            self.req_states[req_id].set()
+        else:
+            logger.warning(
+                f"Request #{req_id} was previously removed from response buffer. "
+                f"Ignoring the response from this request..."
+            )
+
+
+class Hub:
+    """Class acting as a hub for all the requests to send. All requests sent
+    through this class will be automatically dispatched to connected workers,
+    will wait for the responses and return it.
+
+    Args:
+        port (int): Port number to use for the sockets. Defaults to
+            DEFAULT_PORT.
+        heartbeat_interval (float): Heartbeat interval used by the
+            workers, in seconds. Defaults to DEFAULT_HEARTBEAT_INTERVAL.
+        resp_buffer_size (int): Maximum response buffer size. Defaults
+            to RESPONSE_BUFFER_SIZE.
+    """
+
+    def __init__(
+        self,
+        port: int = DEFAULT_PORT,
+        heartbeat_interval: float = DEFAULT_HEARTBEAT_INTERVAL,
+        resp_buffer_size: int = RESPONSE_BUFFER_SIZE,
+    ):
+        super().__init__()
+
+        self.port = port
+        self.heartbeat_t = heartbeat_interval
+        self.socket = None
+        self.w_manager = None
+        self.req_manager = RequestManager(resp_buffer_size=resp_buffer_size)
+
+    async def receive_loop(self):
+        """Infinite loop for receiving responses from the workers."""
+        while True:
+            # Receive stuff
+            logger.debug("Receiving...")
+            address, *frames = await self.socket.recv_multipart()
+            logger.debug(f"Received something from worker #{address}")
+
+            # Since we received a response from this worker, it means it's ready for more !
+            await self.w_manager.reckon(address)
+
+            if len(frames) == 1:
+                # Answer the Ping
+                logger.debug("Answering the ping")
+                await self.socket.send_multipart([address, b"", PONG])
+                continue
+
+            _, resp = frames
+            req_id, code, res = msgpack.unpackb(resp)
+            logger.debug(f"Received response from request #{req_id}")
+
+            self.req_manager.store(req_id, code, res)
+
+    def _start_if_not_started(self):
+        """Helper method to ensure everything is properly started (socket is
+        initialized, receiving loop is started, etc...).
+        """
+        if self.socket is None:
+            # Create what we need here in this process/context
+            context = zmq.asyncio.Context()
+            self.socket = context.socket(zmq.ROUTER)
+            self.socket.bind(f"tcp://*:{self.port}")
+            self.w_manager = WorkerManager(heartbeat_interval=self.heartbeat_t)
+
+            # Fire and forget : infinite loop, taking care of receiving stuff from the socket
+            logger.info("Starting receiving loop...")
+            asyncio.create_task(self.receive_loop())
+
+    async def _request(self, *args: Any, **kwargs: Any) -> Any:
+        """Raw method to send a request. This method will do the following :
+         * Start the receiving loop if it was not started
+         * Get the address of the next worker ready (blocking)
+         * Send the request to the worker
+         * Wait for the response (blocking)
+         * Return the result
+
+        Args:
+            *args: Positional arguments for the request.
+            **kwargs: Keywords arguments for the request.
+
+        Raises:
+            UserCodeException: Exception raised if an exception was raised inside
+                user-defined code on the worker side.
+
+        Returns:
+            Any: The response for the request.
+        """
+        # Before anything, if the receiving loop was not started, start it
+        self._start_if_not_started()
+
+        # Assign a unique ID to the request
+        req_id = uuid.uuid4().hex
+
+        # Let the manager know that we are waiting for this request
+        logger.debug(f"Pinning request #{req_id}")
+        self.req_manager.pin(req_id)
+
+        # Send the request
+        address = await self.w_manager.get_next_worker()
+        logger.debug(f"Sending request #{req_id} to worker #{address}")
+        await self.socket.send_multipart([address, b"", msgpack.packb([req_id, args, kwargs])])
+
+        # Wait until we receive the response
+        code, res = await self.req_manager.wait_for(req_id)
+        logger.debug(f"Received result for request #{req_id}")
+
+        # Depending on what is the response, deal with it properly
+        if code == CODE_FAILURE:
+            raise UserCodeException(res)
+        else:
+            return res
+
+    async def request(self, *args: Any, pintel_timeout: float = None, pintel_retries: int = 0, **kwargs: Any) -> Any:
+        """Main method, used to send a request to workers and get the result.
+
+        This method is a wrapper around `_request`, providing additional
+        functionalities :
+         * Timeout
+         * Automatic retries
+
+        Args:
+            *args: Positional arguments for the request.
+            pintel_timeout (float): Timeout for the request, in seconds.
+                If `None` is given, block until the request is complete.
+                Defaults to None.
+            pintel_retries (int): Number of retries. This argument is
+                used only if `pintel_timeout` is not `None`. If `-1` is given,
+                indefinitely retry. Defaults to 0.
+            **kwargs: Keywords arguments for the request.
+
+        Raises:
+            asyncio.TimeoutError: Error raised if no response is received within
+                the given timeout.
+
+        Returns:
+            Any: The response for the request.
+        """
+        try:
+            return await asyncio.wait_for(self._request(*args, **kwargs), timeout=pintel_timeout)
+        except asyncio.TimeoutError:
+            if pintel_retries == 0:
+                logger.error(f"Request failed : no response received within {pintel_timeout}s")
+                raise
+            else:
+                retries_left = max(pintel_retries - 1, -1)
+                logger.warning(
+                    f"Request failed : no response received within {pintel_timeout}s. Retrying {retries_left} times"
+                )
+                return await self.request(*args, pintel_timeout=pintel_timeout, pintel_retries=retries_left, **kwargs)
+
+    def __del__(self):
+        if self.socket is not None:
+            self.socket.close()

pintel/worker.py

@@ -0,0 +1,231 @@
+import signal
+import traceback
+import uuid
+from multiprocessing import Process
+from typing import Any, Callable
+
+import msgpack
+import zmq
+from loguru import logger
+
+
+DEFAULT_PORT: int = 5019
+DEFAULT_HEARTBEAT_INTERVAL: float = 1
+DEFAULT_RESET_AFTER_N_MISS: int = 2
+MS: int = 1000
+CODE_SUCCESS: int = 0
+CODE_FAILURE: int = 1
+PING: bytes = b""
+PONG: bytes = b""
+
+
+class Worker(Process):
+    """Define a worker process. This worker process indefinitely waits for
+    requests on a socket. Upon receiving a request, it processes it with the
+    worker class provided, and return the response.
+
+    After creating the Worker object, you have 2 different ways to run it :
+     * `worker.run()` : It will run in the current process directly (blocking,
+        infinite loop).
+     * `worker.start()` : It will start a different process and start the code
+        there (non-blocking).
+
+    Args:
+        worker_cls (Callable): Worker class containing the code that will be used
+            to process requests.
+        pintel_host (str): Host of the Hub. Defaults to "localhost".
+        pintel_port (int): Port of the Hub. Defaults to DEFAULT_PORT.
+        pintel_heartbeat_interval (float): Heartbeat interval between the
+            worker and the Hub. Defaults to DEFAULT_HEARTBEAT_INTERVAL.
+        pintel_reset_after_n_miss (int): Number of missed heartbeats
+            allowed before hard-resetting the socket and retrying. Defaults to
+            DEFAULT_RESET_AFTER_N_MISS.
+    """
+
+    def __init__(
+        self,
+        worker_cls: Callable,
+        *args: Any,
+        pintel_host: str = "localhost",
+        pintel_port: int = DEFAULT_PORT,
+        pintel_heartbeat_interval: float = DEFAULT_HEARTBEAT_INTERVAL,
+        pintel_reset_after_n_miss: int = DEFAULT_RESET_AFTER_N_MISS,
+        **kwargs: Any,
+    ):
+        super().__init__()
+
+        self.worker_cls = worker_cls
+        self.worker_args = args
+        self.worker_kwargs = kwargs
+
+        self.identity = uuid.uuid4().hex
+        self.host = pintel_host
+        self.port = pintel_port
+        self.heartbeat_t = pintel_heartbeat_interval
+        self.reset_n_miss = pintel_reset_after_n_miss
+
+        self.waiting_pong = 0
+
+    def create_socket(self, context: zmq.Context) -> zmq.Socket:
+        """Helper method to create a socket, setting its identity and connecting
+        to the Hub.
+
+        Args:
+            context (zmq.Context): ZMQ context to use.
+
+        Returns:
+            zmq.Socket: Initialized and connected socket, ready to use.
+        """
+        # Create the socket, set its identity
+        socket = context.socket(zmq.DEALER)
+        socket.setsockopt_string(zmq.IDENTITY, self.identity)
+
+        # Connect to the Hub
+        socket.connect(f"tcp://{self.host}:{self.port}")
+
+        return socket
+
+    def create_term_socket(self, context: zmq.Context) -> zmq.Socket:
+        """Helper method to create a termination socket.
+
+        Basically it creates 2 sockets, bind/connect them together. One socket
+        will be used to send a termination signal, and the other is returned and
+        used to receive the termination signal.
+
+        Args:
+            context (zmq.Context): ZMQ context to use.
+
+        Returns:
+            zmq.Socket: Initialized and connected socket, ready to use.
+        """
+        # Create the socket than will send the termination ping
+        term_snd_socket = context.socket(zmq.REQ)
+        port = term_snd_socket.bind_to_random_port("tcp://127.0.0.1")
+
+        # Then define the behavior on how to send the termination ping
+        def send_term(*args, **kwargs):
+            logger.debug("Sending termination ping...")
+            # Send something on the termination socket, it doesn't matter what
+            term_snd_socket.send(PING)
+
+        # We send the termination ping upon receiving these signals
+        signal.signal(signal.SIGTERM, send_term)
+        signal.signal(signal.SIGINT, send_term)
+
+        # And finally create the socket that we will use to receive the termination signal
+        term_rcv_socket = context.socket(zmq.REP)
+        term_rcv_socket.connect(f"tcp://localhost:{port}")
+
+        return term_rcv_socket
+
+    def reset_socket(self, socket: zmq.Socket, context: zmq.Context, poller: zmq.Poller) -> zmq.Socket:
+        """Helper method to reset the given socket.
+
+        This method unregister the socket from the given poller, close the
+        socket, and then recreate the socket and register this new socket in the
+        poller.
+
+        Args:
+            socket (zmq.Socket): ZMQ socket to reset.
+            context (zmq.Context): ZMQ context to use.
+            poller (zmq.Poller): ZMQ poller where the socket is registered.
+
+        Returns:
+            zmq.Socket: Initialized and connected socket, ready to use.
+        """
+        # Close the existing socket
+        poller.unregister(socket)
+        socket.close(linger=0)
+
+        # Recreate the socket
+        socket = self.create_socket(context)
+        poller.register(socket, zmq.POLLIN)
+
+        return socket
+
+    def ping(self, socket: zmq.Socket):
+        """Helper method used for the heartbeat. Also takes care of keeping the
+        counter of heartbeats up-to-date.
+
+        Args:
+            socket (zmq.Socket): Socket to use to send the heartbeat.
+        """
+        logger.debug("Sending ping...")
+        socket.send(PING)
+        self.waiting_pong += 1
+
+    def run(self):
+        """Main method. It will initialize the worker class, and enter an
+        infinite loop, waiting for requests. Whenever a request is received, it
+        processes it with the code provided in the constructor.
+        """
+        # Instanciate the worker
+        worker = self.worker_cls(*self.worker_args, **self.worker_kwargs)
+
+        # Initialize what we need for handling sockets
+        context = zmq.Context()
+        poller = zmq.Poller()
+
+        # Create the socket for termination
+        term_socket = self.create_term_socket(context)
+        poller.register(term_socket, zmq.POLLIN)
+
+        # Create the socket connecting to the hub
+        socket = self.create_socket(context)
+        poller.register(socket, zmq.POLLIN)
+
+        logger.info("Worker ready to roll")
+
+        # Tell the Hub we are ready
+        self.ping(socket)
+
+        # Indefinitely wait for requests : when we are done with one request,
+        # we wait for the next one
+        while True:
+            logger.debug("Waiting for request...")
+            events = dict(poller.poll(self.heartbeat_t * MS))
+
+            if term_socket in events:
+                logger.debug("Termination signal received, shutting down gracefully")
+                break
+
+            if socket in events:
+                _, workload = socket.recv_multipart(zmq.NOBLOCK)
+                logger.debug("Received something !")
+                self.waiting_pong = 0
+            else:
+                logger.debug(f"Didn't receive anything for {self.heartbeat_t}s ({self.waiting_pong})")
+
+                if self.waiting_pong >= self.reset_n_miss:
+                    logger.warning(
+                        f"The Hub is not answering, even after {self.waiting_pong} missed pings... "
+                        f"Resetting the socket"
+                    )
+                    socket = self.reset_socket(socket=socket, context=context, poller=poller)
+                    self.waiting_pong = 0
+
+                # We didn't receive anything for some time, try to ping again
+                self.ping(socket)
+                continue
+
+            if workload == PONG:
+                # Just a Pong, ignore it
+                logger.debug("It was just a pong...")
+                continue
+
+            # From here the Hub sent us an actual request
+            req_id, req_args, req_kwargs = msgpack.unpackb(workload)
+            logger.debug(f"Request #{req_id} received")
+
+            # Call worker's code with the request arguments
+            try:
+                res = worker(*req_args, **req_kwargs)
+            except Exception as e:
+                logger.warning(f"Exception in user-defined __call__ method : {e.__class__.__name__}({str(e)})")
+                socket.send_multipart([b"", msgpack.packb([req_id, CODE_FAILURE, traceback.format_exc()])])
+            else:
+                logger.debug("Sending back the response")
+                socket.send_multipart([b"", msgpack.packb([req_id, CODE_SUCCESS, res])])
+
+        logger.info("Worker is shut down")
+        quit()

pintel-0.3.0.dev0.dist-info/METADATA

@@ -0,0 +1,230 @@
+Metadata-Version: 2.4
+Name: pintel
+Version: 0.3.0.dev0
+Summary: Scale your ML workers asynchronously across processes and machines
+Home-page: https://github.com/astariul/pintel
+Author: Nicolas REMOND
+Author-email: remondnicola@gmail.com
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyzmq<27.0,>=22.3
+Requires-Dist: msgpack~=1.0
+Requires-Dist: loguru~=0.6
+Provides-Extra: test
+Requires-Dist: pytest~=8.0; extra == "test"
+Requires-Dist: pytest-asyncio~=0.18; extra == "test"
+Requires-Dist: pytest-cov~=3.0; extra == "test"
+Requires-Dist: coverage-badge~=1.0; extra == "test"
+Provides-Extra: hook
+Requires-Dist: pre-commit~=4.0; extra == "hook"
+Provides-Extra: lint
+Requires-Dist: isort~=5.9; extra == "lint"
+Requires-Dist: black~=24.1; extra == "lint"
+Requires-Dist: flake518~=1.2; extra == "lint"
+Requires-Dist: darglint~=1.8; extra == "lint"
+Provides-Extra: docs
+Requires-Dist: mkdocs-material~=9.0; extra == "docs"
+Requires-Dist: mkdocstrings[python]~=0.18; extra == "docs"
+Requires-Dist: mike~=2.0; extra == "docs"
+Provides-Extra: ex
+Requires-Dist: fastapi~=0.75; extra == "ex"
+Requires-Dist: uvicorn~=0.17; extra == "ex"
+Requires-Dist: requests~=2.27; extra == "ex"
+Requires-Dist: transformers~=4.17; extra == "ex"
+Provides-Extra: all
+Requires-Dist: pytest~=8.0; extra == "all"
+Requires-Dist: pytest-asyncio~=0.18; extra == "all"
+Requires-Dist: pytest-cov~=3.0; extra == "all"
+Requires-Dist: coverage-badge~=1.0; extra == "all"
+Requires-Dist: pre-commit~=4.0; extra == "all"
+Requires-Dist: isort~=5.9; extra == "all"
+Requires-Dist: black~=24.1; extra == "all"
+Requires-Dist: flake518~=1.2; extra == "all"
+Requires-Dist: darglint~=1.8; extra == "all"
+Requires-Dist: mkdocs-material~=9.0; extra == "all"
+Requires-Dist: mkdocstrings[python]~=0.18; extra == "all"
+Requires-Dist: mike~=2.0; extra == "all"
+Requires-Dist: fastapi~=0.75; extra == "all"
+Requires-Dist: uvicorn~=0.17; extra == "all"
+Requires-Dist: requests~=2.27; extra == "all"
+Requires-Dist: transformers~=4.17; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest~=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio~=0.18; extra == "dev"
+Requires-Dist: pytest-cov~=3.0; extra == "dev"
+Requires-Dist: coverage-badge~=1.0; extra == "dev"
+Requires-Dist: pre-commit~=4.0; extra == "dev"
+Requires-Dist: isort~=5.9; extra == "dev"
+Requires-Dist: black~=24.1; extra == "dev"
+Requires-Dist: flake518~=1.2; extra == "dev"
+Requires-Dist: darglint~=1.8; extra == "dev"
+Requires-Dist: mkdocs-material~=9.0; extra == "dev"
+Requires-Dist: mkdocstrings[python]~=0.18; extra == "dev"
+Requires-Dist: mike~=2.0; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<h1 align="center">pintel</h1>
+<p align="center">
+Scale your ML workers asynchronously across processes and machines
+</p>
+
+<p align="center">
+    <a href="https://github.com/astariul/pintel/releases"><img src="https://img.shields.io/github/release/astariul/pintel.svg" alt="GitHub release" /></a>
+    <a href="https://github.com/astariul/pintel/actions/workflows/pytest.yaml"><img src="https://github.com/astariul/pintel/actions/workflows/pytest.yaml/badge.svg" alt="Test status" /></a>
+    <a href="https://github.com/astariul/pintel/actions/workflows/lint.yaml"><img src="https://github.com/astariul/pintel/actions/workflows/lint.yaml/badge.svg" alt="Lint status" /></a>
+    <img src=".github/badges/coverage.svg" alt="Coverage status" />
+    <a href="https://astariul.github.io/pintel"><img src="https://img.shields.io/website?down_message=failing&label=docs&up_color=green&up_message=passing&url=https%3A%2F%2Fastariul.github.io%2Fpintel" alt="Docs" /></a>
+    <a href="https://github.com/astariul/pintel/blob/main/LICENSE"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="licence" /></a>
+</p>
+
+<p align="center">
+  <a href="#description">Description</a> •
+  <a href="#install">Install</a> •
+  <a href="#usage">Usage</a> •
+  <a href="#faq">FAQ</a> •
+  <a href="#contribute">Contribute</a>
+  <br>
+  <a href="https://astariul.github.io/pintel/" target="_blank">Documentation</a>
+</p>
+
+
+<h2 align="center">Description</h2>
+
+**`pintel`** is a python package that helps you scale your ML workers (or any python code) across processes and machines, asynchronously.
+
+`pintel` is :
+
+* ⚡️ Highly performant
+* 🔀 Asynchronous
+* 🐥 Easy-to-use
+
+
+<h2 align="center">Install</h2>
+
+Install `pintel` by running :
+
+
+```
+pip install pintel
+```
+
+
+<h2 align="center">Usage</h2>
+
+After defining your awesome model :
+
+```python
+import time
+
+class MyAwesomeModel:
+    def __init__(self, wait_time=0.25):
+        super().__init__()
+        self.w = wait_time
+
+    def __call__(self, x):
+        time.sleep(self.w)
+        return x**2
+```
+
+You can simply start a few workers serving the model :
+
+```python
+from pintel import Worker
+
+for _ in range(4):
+    Worker(MyAwesomeModel).start()
+```
+
+And send requests through the Hub :
+
+```python
+from pintel import Hub
+
+hub = Hub()
+
+# In an async function
+await hub.request(34)
+```
+
+And that's it !
+
+---
+
+Make sure to check the [documentation](https://astariul.github.io/pintel/usage/) for a more detailed explanation.
+
+Or you can run some examples from the `examples/` folder.
+
+
+<h2 align="center">FAQ</h2>
+
+#### ❓ **How `pintel` works ?**
+
+`pintel` simply run your model code in separate processes, and send requests to the right process to ensure requests are treated in parallel.
+
+`pintel` uses a modified form of [the Paranoid Pirate Pattern from the zmq guide](https://zguide.zeromq.org/docs/chapter4/#Robust-Reliable-Queuing-Paranoid-Pirate-Pattern).
+
+#### ❓ **Why the name "pintel" ?**
+
+Pintel is one of the pirates of Captain Barbossa's crew on the Black Pearl.  
+Since we are using the Paranoid Pirate Pattern, we needed a pirate name !
+
+<h2 align="center">Contribute</h2>
+
+To contribute, install the package locally, create your own branch, add your code (and tests, and documentation), and open a PR !
+
+### Pre-commit hooks
+
+Pre-commit hooks are set to check the code added whenever you commit something.
+
+If you never ran the hooks before, install it with :
+
+```bash
+pre-commit install
+```
+
+---
+
+Then you can just try to commit your code. If you code does not meet the quality required by linters, it will not be committed. You can just fix your code and try to commit again !
+
+---
+
+You can manually run the pre-commit hooks with :
+
+```bash
+pre-commit run --all-files
+```
+
+### Tests
+
+When you contribute, you need to make sure all the unit-tests pass. You should also add tests if necessary !
+
+You can run the tests with :
+
+```bash
+pytest
+```
+
+---
+
+Pre-commit hooks will not run the tests, but it will automatically update the coverage badge !
+
+### Documentation
+
+The documentation should be kept up-to-date. You can visualize the documentation locally by running :
+
+```bash
+mkdocs serve
+```

pintel-0.3.0.dev0.dist-info/RECORD

@@ -0,0 +1,8 @@
+pintel/__init__.py,sha256=O3Zed-_llzmSEe-eAGjuQ0v76N4PNLp-CbiGvgqDAGY,121
+pintel/hub.py,sha256=wua2GZ-LmnVyy2WW1W4sS_CskLJA6aBHGb1nRPyR-Jg,11288
+pintel/worker.py,sha256=Ipn3NQUgNK51nLoRsJJgDJutqeMyfiN-QqrYgUFxJgk,8476
+pintel-0.3.0.dev0.dist-info/licenses/LICENSE,sha256=efxIJwqRW2jrT96PhExhD9OYd4DjZ9GKfq2UKwog8kc,1065
+pintel-0.3.0.dev0.dist-info/METADATA,sha256=OtZNH3XidsQf3UxB50_5JN8ZSokRP1z68ekTAPtSX-M,7139
+pintel-0.3.0.dev0.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
+pintel-0.3.0.dev0.dist-info/top_level.txt,sha256=TJn487U_Ud0TaVQFbCER0Ki3fqSan5l6bVevHf54GWg,7
+pintel-0.3.0.dev0.dist-info/RECORD,,

pintel-0.3.0.dev0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (79.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pintel-0.3.0.dev0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Astariul
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pintel-0.3.0.dev0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pintel