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

wool/_mempool/__init__.py

@@ -1,3 +1,4 @@
 from wool._mempool._mempool import MemoryPool
+from wool._mempool._service import MemoryPoolService
 
-__all__ = ["MemoryPool"]
+__all__ = ["MemoryPool", "MemoryPoolService"]

wool/_mempool/_mempool.py

@@ -1,34 +1,141 @@
+from __future__ import annotations
+
 import asyncio
 import hashlib
 import mmap
 import os
 import pathlib
 import shutil
-from collections import namedtuple
 from contextlib import asynccontextmanager
-from dataclasses import asdict
-from dataclasses import fields
-from types import MappingProxyType
+from typing import BinaryIO
+
+try:
+    from typing import Self
+except ImportError:
+    from typing_extensions import Self
 
 import shortuuid
 
 from wool._mempool._metadata import MetadataMessage
 
-Metadata = namedtuple(
-    "Metadata",
-    [field.name for field in fields(MetadataMessage)],
-)
 
+class SharedObject:
+    _id: str
+    _mempool: MemoryPool
+    _file: BinaryIO
+    _mmap: mmap.mmap
+    _size: int
+    _md5: bytes
+
+    def __init__(self, id: str, *, mempool: MemoryPool):
+        self._id = id
+        self._mempool = mempool
+        self._file = open(self._path / "dump", "r+b")
+        self._mmap = mmap.mmap(self._file.fileno(), 0)
+        self._size = self.metadata.size
+        self._md5 = self.metadata.md5
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def metadata(self) -> SharedObjectMetadata:
+        return SharedObjectMetadata(self.id, mempool=self._mempool)
+
+    @property
+    def mmap(self) -> mmap.mmap:
+        return self._mmap
+
+    @property
+    def _path(self) -> pathlib.Path:
+        return pathlib.Path(self._mempool.path, self.id)
+
+    def close(self):
+        self.metadata.close()
+        self._mmap.close()
+        self._file.close()
+
+    def refresh(self) -> Self:
+        if self._size != self.metadata.size or self._md5 != self.metadata.md5:
+            self._mmap.close()
+            self._file.close()
+            self._file = open(self._path / "dump", "r+b")
+            self._mmap = mmap.mmap(self._file.fileno(), 0)
+            self._size = self.metadata.size
+            self._md5 = self.metadata.md5
+        return self
+
+
+class SharedObjectMetadata:
+    _id: str
+    _mempool: MemoryPool
+    _file: BinaryIO
+    _mmap: mmap.mmap
+    _instances: dict[str, SharedObjectMetadata] = {}
+
+    def __new__(cls, id: str, *, mempool: MemoryPool):
+        if id in cls._instances:
+            return cls._instances[id]
+        return super().__new__(cls)
+
+    def __init__(self, id: str, mempool: MemoryPool):
+        self._id = id
+        self._mempool = mempool
+        self._file = open(self._path / "meta", "r+b")
+        self._mmap = mmap.mmap(self._file.fileno(), 0)
+        self._instances[id] = self
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    @property
+    def id(self) -> str:
+        return self._id
+
+    @property
+    def mutable(self) -> bool:
+        return self._metadata.mutable
+
+    @property
+    def size(self) -> int:
+        return self._metadata.size
+
+    @property
+    def md5(self) -> bytes:
+        return self._metadata.md5
+
+    @property
+    def mmap(self) -> mmap.mmap:
+        return self._mmap
+
+    @property
+    def _path(self) -> pathlib.Path:
+        return pathlib.Path(self._mempool.path, self.id)
 
-class MetadataMapping:
-    def __init__(self, mapping) -> None:
-        self._mapping = MappingProxyType(mapping)
+    @property
+    def _metadata(self) -> MetadataMessage:
+        return MetadataMessage.loads(bytes(self._mmap))
 
-    def __getitem__(self, key: str) -> Metadata:
-        return Metadata(**asdict(self._mapping[key]))
+    def close(self):
+        self._mmap.close()
+        self._file.close()
+        del self._instances[self.id]
 
 
 class MemoryPool:
+    _objects: dict[str, SharedObject]
+    _path: pathlib.Path
+
     def __init__(self, path: str | pathlib.Path = pathlib.Path(".mempool")):
         if isinstance(path, str):
             self._path = pathlib.Path(path)
@@ -36,89 +143,86 @@ class MemoryPool:
             self._path = path
         self._lockdir = self._path / "locks"
         os.makedirs(self._lockdir, exist_ok=True)
-        self._files = {}
-        self._mmaps = {}
-        self._metadata: dict[str, MetadataMessage] = {}
+        self._acquire(f"pid-{os.getpid()}")
+        self._objects = dict()
 
-    @property
-    def metadata(self) -> MetadataMapping:
-        return MetadataMapping(self._metadata)
+    def __contains__(self, ref: str) -> bool:
+        return ref in self._objects
+
+    def __del__(self):
+        self._release(f"pid-{os.getpid()}")
 
     @property
     def path(self) -> pathlib.Path:
         return self._path
 
-    async def map(self):
-        for entry in os.scandir(self._path):
-            if entry.is_dir() and (ref := entry.name) != "locks":
-                async with self._reflock(ref):
-                    self._map(ref)
+    async def map(self, ref: str | None = None):
+        if ref is not None and ref not in self._objects:
+            if self._locked(f"delete-{ref}"):
+                raise RuntimeError(
+                    f"Reference {ref} is currently locked for deletion"
+                )
+            async with self._reference_lock(ref):
+                self._map(ref)
+        else:
+            for entry in os.scandir(self._path):
+                if entry.is_dir() and (ref := entry.name) != "locks":
+                    if not self._locked(f"delete-{ref}"):
+                        async with self._reference_lock(ref):
+                            self._map(ref)
 
     async def put(
         self, dump: bytes, *, mutable: bool = False, ref: str | None = None
     ) -> str:
-        async with self._reflock(ref := ref or str(shortuuid.uuid())):
+        ref = ref or str(shortuuid.uuid())
+        async with self._reference_lock(ref):
             self._put(ref, dump, mutable=mutable, exist_ok=False)
             return ref
 
-    async def post(self, ref: str, dump: bytes):
-        async with self._reflock(ref):
-            if ref not in self._mmaps:
-                self._map(ref)
-            metamap, dumpmap = self._mmaps[ref]
-            metamap.seek(0)
-            metadata = self._metadata.setdefault(
-                ref, MetadataMessage.loads(metamap.read())
+    async def post(self, ref: str, dump: bytes) -> bool:
+        if self._locked(f"delete-{ref}"):
+            raise RuntimeError(
+                f"Reference {ref} is currently locked for deletion"
             )
-            if not metadata.mutable:
+        async with self._reference_lock(ref):
+            if ref not in self._objects:
+                self._map(ref)
+            obj = self._objects[ref]
+            if not obj.metadata.mutable:
                 raise ValueError("Cannot modify an immutable reference")
-            if (size := len(dump)) != metadata.size:
+            if (size := len(dump)) != obj.metadata.size:
                 try:
-                    dumpmap.resize(size)
-                    self._post(ref, dump, metadata)
+                    obj.mmap.resize(size)
+                    self._post(ref, obj, dump)
                 except SystemError:
                     self._put(ref, dump, mutable=True, exist_ok=True)
                 return True
-            elif hashlib.md5(dump).digest() != metadata.md5:
-                self._post(ref, dump, metadata)
+            elif hashlib.md5(dump).digest() != obj.metadata.md5:
+                self._post(ref, obj, dump)
                 return True
             else:
                 return False
 
     async def get(self, ref: str) -> bytes:
-        async with self._reflock(ref):
-            if ref not in self._mmaps:
-                self._map(ref)
-            metamap, dumpmap = self._mmaps[ref]
-            metamap.seek(0)
-            metadata = MetadataMessage.loads(metamap.read())
-            cached_metadata = self._metadata.setdefault(ref, metadata)
-            if metadata.mutable and metadata.size != cached_metadata.size:
-                # Dump size has changed, so we need to re-map it
+        if self._locked(f"delete-{ref}"):
+            raise RuntimeError(
+                f"Reference {ref} is currently locked for deletion"
+            )
+        async with self._reference_lock(ref):
+            if ref not in self._objects:
                 self._map(ref)
-            dumpmap.seek(0)
-            return dumpmap.read()
+            return bytes(self._objects[ref].refresh().mmap)
 
     async def delete(self, ref: str):
-        async with self._reflock(ref):
-            if ref not in self._mmaps:
-                self._map(ref)
-            metamap, dumpmap = self._mmaps.pop(ref)
-            metafile, dumpfile = self._files.pop(ref)
-            if ref in self._metadata:
-                del self._metadata[ref]
-            if metamap:
-                metamap.close()
-            if dumpmap:
-                dumpmap.close()
-            if metafile:
-                metafile.close()
-            if dumpfile:
-                dumpfile.close()
-            try:
-                shutil.rmtree(self.path / ref)
-            except FileNotFoundError:
-                pass
+        async with self._delete_lock(ref):
+            async with self._reference_lock(ref):
+                if ref not in self._objects:
+                    self._map(ref)
+                self._objects.pop(ref).close()
+                try:
+                    shutil.rmtree(self.path / ref)
+                except FileNotFoundError:
+                    pass
 
     def _put(
         self,
@@ -145,60 +249,63 @@ class MemoryPool:
             dumpfile.write(dump)
 
         self._map(ref)
-        self._metadata[ref] = metadata
-
-    def _post(self, ref: str, dump: bytes, metadata: MetadataMessage):
-        metamap, dumpmap = self._mmaps[ref]
-        metadata.size = len(dump)
-        metadata.md5 = hashlib.md5(dump).digest()
-        metamap.seek(0)
-        metamap.write(metadata.dumps())
-        metamap.flush()
-        dumpmap.seek(0)
-        dumpmap.write(dump)
-        dumpmap.flush()
+
+    def _post(self, ref: str, obj: SharedObject, dump: bytes):
+        if not obj.metadata.mutable:
+            raise ValueError("Cannot modify an immutable reference")
+        metadata = MetadataMessage(
+            ref=ref,
+            mutable=True,
+            size=len(dump),
+            md5=hashlib.md5(dump).digest(),
+        )
+        obj.metadata.mmap[:] = metadata.dumps()
+        obj.metadata.mmap.flush()
+        obj.mmap.seek(0)
+        obj.mmap.write(dump)
 
     def _map(self, ref: str):
-        refpath = pathlib.Path(self._path, f"{ref}")
-        metafile = open(refpath / "meta", "r+b")
-        metamap = mmap.mmap(metafile.fileno(), 0, flags=mmap.MAP_SHARED)
-        dumpfile = open(refpath / "dump", "r+b")
-        dumpmap = mmap.mmap(dumpfile.fileno(), 0, flags=mmap.MAP_SHARED)
-        cached_metafile, cached_dumpfile = self._files.pop(ref, (None, None))
-        if cached_metafile:
-            cached_metafile.close()
-        if cached_dumpfile:
-            cached_dumpfile.close()
-        cached_metamap, cached_dumpmap = self._mmaps.pop(ref, (None, None))
-        if cached_metamap is not None and not cached_metamap.closed:
-            cached_metamap.close()
-        if cached_dumpmap is not None and not cached_dumpmap.closed:
-            cached_dumpmap.close()
-        self._files[ref] = (metafile, dumpfile)
-        self._mmaps[ref] = (metamap, dumpmap)
-
-    def _lockpath(self, ref: str):
-        return pathlib.Path(self._lockdir, f"{ref}.lock")
-
-    def _acquire(self, ref: str):
+        obj = self._objects.pop(ref, None)
+        if obj:
+            obj.close()
+        self._objects[ref] = SharedObject(id=ref, mempool=self)
+
+    def _lockpath(self, key: str) -> pathlib.Path:
+        return pathlib.Path(self._lockdir, f"{key}.lock")
+
+    def _acquire(self, key: str) -> bool:
         try:
-            os.symlink(f"{ref}", self._lockpath(ref))
+            os.symlink(f"{key}", self._lockpath(key))
             return True
         except FileExistsError:
             return False
 
-    def _release(self, ref: str):
+    def _release(self, key: str):
         try:
-            if os.path.islink(lock_path := self._lockpath(ref)):
+            if os.path.islink(lock_path := self._lockpath(key)):
                 os.unlink(lock_path)
         except FileNotFoundError:
             pass
 
+    def _locked(self, key: str) -> bool:
+        return os.path.islink(self._lockpath(key))
+
     @asynccontextmanager
-    async def _reflock(self, ref: str):
+    async def _reference_lock(self, ref: str):
         try:
             while not self._acquire(ref):
                 await asyncio.sleep(0)
             yield
         finally:
             self._release(ref)
+
+    @asynccontextmanager
+    async def _delete_lock(self, ref: str):
+        key = f"delete-{ref}"
+        if not self._acquire(f"delete-{ref}"):
+            raise RuntimeError(
+                f"Reference {ref} is currently locked for deletion"
+            )
+        else:
+            yield
+        self._release(key)

wool/_mempool/{_metadata/__init__.py → _metadata.py}

@@ -4,9 +4,7 @@ import logging
 from dataclasses import dataclass
 
 try:
-    from wool._protobuf._mempool._metadata._metadata_pb2 import (
-        _MetadataMessage,
-    )
+    from wool._protobuf.mempool.metadata.metadata_pb2 import _MetadataMessage
 except ImportError:
     logging.error(
         "Failed to import _MetadataMessage. "

wool/_mempool/_service.py

@@ -0,0 +1,225 @@
+from __future__ import annotations
+
+import asyncio
+from typing import AsyncGenerator
+from typing import Final
+from weakref import WeakSet
+from weakref import WeakValueDictionary
+
+import shortuuid
+from grpc.aio import ServicerContext
+
+from wool._mempool import MemoryPool
+from wool._protobuf.mempool import mempool_pb2 as proto
+from wool._protobuf.mempool import mempool_pb2_grpc as rpc
+
+
+class Session:
+    """
+    A session represents a client connection to the memory pool service and
+    serves as the scope for any shared references acquired over its duration.
+    """
+
+    id: Final[str]
+    queue: Final[asyncio.Queue[proto.SessionResponse]]
+    references: Final[set[Reference]]
+    sessions: Final[WeakValueDictionary[str, Session]] = WeakValueDictionary()
+
+    @classmethod
+    def get(cls, id: str) -> Session | None:
+        return cls.sessions.get(id)
+
+    def __init__(self):
+        self.id = shortuuid.uuid()
+        self.queue = asyncio.Queue()
+        self.references = set()
+        self.sessions[self.id] = self
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, Session):
+            return self.id == other.id
+        return False
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+
+class Reference:
+    id: Final[str]
+    mempool: Final[MemoryPool]
+    sessions: Final[WeakSet[Session]]
+
+    _references: Final[WeakValueDictionary[str, Reference]] = (
+        WeakValueDictionary()
+    )
+    _to_delete: Final[set[str]] = set()
+    _initialized: bool = False
+
+    @classmethod
+    def get(cls, id: str) -> Reference | None:
+        return cls._references.get(id)
+
+    @classmethod
+    def new(cls, id: str, *, mempool: MemoryPool) -> Reference:
+        if id in cls._references:
+            raise ValueError(f"Reference {id} already exists")
+        return cls(id, mempool=mempool)
+
+    def __new__(cls, id: str, *, mempool: MemoryPool):
+        if id in cls._references:
+            if id in cls._to_delete:
+                cls._to_delete.remove(id)
+            return cls._references[id]
+        return super().__new__(cls)
+
+    def __init__(self, id: str, *, mempool: MemoryPool):
+        if not self._initialized:
+            self.id = id
+            self.mempool = mempool
+            self.sessions = WeakSet()
+            self._references[id] = self
+            self._initialized = True
+
+    def __eq__(self, other) -> bool:
+        if isinstance(other, Reference):
+            return self.id == other.id
+        return False
+
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    def __del__(self):
+        self._to_delete.add(self.id)
+
+        id = self.id
+        to_delete = self._to_delete
+        mempool = self.mempool
+
+        async def _delete():
+            if id in to_delete:
+                try:
+                    to_delete.remove(id)
+                    await mempool.delete(id)
+                except FileNotFoundError:
+                    pass
+
+        try:
+            asyncio.get_running_loop().create_task(_delete())
+        except RuntimeError:
+            asyncio.new_event_loop().run_until_complete(_delete())
+
+
+class MemoryPoolService(rpc.MemoryPoolServicer):
+    def __init__(self, mempool: MemoryPool | None = None):
+        self._mempool = mempool or MemoryPool()
+        self._shutdown = asyncio.Event()
+
+    async def session(
+        self, request: proto.SessionRequest, context: ServicerContext
+    ) -> AsyncGenerator[proto.SessionResponse]:
+        session = Session()
+        yield proto.SessionResponse(session=proto.Session(id=session.id))
+        while True:
+            yield await session.queue.get()
+
+    async def acquire(
+        self, request: proto.AcquireRequest, context: ServicerContext
+    ) -> proto.AcquireResponse:
+        if not (session := Session.get(request.session.id)):
+            raise ValueError(f"Session {request.session.id} not found")
+        if not (reference := Reference.get(request.reference.id)):
+            raise ValueError(f"Reference {request.reference.id} not found")
+        session.references.add(reference)
+        reference.sessions.add(session)
+        return proto.AcquireResponse()
+
+    async def map(
+        self, request: proto.AcquireRequest, context: ServicerContext
+    ) -> proto.AcquireResponse:
+        if not (session := Session.get(request.session.id)):
+            raise ValueError(f"Session {request.session.id} not found")
+        await self._mempool.map(request.reference.id)
+        reference = Reference(request.reference.id, mempool=self._mempool)
+        await self.acquire(
+            proto.AcquireRequest(
+                session=proto.Session(id=session.id),
+                reference=proto.Reference(id=reference.id),
+            ),
+            context,
+        )
+        return proto.AcquireResponse()
+
+    async def put(
+        self, request: proto.PutRequest, context: ServicerContext
+    ) -> proto.PutResponse:
+        if not (session := Session.get(request.session.id)):
+            raise ValueError(f"Session {request.session.id} not found")
+        reference = Reference(
+            id=await self._mempool.put(request.dump, mutable=request.mutable),
+            mempool=self._mempool,
+        )
+        await self.acquire(
+            proto.AcquireRequest(
+                session=proto.Session(id=session.id),
+                reference=proto.Reference(id=reference.id),
+            ),
+            context,
+        )
+        return proto.PutResponse(reference=proto.Reference(id=reference.id))
+
+    async def get(
+        self, request: proto.GetRequest, context: ServicerContext
+    ) -> proto.GetResponse:
+        if not (session := Session.get(request.session.id)):
+            raise ValueError(f"Session {request.session.id} not found")
+        if not (reference := Reference.get(request.reference.id)):
+            raise ValueError(f"Reference {request.reference.id} not found")
+        if reference not in session.references:
+            await self.acquire(
+                proto.AcquireRequest(
+                    session=proto.Session(id=session.id),
+                    reference=proto.Reference(id=reference.id),
+                ),
+                context,
+            )
+        dump = await self._mempool.get(reference.id)
+        return proto.GetResponse(dump=dump)
+
+    async def post(
+        self, request: proto.PostRequest, context: ServicerContext
+    ) -> proto.PostResponse:
+        if not (session := Session.get(request.session.id)):
+            raise ValueError(f"Session {request.session.id} not found")
+        if not (reference := Reference.get(request.reference.id)):
+            raise ValueError(f"Reference {request.reference.id} not found")
+        if reference not in session.references:
+            await self.acquire(
+                proto.AcquireRequest(
+                    session=proto.Session(id=session.id),
+                    reference=proto.Reference(id=reference.id),
+                ),
+                context,
+            )
+        updated = await self._mempool.post(request.reference.id, request.dump)
+        if updated:
+            for session in Reference(
+                id=request.reference.id, mempool=self._mempool
+            ).sessions:
+                if session.id is not request.session.id:
+                    event = proto.Event(
+                        reference=request.reference,
+                        event_type="post",
+                    )
+                    await session.queue.put(proto.SessionResponse(event=event))
+        return proto.PostResponse(updated=updated)
+
+    async def release(
+        self, request: proto.ReleaseRequest, context: ServicerContext
+    ) -> proto.ReleaseResponse:
+        if not (session := Session.get(request.session.id)):
+            raise ValueError(f"Session {request.session.id} not found")
+        if not (reference := Reference.get(request.reference.id)):
+            raise ValueError(f"Reference {request.reference.id} not found")
+        session.references.remove(reference)
+        reference.sessions.remove(session)
+        return proto.ReleaseResponse()

wool/_protobuf/__init__.py

@@ -0,0 +1,4 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))

wool/_protobuf/mempool/mempool_pb2.py

@@ -0,0 +1,66 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# NO CHECKED-IN PROTOBUF GENCODE
+# source: mempool/mempool.proto
+# Protobuf Python Version: 6.31.0
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import runtime_version as _runtime_version
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+_runtime_version.ValidateProtobufRuntimeVersion(
+    _runtime_version.Domain.PUBLIC,
+    6,
+    31,
+    0,
+    '',
+    'mempool/mempool.proto'
+)
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15mempool/mempool.proto\x12\x16wool._protobuf.mempool\"\x10\n\x0eSessionRequest\"\x81\x01\n\x0fSessionResponse\x12\x32\n\x07session\x18\x01 \x01(\x0b\x32\x1f.wool._protobuf.mempool.SessionH\x00\x12.\n\x05\x65vent\x18\x02 \x01(\x0b\x32\x1d.wool._protobuf.mempool.EventH\x00\x42\n\n\x08response\"x\n\x0e\x41\x63quireRequest\x12\x34\n\treference\x18\x01 \x01(\x0b\x32!.wool._protobuf.mempool.Reference\x12\x30\n\x07session\x18\x02 \x01(\x0b\x32\x1f.wool._protobuf.mempool.Session\"\x11\n\x0f\x41\x63quireResponse\"]\n\nPutRequest\x12\x30\n\x07session\x18\x01 \x01(\x0b\x32\x1f.wool._protobuf.mempool.Session\x12\x0f\n\x07mutable\x18\x02 \x01(\x08\x12\x0c\n\x04\x64ump\x18\x03 \x01(\x0c\"C\n\x0bPutResponse\x12\x34\n\treference\x18\x01 \x01(\x0b\x32!.wool._protobuf.mempool.Reference\"\x83\x01\n\x0bPostRequest\x12\x30\n\x07session\x18\x01 \x01(\x0b\x32\x1f.wool._protobuf.mempool.Session\x12\x34\n\treference\x18\x02 \x01(\x0b\x32!.wool._protobuf.mempool.Reference\x12\x0c\n\x04\x64ump\x18\x03 \x01(\x0c\"\x1f\n\x0cPostResponse\x12\x0f\n\x07updated\x18\x01 \x01(\x08\"t\n\nGetRequest\x12\x34\n\treference\x18\x01 \x01(\x0b\x32!.wool._protobuf.mempool.Reference\x12\x30\n\x07session\x18\x02 \x01(\x0b\x32\x1f.wool._protobuf.mempool.Session\"\x1b\n\x0bGetResponse\x12\x0c\n\x04\x64ump\x18\x01 \x01(\x0c\"x\n\x0eReleaseRequest\x12\x34\n\treference\x18\x01 \x01(\x0b\x32!.wool._protobuf.mempool.Reference\x12\x30\n\x07session\x18\x02 \x01(\x0b\x32\x1f.wool._protobuf.mempool.Session\"\x11\n\x0fReleaseResponse\"\x17\n\tReference\x12\n\n\x02id\x18\x01 \x01(\t\"\x15\n\x07Session\x12\n\n\x02id\x18\x01 \x01(\t\"Q\n\x05\x45vent\x12\x34\n\treference\x18\x01 \x01(\x0b\x32!.wool._protobuf.mempool.Reference\x12\x12\n\nevent_type\x18\x02 \x01(\t2\x95\x04\n\nMemoryPool\x12\\\n\x07session\x12&.wool._protobuf.mempool.SessionRequest\x1a\'.wool._protobuf.mempool.SessionResponse0\x01\x12Z\n\x07\x61\x63quire\x12&.wool._protobuf.mempool.AcquireRequest\x1a\'.wool._protobuf.mempool.AcquireResponse\x12N\n\x03put\x12\".wool._protobuf.mempool.PutRequest\x1a#.wool._protobuf.mempool.PutResponse\x12Q\n\x04post\x12#.wool._protobuf.mempool.PostRequest\x1a$.wool._protobuf.mempool.PostResponse\x12N\n\x03get\x12\".wool._protobuf.mempool.GetRequest\x1a#.wool._protobuf.mempool.GetResponse\x12Z\n\x07release\x12&.wool._protobuf.mempool.ReleaseRequest\x1a\'.wool._protobuf.mempool.ReleaseResponseb\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'mempool.mempool_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_SESSIONREQUEST']._serialized_start=49
+  _globals['_SESSIONREQUEST']._serialized_end=65
+  _globals['_SESSIONRESPONSE']._serialized_start=68
+  _globals['_SESSIONRESPONSE']._serialized_end=197
+  _globals['_ACQUIREREQUEST']._serialized_start=199
+  _globals['_ACQUIREREQUEST']._serialized_end=319
+  _globals['_ACQUIRERESPONSE']._serialized_start=321
+  _globals['_ACQUIRERESPONSE']._serialized_end=338
+  _globals['_PUTREQUEST']._serialized_start=340
+  _globals['_PUTREQUEST']._serialized_end=433
+  _globals['_PUTRESPONSE']._serialized_start=435
+  _globals['_PUTRESPONSE']._serialized_end=502
+  _globals['_POSTREQUEST']._serialized_start=505
+  _globals['_POSTREQUEST']._serialized_end=636
+  _globals['_POSTRESPONSE']._serialized_start=638
+  _globals['_POSTRESPONSE']._serialized_end=669
+  _globals['_GETREQUEST']._serialized_start=671
+  _globals['_GETREQUEST']._serialized_end=787
+  _globals['_GETRESPONSE']._serialized_start=789
+  _globals['_GETRESPONSE']._serialized_end=816
+  _globals['_RELEASEREQUEST']._serialized_start=818
+  _globals['_RELEASEREQUEST']._serialized_end=938
+  _globals['_RELEASERESPONSE']._serialized_start=940
+  _globals['_RELEASERESPONSE']._serialized_end=957
+  _globals['_REFERENCE']._serialized_start=959
+  _globals['_REFERENCE']._serialized_end=982
+  _globals['_SESSION']._serialized_start=984
+  _globals['_SESSION']._serialized_end=1005
+  _globals['_EVENT']._serialized_start=1007
+  _globals['_EVENT']._serialized_end=1088
+  _globals['_MEMORYPOOL']._serialized_start=1091
+  _globals['_MEMORYPOOL']._serialized_end=1624
+# @@protoc_insertion_point(module_scope)

wool/_protobuf/mempool/mempool_pb2.pyi

@@ -0,0 +1,108 @@
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from collections.abc import Mapping as _Mapping
+from typing import ClassVar as _ClassVar, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+
+class SessionRequest(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class SessionResponse(_message.Message):
+    __slots__ = ("session", "event")
+    SESSION_FIELD_NUMBER: _ClassVar[int]
+    EVENT_FIELD_NUMBER: _ClassVar[int]
+    session: Session
+    event: Event
+    def __init__(self, session: _Optional[_Union[Session, _Mapping]] = ..., event: _Optional[_Union[Event, _Mapping]] = ...) -> None: ...
+
+class AcquireRequest(_message.Message):
+    __slots__ = ("reference", "session")
+    REFERENCE_FIELD_NUMBER: _ClassVar[int]
+    SESSION_FIELD_NUMBER: _ClassVar[int]
+    reference: Reference
+    session: Session
+    def __init__(self, reference: _Optional[_Union[Reference, _Mapping]] = ..., session: _Optional[_Union[Session, _Mapping]] = ...) -> None: ...
+
+class AcquireResponse(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class PutRequest(_message.Message):
+    __slots__ = ("session", "mutable", "dump")
+    SESSION_FIELD_NUMBER: _ClassVar[int]
+    MUTABLE_FIELD_NUMBER: _ClassVar[int]
+    DUMP_FIELD_NUMBER: _ClassVar[int]
+    session: Session
+    mutable: bool
+    dump: bytes
+    def __init__(self, session: _Optional[_Union[Session, _Mapping]] = ..., mutable: bool = ..., dump: _Optional[bytes] = ...) -> None: ...
+
+class PutResponse(_message.Message):
+    __slots__ = ("reference",)
+    REFERENCE_FIELD_NUMBER: _ClassVar[int]
+    reference: Reference
+    def __init__(self, reference: _Optional[_Union[Reference, _Mapping]] = ...) -> None: ...
+
+class PostRequest(_message.Message):
+    __slots__ = ("session", "reference", "dump")
+    SESSION_FIELD_NUMBER: _ClassVar[int]
+    REFERENCE_FIELD_NUMBER: _ClassVar[int]
+    DUMP_FIELD_NUMBER: _ClassVar[int]
+    session: Session
+    reference: Reference
+    dump: bytes
+    def __init__(self, session: _Optional[_Union[Session, _Mapping]] = ..., reference: _Optional[_Union[Reference, _Mapping]] = ..., dump: _Optional[bytes] = ...) -> None: ...
+
+class PostResponse(_message.Message):
+    __slots__ = ("updated",)
+    UPDATED_FIELD_NUMBER: _ClassVar[int]
+    updated: bool
+    def __init__(self, updated: bool = ...) -> None: ...
+
+class GetRequest(_message.Message):
+    __slots__ = ("reference", "session")
+    REFERENCE_FIELD_NUMBER: _ClassVar[int]
+    SESSION_FIELD_NUMBER: _ClassVar[int]
+    reference: Reference
+    session: Session
+    def __init__(self, reference: _Optional[_Union[Reference, _Mapping]] = ..., session: _Optional[_Union[Session, _Mapping]] = ...) -> None: ...
+
+class GetResponse(_message.Message):
+    __slots__ = ("dump",)
+    DUMP_FIELD_NUMBER: _ClassVar[int]
+    dump: bytes
+    def __init__(self, dump: _Optional[bytes] = ...) -> None: ...
+
+class ReleaseRequest(_message.Message):
+    __slots__ = ("reference", "session")
+    REFERENCE_FIELD_NUMBER: _ClassVar[int]
+    SESSION_FIELD_NUMBER: _ClassVar[int]
+    reference: Reference
+    session: Session
+    def __init__(self, reference: _Optional[_Union[Reference, _Mapping]] = ..., session: _Optional[_Union[Session, _Mapping]] = ...) -> None: ...
+
+class ReleaseResponse(_message.Message):
+    __slots__ = ()
+    def __init__(self) -> None: ...
+
+class Reference(_message.Message):
+    __slots__ = ("id",)
+    ID_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    def __init__(self, id: _Optional[str] = ...) -> None: ...
+
+class Session(_message.Message):
+    __slots__ = ("id",)
+    ID_FIELD_NUMBER: _ClassVar[int]
+    id: str
+    def __init__(self, id: _Optional[str] = ...) -> None: ...
+
+class Event(_message.Message):
+    __slots__ = ("reference", "event_type")
+    REFERENCE_FIELD_NUMBER: _ClassVar[int]
+    EVENT_TYPE_FIELD_NUMBER: _ClassVar[int]
+    reference: Reference
+    event_type: str
+    def __init__(self, reference: _Optional[_Union[Reference, _Mapping]] = ..., event_type: _Optional[str] = ...) -> None: ...

wool/_protobuf/mempool/mempool_pb2_grpc.py

@@ -0,0 +1,312 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+from mempool import mempool_pb2 as mempool_dot_mempool__pb2
+
+GRPC_GENERATED_VERSION = '1.73.1'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in mempool/mempool_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )
+
+
+class MemoryPoolStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.session = channel.unary_stream(
+                '/wool._protobuf.mempool.MemoryPool/session',
+                request_serializer=mempool_dot_mempool__pb2.SessionRequest.SerializeToString,
+                response_deserializer=mempool_dot_mempool__pb2.SessionResponse.FromString,
+                _registered_method=True)
+        self.acquire = channel.unary_unary(
+                '/wool._protobuf.mempool.MemoryPool/acquire',
+                request_serializer=mempool_dot_mempool__pb2.AcquireRequest.SerializeToString,
+                response_deserializer=mempool_dot_mempool__pb2.AcquireResponse.FromString,
+                _registered_method=True)
+        self.put = channel.unary_unary(
+                '/wool._protobuf.mempool.MemoryPool/put',
+                request_serializer=mempool_dot_mempool__pb2.PutRequest.SerializeToString,
+                response_deserializer=mempool_dot_mempool__pb2.PutResponse.FromString,
+                _registered_method=True)
+        self.post = channel.unary_unary(
+                '/wool._protobuf.mempool.MemoryPool/post',
+                request_serializer=mempool_dot_mempool__pb2.PostRequest.SerializeToString,
+                response_deserializer=mempool_dot_mempool__pb2.PostResponse.FromString,
+                _registered_method=True)
+        self.get = channel.unary_unary(
+                '/wool._protobuf.mempool.MemoryPool/get',
+                request_serializer=mempool_dot_mempool__pb2.GetRequest.SerializeToString,
+                response_deserializer=mempool_dot_mempool__pb2.GetResponse.FromString,
+                _registered_method=True)
+        self.release = channel.unary_unary(
+                '/wool._protobuf.mempool.MemoryPool/release',
+                request_serializer=mempool_dot_mempool__pb2.ReleaseRequest.SerializeToString,
+                response_deserializer=mempool_dot_mempool__pb2.ReleaseResponse.FromString,
+                _registered_method=True)
+
+
+class MemoryPoolServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def session(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def acquire(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def put(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def post(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def get(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def release(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_MemoryPoolServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'session': grpc.unary_stream_rpc_method_handler(
+                    servicer.session,
+                    request_deserializer=mempool_dot_mempool__pb2.SessionRequest.FromString,
+                    response_serializer=mempool_dot_mempool__pb2.SessionResponse.SerializeToString,
+            ),
+            'acquire': grpc.unary_unary_rpc_method_handler(
+                    servicer.acquire,
+                    request_deserializer=mempool_dot_mempool__pb2.AcquireRequest.FromString,
+                    response_serializer=mempool_dot_mempool__pb2.AcquireResponse.SerializeToString,
+            ),
+            'put': grpc.unary_unary_rpc_method_handler(
+                    servicer.put,
+                    request_deserializer=mempool_dot_mempool__pb2.PutRequest.FromString,
+                    response_serializer=mempool_dot_mempool__pb2.PutResponse.SerializeToString,
+            ),
+            'post': grpc.unary_unary_rpc_method_handler(
+                    servicer.post,
+                    request_deserializer=mempool_dot_mempool__pb2.PostRequest.FromString,
+                    response_serializer=mempool_dot_mempool__pb2.PostResponse.SerializeToString,
+            ),
+            'get': grpc.unary_unary_rpc_method_handler(
+                    servicer.get,
+                    request_deserializer=mempool_dot_mempool__pb2.GetRequest.FromString,
+                    response_serializer=mempool_dot_mempool__pb2.GetResponse.SerializeToString,
+            ),
+            'release': grpc.unary_unary_rpc_method_handler(
+                    servicer.release,
+                    request_deserializer=mempool_dot_mempool__pb2.ReleaseRequest.FromString,
+                    response_serializer=mempool_dot_mempool__pb2.ReleaseResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'wool._protobuf.mempool.MemoryPool', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+    server.add_registered_method_handlers('wool._protobuf.mempool.MemoryPool', rpc_method_handlers)
+
+
+ # This class is part of an EXPERIMENTAL API.
+class MemoryPool(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def session(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(
+            request,
+            target,
+            '/wool._protobuf.mempool.MemoryPool/session',
+            mempool_dot_mempool__pb2.SessionRequest.SerializeToString,
+            mempool_dot_mempool__pb2.SessionResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def acquire(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/wool._protobuf.mempool.MemoryPool/acquire',
+            mempool_dot_mempool__pb2.AcquireRequest.SerializeToString,
+            mempool_dot_mempool__pb2.AcquireResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def put(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/wool._protobuf.mempool.MemoryPool/put',
+            mempool_dot_mempool__pb2.PutRequest.SerializeToString,
+            mempool_dot_mempool__pb2.PutResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def post(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/wool._protobuf.mempool.MemoryPool/post',
+            mempool_dot_mempool__pb2.PostRequest.SerializeToString,
+            mempool_dot_mempool__pb2.PostResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def get(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/wool._protobuf.mempool.MemoryPool/get',
+            mempool_dot_mempool__pb2.GetRequest.SerializeToString,
+            mempool_dot_mempool__pb2.GetResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)
+
+    @staticmethod
+    def release(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/wool._protobuf.mempool.MemoryPool/release',
+            mempool_dot_mempool__pb2.ReleaseRequest.SerializeToString,
+            mempool_dot_mempool__pb2.ReleaseResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

wool/_protobuf/{_mempool/_metadata/_metadata_pb2.py → mempool/metadata/metadata_pb2.py}

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 # Generated by the protocol buffer compiler.  DO NOT EDIT!
 # NO CHECKED-IN PROTOBUF GENCODE
-# source: _mempool/_metadata/_metadata.proto
-# Protobuf Python Version: 6.30.0
+# source: mempool/metadata/metadata.proto
+# Protobuf Python Version: 6.31.0
 """Generated protocol buffer code."""
 from google.protobuf import descriptor as _descriptor
 from google.protobuf import descriptor_pool as _descriptor_pool
@@ -12,10 +12,10 @@ from google.protobuf.internal import builder as _builder
 _runtime_version.ValidateProtobufRuntimeVersion(
     _runtime_version.Domain.PUBLIC,
     6,
-    30,
+    31,
     0,
     '',
-    '_mempool/_metadata/_metadata.proto'
+    'mempool/metadata/metadata.proto'
 )
 # @@protoc_insertion_point(imports)
 
@@ -24,13 +24,13 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"_mempool/_metadata/_metadata.proto\x12\x17wool._mempool._metadata\"K\n\x10_MetadataMessage\x12\x0b\n\x03ref\x18\x01 \x01(\t\x12\x0f\n\x07mutable\x18\x02 \x01(\x08\x12\x0c\n\x04size\x18\x03 \x01(\x03\x12\x0b\n\x03md5\x18\x04 \x01(\x0c\x62\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1fmempool/metadata/metadata.proto\x12\x16wool._mempool.metadata\"K\n\x10_MetadataMessage\x12\x0b\n\x03ref\x18\x01 \x01(\t\x12\x0f\n\x07mutable\x18\x02 \x01(\x08\x12\x0c\n\x04size\x18\x03 \x01(\x03\x12\x0b\n\x03md5\x18\x04 \x01(\x0c\x62\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
-_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, '_mempool._metadata._metadata_pb2', _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'mempool.metadata.metadata_pb2', _globals)
 if not _descriptor._USE_C_DESCRIPTORS:
   DESCRIPTOR._loaded_options = None
-  _globals['__METADATAMESSAGE']._serialized_start=63
-  _globals['__METADATAMESSAGE']._serialized_end=138
+  _globals['__METADATAMESSAGE']._serialized_start=59
+  _globals['__METADATAMESSAGE']._serialized_end=134
 # @@protoc_insertion_point(module_scope)

wool/_protobuf/mempool/metadata/metadata_pb2_grpc.py

@@ -0,0 +1,24 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+import warnings
+
+
+GRPC_GENERATED_VERSION = '1.73.1'
+GRPC_VERSION = grpc.__version__
+_version_not_supported = False
+
+try:
+    from grpc._utilities import first_version_is_lower
+    _version_not_supported = first_version_is_lower(GRPC_VERSION, GRPC_GENERATED_VERSION)
+except ImportError:
+    _version_not_supported = True
+
+if _version_not_supported:
+    raise RuntimeError(
+        f'The grpc package installed is at version {GRPC_VERSION},'
+        + f' but the generated code in mempool/metadata/metadata_pb2_grpc.py depends on'
+        + f' grpcio>={GRPC_GENERATED_VERSION}.'
+        + f' Please upgrade your grpc module to grpcio>={GRPC_GENERATED_VERSION}'
+        + f' or downgrade your generated code using grpcio-tools<={GRPC_VERSION}.'
+    )

{wool-0.1rc7.dist-info → wool-0.1rc8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wool
-Version: 0.1rc7
+Version: 0.1rc8
 Summary: A Python framework for distributed multiprocessing.
 Author-email: Conrad Bzura <conrad@wool.io>
 Maintainer-email: maintainers@wool.io
@@ -206,19 +206,24 @@ License:                                  Apache License
            See the License for the specific language governing permissions and
            limitations under the License.
 Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
 Requires-Python: >=3.10
 Requires-Dist: annotated-types
 Requires-Dist: click
 Requires-Dist: debugpy
+Requires-Dist: grpcio
 Requires-Dist: protobuf
 Requires-Dist: shortuuid
 Requires-Dist: tblib
+Requires-Dist: typing-extensions
 Provides-Extra: dev
 Requires-Dist: pytest; extra == 'dev'
 Requires-Dist: pytest-asyncio; extra == 'dev'
+Requires-Dist: pytest-grpc-aio~=0.2.0; extra == 'dev'
 Requires-Dist: ruff; extra == 'dev'
 Provides-Extra: locking
-Requires-Dist: wool-locking==0.1rc7; extra == 'locking'
+Requires-Dist: wool-locking==0.1rc8; extra == 'locking'
 Description-Content-Type: text/markdown
 
 # Wool

wool-0.1rc8.dist-info/RECORD

@@ -0,0 +1,28 @@
+wool/__init__.py,sha256=I5_ROaxPM764bhVbirFqLN62TyFrwS8Z47IR7wN4e1k,1900
+wool/_cli.py,sha256=zLJqrT6nyLWNR83z40WsF279zJlE13UdDAhLuwoo50s,6565
+wool/_event.py,sha256=3fixaB2FN9Uetgkpwnw9MikohaRq2NwdnWEMFwPz3A4,2965
+wool/_future.py,sha256=Wn-wOuxfN9_R1-7wTzZGPUSl-IRYy5OM8ml68Ah6VuQ,4792
+wool/_logging.py,sha256=r4iLicEjuYo1P7GMs1OB0GkHo9NKAFocvoR3RAnvrRA,1262
+wool/_manager.py,sha256=QjYH73OPyTBeiOhJhbKJS9cPhuAIN2EOb14bUxZWI4o,4222
+wool/_pool.py,sha256=vdQAjA0J7X5aa5VldjqgMxTMqp2t_K9268obZDKeT3M,15598
+wool/_queue.py,sha256=qiTIezBe7sYvNszSRGDilumE49wlO3VWyMA74PgofeU,978
+wool/_session.py,sha256=Dv2hYLvfv_zCoiptt27o6GqZkgHZoNvak6pAIz7znaA,11842
+wool/_task.py,sha256=FRWyLb2geFGJmUtdn7RO_xjJSrUU_1TMDA9Mc9tBB8Y,10954
+wool/_typing.py,sha256=FmTNTqJtist1rlaVAVSyg12AW9RwqcbvqC4M1u88iSU,397
+wool/_utils.py,sha256=dHhgCp51oGjvKYCOYBjgWj6C03k2ZvclalrCZ4hH3sU,1527
+wool/_worker.py,sha256=bEjPOHciLjLc-R456sX6EoImq9CTEGaLiZOOZP1BJYI,6434
+wool/_mempool/__init__.py,sha256=GxNfNqxs51zLqzN9KN_--srguiZUFgJlGartzrpWbxA,146
+wool/_mempool/_mempool.py,sha256=FAFbLuRS0ZVynY83Lg4CDlJLlnr1tgoUpJhPKmMgNSQ,8962
+wool/_mempool/_metadata.py,sha256=wIOU8N4-1udojYO3SNj3lg-CyZ4O_oIaABgjNAiGAaI,910
+wool/_mempool/_service.py,sha256=25kqNhOjDAzB0NVzpQAwIedOzEl4w_FCyfvgTe2SQdo,8052
+wool/_protobuf/__init__.py,sha256=-tk1eG9ej62htUNZbCA137mI-Tx5D71YJ2NYk7nQKFo,85
+wool/_protobuf/mempool/mempool_pb2.py,sha256=fExanuvJuYtD7vebn3aWiK2Fvi3rVp2RRjQL0Xuc3sM,5030
+wool/_protobuf/mempool/mempool_pb2.pyi,sha256=p06Jy4fLv91PHZln9rBnlaTvN7DRf3siZpTLDO6diEU,4083
+wool/_protobuf/mempool/mempool_pb2_grpc.py,sha256=6aVmk3hPFBNa3y0PdJqG3yLIOTAenjKo4AGtWNsiPrk,12153
+wool/_protobuf/mempool/metadata/metadata_pb2.py,sha256=HF90_abKxFnP8Yj-Gtz4WZrudBvrkwxdMDOttdql3Jg,1478
+wool/_protobuf/mempool/metadata/metadata_pb2.pyi,sha256=Tp6EcQF0ScsT-lNG9844yfwTkDkQwtLkDn6u2gMbjfE,653
+wool/_protobuf/mempool/metadata/metadata_pb2_grpc.py,sha256=sAOhIZ2kSEJwYMyV8Ok1VtqeNFVflhh27Br8Rr33n0M,906
+wool-0.1rc8.dist-info/METADATA,sha256=J2I5rxYh2l2xjlBrfklvl-tyrlojlWpQSfAFE7WhadI,17030
+wool-0.1rc8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+wool-0.1rc8.dist-info/entry_points.txt,sha256=ybzb5TYXou-2cKC8HP5p0X8bw6Iyv7UMasqml6zlO1k,39
+wool-0.1rc8.dist-info/RECORD,,

wool-0.1rc7.dist-info/RECORD

@@ -1,23 +0,0 @@
-wool/__init__.py,sha256=I5_ROaxPM764bhVbirFqLN62TyFrwS8Z47IR7wN4e1k,1900
-wool/_cli.py,sha256=zLJqrT6nyLWNR83z40WsF279zJlE13UdDAhLuwoo50s,6565
-wool/_event.py,sha256=3fixaB2FN9Uetgkpwnw9MikohaRq2NwdnWEMFwPz3A4,2965
-wool/_future.py,sha256=Wn-wOuxfN9_R1-7wTzZGPUSl-IRYy5OM8ml68Ah6VuQ,4792
-wool/_logging.py,sha256=r4iLicEjuYo1P7GMs1OB0GkHo9NKAFocvoR3RAnvrRA,1262
-wool/_manager.py,sha256=QjYH73OPyTBeiOhJhbKJS9cPhuAIN2EOb14bUxZWI4o,4222
-wool/_pool.py,sha256=vdQAjA0J7X5aa5VldjqgMxTMqp2t_K9268obZDKeT3M,15598
-wool/_queue.py,sha256=qiTIezBe7sYvNszSRGDilumE49wlO3VWyMA74PgofeU,978
-wool/_session.py,sha256=Dv2hYLvfv_zCoiptt27o6GqZkgHZoNvak6pAIz7znaA,11842
-wool/_task.py,sha256=FRWyLb2geFGJmUtdn7RO_xjJSrUU_1TMDA9Mc9tBB8Y,10954
-wool/_typing.py,sha256=FmTNTqJtist1rlaVAVSyg12AW9RwqcbvqC4M1u88iSU,397
-wool/_utils.py,sha256=dHhgCp51oGjvKYCOYBjgWj6C03k2ZvclalrCZ4hH3sU,1527
-wool/_worker.py,sha256=bEjPOHciLjLc-R456sX6EoImq9CTEGaLiZOOZP1BJYI,6434
-wool/_mempool/__init__.py,sha256=gciN0LCV0G4cbJrL2rxmtu7e8lFJk8wCWqQQWpw5mOs,72
-wool/_mempool/_mempool.py,sha256=vG_mhrM2RtDHHfULDyK7Qti_qjbWuW-IjjbtFflkmXs,6618
-wool/_mempool/_metadata/__init__.py,sha256=5tojyNteoJto5tMhxpPj74Iiufa9I74Mbylcge5lTGQ,930
-wool/_protobuf/.gitkeep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wool/_protobuf/_mempool/_metadata/_metadata_pb2.py,sha256=PDMp6NwAod_r0vp0guO5aDrb8P_8ClT1KiNudqLb-rQ,1489
-wool/_protobuf/_mempool/_metadata/_metadata_pb2.pyi,sha256=Tp6EcQF0ScsT-lNG9844yfwTkDkQwtLkDn6u2gMbjfE,653
-wool-0.1rc7.dist-info/METADATA,sha256=3_7sv9XzIwJ9UQSJ8CqeZdVOnTANvTWw99xpO1JDHwc,16825
-wool-0.1rc7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-wool-0.1rc7.dist-info/entry_points.txt,sha256=ybzb5TYXou-2cKC8HP5p0X8bw6Iyv7UMasqml6zlO1k,39
-wool-0.1rc7.dist-info/RECORD,,