object-pool-async 0.1.2__py3-none-any.whl

object_pool/__init__.py

@@ -0,0 +1,10 @@
+"""
+对象池。
+"""
+
+from .exceptions import PoolError, ObjectNotFoundError
+from .status import Status
+from .pool import (
+	Pool,
+	Object, ObjectWrapper, ObjectPack
+)

object_pool/collections.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+
+class AttributeDict(dict):
+    """
+    A class that can read / set attribute value via both `.` and `[]`.
+    """
+
+    def __getattr__(self, key: str) -> Any:
+        """
+        Get an attribute value by `.`
+
+        Args:
+            key (str): The name of the attribute to get.
+
+        Returns:
+            Any: The value of the attribute.
+        """
+        return self[key]
+
+    def __setattr__(self, key: str, value: Any) -> None:
+        """
+        Set an attribute value by `.`
+
+        Args:
+            key (str): The name of the attribute to set.
+            value (Any): The value to set the attribute to.
+        """
+        self[key] = value
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({super().__repr__()})"

object_pool/exceptions.py

@@ -0,0 +1,14 @@
+"""
+异常
+"""
+
+class PoolError(Exception):
+    """
+    与对象池有关的错误。
+    """
+
+
+class ObjectNotFoundError(PoolError):
+    """
+    在池中没有找到对象。
+    """

object_pool/pool.py

@@ -0,0 +1,441 @@
+"""
+class: Pool
+"""
+
+from __future__ import annotations
+import asyncio
+from collections.abc import Callable, Coroutine
+from datetime import datetime, timedelta
+import functools
+from numbers import Number
+import random
+from typing import Any, Dict, Generic, List, Optional, Sequence, TypeVar
+
+from .collections import AttributeDict
+from .exceptions import ObjectNotFoundError
+from .status import Status
+from .utils import AsyncRLock, to_async
+
+
+# 池中对象
+Object = TypeVar("Object")
+
+
+# 包装器
+class ObjectWrapper(AttributeDict, Generic[Object]):
+    """
+    对象包装器，用于储存对象的数据。
+    """
+    def __init__(self, object: Object, status: Status = Status.PENDING, **kwargs):
+        super(AttributeDict, self).__init__(**kwargs)
+        self.object: Object = object
+        self.status: Status = status
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}<{self.object}: {self.status}>"
+
+
+# 打包器
+class ObjectPack(Generic[Object]):
+    """
+    对象包裹，当对象被借出时返回。
+    """
+    def __init__(self, object_wrapper: ObjectWrapper[Object]):
+        self._object_wrapper = object_wrapper
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}<{self.object}>"
+
+
+    @property
+    def object(self):
+        """
+        返回对象。
+        """
+        return self._object_wrapper.object
+
+
+    def close(self, **feedback) -> None:
+        """
+        归还借出的对象。
+        """
+        self._object_wrapper.status = Status.PENDING
+        self._object_wrapper.update(feedback)
+
+
+    def __enter__(self) -> Object:
+        return self.object
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.close()
+        self._object_wrapper = None
+
+    async def __aenter__(self) -> Object:
+        return self.__enter__()
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        return self.__exit__(exc_type, exc_val, exc_tb)
+
+
+def _split_chunk(objects: List[Any], chunk_size: Optional[int] = None) -> List[List[Any]]:
+    """
+    将对象列表按每组 chunk_size 个，分组。
+    """
+    if not chunk_size or chunk_size < 0:
+        return [objects]
+
+    return [
+        objects[i : i + chunk_size]
+        for i in range(0, len(objects), chunk_size)
+    ]
+
+
+def _choice(seq: Sequence[Any]) -> Optional[Any]:
+    """
+    默认的随机选择函数。
+    """
+    if not seq:
+        return None
+    return random.choice(seq)
+
+
+def async_locked(method: Callable) -> Callable:
+    """装饰器：为异步方法自动加上 RLock"""
+    @functools.wraps(method)
+    async def wrapper(self, *args, **kwargs):
+        async with self._lock_async:
+            return await method(self, *args, **kwargs)
+    return wrapper
+
+
+class Pool(Generic[Object]):
+    """
+    对象池。
+    """
+    # 对象的ID
+    ID = int
+
+    # 对象状态检测器
+    StatusDetector = Callable[
+        [ObjectWrapper[Object]],
+        Status
+    ]
+    StatusDetectorAsync = Callable[
+        [ObjectWrapper[Object]],
+        Coroutine[None, None, Status]
+    ]
+
+    # 对象选择器
+    ObjectSelector = Callable[
+        [List[ObjectWrapper[Object]], ...],
+        Optional[ObjectWrapper[Object]]
+    ]
+    ObjectSelectorAsync = Callable[
+        [List[ObjectWrapper[Object]], ...],
+        Coroutine[None, None, Optional[ObjectWrapper[Object]]]
+    ]
+
+    # 包装工厂函数
+    Wrapper = Callable[
+        [Object],
+        ObjectWrapper[Object]
+    ]
+    WrapperAsync = Callable[
+        [Object],
+        Coroutine[None, None, ObjectWrapper[Object]]
+    ]
+
+    # 打包工厂函数
+    Packer = Callable[
+        [ObjectWrapper[Object]],
+        ObjectPack[Object]
+    ]
+    PackerAsync = Callable[
+        [ObjectWrapper[Object]],
+        Coroutine[None, None, ObjectPack[Object]]
+    ]
+
+    def __init__(
+        self,
+        detect_status: StatusDetector | StatusDetectorAsync,
+        select_object: ObjectSelector | ObjectSelectorAsync = _choice,
+        *,
+        wrapper: Wrapper | WrapperAsync = ObjectWrapper,
+        packer: Packer | PackerAsync = ObjectPack,
+        wrapping_data: Optional[Dict[str, Any]] = None,
+        async_concurrency: Optional[int] = None
+    ):
+        """
+        初始化一个 Pool 对象。
+
+        Args:
+            detect_status (StatusDetector | StatusDetectorAsync): 检测对象状态的函数，内部会把它变成异步函数。
+            select_object (ObjectSelector | ObjectSelectorAsync): 从容器中选择一个对象。默认随机选择。
+            wrapper (Callable[[Object], ObjectWrapper]): 包装对象的可调用对象。
+            packer (Callable[[ObjectWrapper], ObjectPack]): 打包对象的可调用对象。
+            wrapping_data (Dict[str, Any]): 添加对象时，默认的数据。
+            async_concurrency (int): 最大异步并发数。若缺省，则全部并发。
+        """
+        self._object_wrappers       : Dict[self.ID, ObjectWrapper[Object]] = {}
+        self._detect_status_async   : self.StatusDetectorAsync             = to_async(detect_status)
+        self._select_object_async   : self.ObjectSelectorAsync             = to_async(select_object)
+        self._wrapper_async         : self.WrapperAsync                    = to_async(wrapper)
+        self._packer_async          : self.PackerAsync                     = to_async(packer)
+        self._default_wrapping_data : Dict[str, Any]                       = wrapping_data or {}
+        self._async_concurrency     : int                                  = async_concurrency
+        self._due_datetime          : Dict[self.ID, datetime]              = {}
+        self._lock_async = AsyncRLock()
+
+
+    def __len__(self) -> int:
+        return len(self._object_wrappers)
+
+
+    def __contains__(self, obj: Object) -> bool:
+        _id = id(obj)
+        return _id in self._object_wrappers
+
+
+    def _split_chunk(self, objects: List[Any]) -> List[List[Any]]:
+        """
+        将对象列表按每组 self._async_concurrency 个，分组。
+        """
+        return _split_chunk(objects, self._async_concurrency)
+
+
+    async def _get_wrapper_async(self, obj: Object) -> ObjectWrapper[Object]:
+        """
+        返回 `obj` 的包装器对象。
+
+        Raises:
+            ObjectNotFoundError: 如果 obj 不在池中。
+        """
+        _id = id(obj)
+        if _id not in self._object_wrappers:
+            raise ObjectNotFoundError(str(obj))
+        return self._object_wrappers[_id]
+
+
+    @async_locked
+    async def add_async(self, obj: Object, **kwargs) -> ObjectWrapper[Object]:
+        """
+        向池中添加/覆盖一个对象。
+        """
+        kwargs = self._default_wrapping_data | kwargs
+        _id = id(obj)
+        self._object_wrappers[_id] = await self._wrapper_async(obj, **kwargs)
+        return await self._get_wrapper_async(obj)
+
+
+    async def _delete_async(self, obj: Object) -> None:
+        """
+        从池中丢弃一个对象。
+
+        Raises:
+            ObjectNotFoundError: 如果 obj 不在池中。
+        """
+        _id = id(obj)
+        if _id not in self._object_wrappers:
+            raise ObjectNotFoundError(str(obj))
+        self._object_wrappers.pop(_id)
+        self._due_datetime.pop(_id, None)
+
+
+    @async_locked
+    async def discard_async(self, obj: Object) -> None:
+        """
+        从池中丢弃一个对象。
+
+        如果池中没有该对象，不会报错。
+        """
+        if obj in self:
+            await self._delete_async(obj)
+
+
+    @async_locked
+    async def remove_async(self, obj: Object) -> None:
+        """
+        从池中丢弃一个对象。
+
+        Raises:
+            ObjectNotFoundError: 如果 obj 不在池中。
+        """
+        await self._delete_async(obj)
+
+
+    @async_locked
+    async def clear_async(self) -> None:
+        """
+        清空对象池。
+        """
+        self._object_wrappers.clear()
+        self._due_datetime.clear()
+
+
+    async def _get_status_by_id_async(self, _id: ID) -> Status:
+        """
+        通过 id 查询对象状态。
+        """
+        if _id not in self._object_wrappers:
+            raise ObjectNotFoundError(f"Can't find object with id {_id!r}")
+        object_wrapper = self._object_wrappers[_id]
+        return object_wrapper.status
+
+
+    @async_locked
+    async def get_status_async(self, obj: Object) -> Status:
+        """
+        查询对象的状态。
+        """
+        _id = id(obj)
+        return await self._get_status_by_id_async(_id)
+
+
+    async def _detect_async(self) -> None:
+        """
+        对池中对象进行检测，更新 status。
+        """
+        # 排除被借出的对象
+        object_wrappers_to_be_detected = [
+            object_wrapper
+            for object_wrapper in self._object_wrappers.values()
+            if object_wrapper.status != Status.BORROWED
+        ]
+
+        # 异步并发检测对象
+        object_wrapper_chunks = self._split_chunk(object_wrappers_to_be_detected)
+        for object_wrappers in object_wrapper_chunks:
+            tasks = map(self._detect_status_async, object_wrappers)
+            statuses = await asyncio.gather(*tasks, return_exceptions=True)
+            for (object_wrapper, status) in zip(object_wrappers, statuses):
+                if isinstance(status, Exception):
+                    # 记录日志，并将状态设为 UNKNOWN
+                    object_wrapper.status = Status.UNKNOWN
+                else:
+                    object_wrapper.status = status
+
+
+    async def _clean_async(self) -> None:
+        """
+        删除池中不可用的对象。
+        """
+        # 挑出无效对象
+        objects_to_be_removed = [
+            object_wrapper.object
+            for object_wrapper in await self._get_object_wrappers_by_status_async(Status.INVALID)
+        ]
+
+        # 异步并发删除对象
+        object_chunks = self._split_chunk(objects_to_be_removed)
+        for objects in object_chunks:
+            tasks = map(self._delete_async, objects)
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+
+    async def _withdraw_async(self) -> None:
+        """
+        强制收回被借出的过期对象。
+        """
+        # 找出过期的
+        now = datetime.now()
+        withdrawn_ids = []
+        for (_id, due) in self._due_datetime.items():
+            if due < now:
+                withdrawn_ids.append(_id)
+
+        # 回收
+        for _id in withdrawn_ids:
+            self._due_datetime.pop(_id)
+            object_wrapper = self._object_wrappers.get(_id, None)
+            if object_wrapper and object_wrapper.status == Status.BORROWED:
+                object_wrapper.status = Status.PENDING
+
+
+    @async_locked
+    async def update_status_async(self) -> None:
+        """
+        更新对象的状态记录。
+        """
+        await self._withdraw_async()
+        await self._detect_async()
+        await self._clean_async()
+
+
+    async def _get_object_wrappers_by_status_async(self, status: Status) -> List[ObjectWrapper[Object]]:
+        """
+        根据状态查找对象。
+        """
+        return [
+            object_wrapper
+            for object_wrapper in self._object_wrappers.values()
+            if object_wrapper.status == status
+        ]
+
+
+    @async_locked
+    async def borrow_async(
+        self,
+        timeout: Optional[Number | timedelta] = None,
+        **kwargs
+    ) -> Optional[ObjectPack[Object]]:
+        """
+        从池中借出一个对象。
+
+        Args:
+            timeout (Optional[Number | timedelta]): 借出对象的借出时间间隔，超过该时间后，对象将强制归还。
+            - Number: 单位：秒。
+            - timedelta: 经过该时间间隔被归还。
+            - None: 不限超时。
+        """
+        # 获取对象
+        await self.update_status_async()
+        available_object_wrappers = await self._get_object_wrappers_by_status_async(Status.AVAILABLE)
+        object_wrapper = await self._select_object_async(available_object_wrappers, **kwargs)
+        if object_wrapper is None:
+            # 没有可用对象
+            return None
+
+        # 计算到期时间
+        if timeout is None:
+            due_time = datetime.max
+        else:
+            if isinstance(timeout, Number):
+                timeout = timedelta(seconds = timeout)
+            due_time = datetime.now() + timeout
+
+        # 记录借出
+        object_wrapper.status = Status.BORROWED
+        self._due_datetime[id(object_wrapper.object)] = due_time
+
+        return await self._packer_async(object_wrapper)
+
+
+    # ==== 异步方法转同步 ====
+
+    def add(self, obj: Object, **kwargs) -> ObjectWrapper[Object]:
+        """ Synchronous version of `.add_async`. """
+        return asyncio.run(self.add_async(obj, **kwargs))
+
+    def discard(self, obj: Object) -> None:
+        """ Synchronous version of `.discard_async`. """
+        asyncio.run(self.discard_async(obj))
+
+    def remove(self, obj: Object) -> None:
+        """ Synchronous version of `.remove_async`. """
+        asyncio.run(self.remove_async(obj))
+
+    def clear(self) -> None:
+        """ Synchronous version of `.clear_async`. """
+        asyncio.run(self.clear_async())
+
+    def get_status(self, obj: Object) -> Status:
+        """ Synchronous version of `.get_status_async`. """
+        return asyncio.run(self.get_status_async(obj))
+
+    def update_status(self) -> None:
+        """ Synchronous version of `.update_status_async`. """
+        asyncio.run(self.update_status_async())
+
+    def borrow(self, timeout: Optional[Number | timedelta] = None, **kwargs) -> Optional[ObjectPack[Object]]:
+        """ Synchronous version of `.borrow_async`. """
+        return asyncio.run(self.borrow_async(timeout, **kwargs))

object_pool/status.py

@@ -0,0 +1,41 @@
+"""
+enum: Status
+"""
+
+try:
+    from enum import StrEnum
+except ImportError:
+    # 兼容低版本
+    from enum import Enum
+    class StrEnum(str, Enum):
+        pass
+
+
+class Status(StrEnum):
+    """
+    池中对象的状态。
+
+    Note:
+        PENDING: 一般出现在：对象刚入池时、对象刚被归还时、对象借出超时后。
+        DORMANT: 对象目前不可用，但是过一段时间可能可用。
+        INVALID: 对象永久用不了。
+        UNKNOWN: 一般不会出现。
+    """
+
+    # 被借出的
+    BORROWED = "borrowed"
+
+    # 待检测的
+    PENDING = "pending"
+
+    # 可用的
+    AVAILABLE = "available"
+
+    # 休眠的
+    DORMANT = "dormant"
+
+    # 不可用的
+    INVALID = "invalid"
+
+    # 未知的
+    UNKNOWN = "unknown"

object_pool/utils.py

@@ -0,0 +1,97 @@
+"""
+提供了一些与同步、异步函数转换有关的工厂函数。
+
+Pickle 友好。
+"""
+
+import asyncio
+from functools import partial
+from inspect import isawaitable
+from typing import Any, Awaitable, AsyncContextManager, Callable, ContextManager, Optional
+
+# 同步函数类型
+SyncFunction = Callable[..., Any]
+
+# 异步函数类型
+AsyncFunction = Callable[..., Awaitable[Any]]
+
+
+async def _run_func_async(func: Callable, *args, **kwargs):
+    """
+    异步运行一个同步或异步函数。
+    """
+    result = func(*args, **kwargs)
+    if isawaitable(result):
+        return await result
+    return result
+
+def to_async(func: Callable) -> AsyncFunction:
+    """
+    把同步或异步函数转换为异步函数。
+    """
+    return partial(_run_func_async, func)
+
+
+def _run_func_sync(func: Callable, *args, **kwargs):
+    """
+    同步运行一个同步或异步函数。
+    """
+    result = func(*args, **kwargs)
+    if isawaitable(result):
+        return asyncio.run(result)
+    return result
+
+def to_sync(func: Callable) -> SyncFunction:
+    """
+    把同步或异步函数转换为同步函数。
+    """
+    return partial(_run_func_sync, func)
+
+
+def run_within_context(context: ContextManager, func: SyncFunction, *args, **kwargs):
+    """
+    将函数 func 放在上下文里执行。
+    """
+    with context:
+        return func(*args, **kwargs)
+
+
+async def run_within_context_async(context: AsyncContextManager, func: AsyncFunction, *args, **kwargs):
+    """
+    Asynchronous version of `run_within_context`.
+    """
+    async with context:
+        return await func(*args, **kwargs)
+
+
+class AsyncRLock:
+    """简单的异步可重入锁，兼容 Python 3.10"""
+    def __init__(self):
+        self._lock = asyncio.Lock()
+        self._owner: Optional[int] = None   # 持有锁的 task id
+        self._count = 0
+
+    async def acquire(self):
+        current_task = id(asyncio.current_task())
+        if self._owner == current_task:
+            self._count += 1
+            return True
+        await self._lock.acquire()
+        self._owner = current_task
+        self._count = 1
+        return True
+
+    def release(self):
+        if self._owner != id(asyncio.current_task()):
+            raise RuntimeError("Cannot release a lock that is not held by the current task")
+        self._count -= 1
+        if self._count == 0:
+            self._owner = None
+            self._lock.release()
+
+    async def __aenter__(self):
+        await self.acquire()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        self.release()

object_pool_async-0.1.2.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: object-pool-async
+Version: 0.1.2
+Summary: A generic, async-first object pool for Python
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Jerry-Wu-GitHub/object-pool
+Keywords: object-pool,async,connection-pool
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Object Pool
+
+一个功能丰富、支持异步的通用对象池，提供细粒度的对象生命周期管理、状态检测、超时回收和灵活的定制能力。
+
+## 特性
+
+- ✅ **异步优先**：原生支持 `asyncio`，在高并发 I/O 场景下性能优异
+- 🔄 **完整生命周期**：管理对象的 `PENDING`、`AVAILABLE`、`BORROWED`、`INVALID`、`DORMANT`、`UNKNOWN` 状态
+- ⏱️ **超时回收**：支持对象级别的借出超时自动回收
+- 🧩 **高度可定制**：可自定义状态检测器、对象选择器、包装器（Wrapper）和打包器（Packer）
+- 🚦 **并发控制**：内置并发度限制，批量操作自动分块
+- 🔁 **双 API**：同时提供异步（`*_async`）和同步接口
+- 🧵 **协程安全**：基于 `AsyncRLock` 实现，在单事件循环多协程下安全
+
+## 安装
+
+```bash
+pip install object-pool
+```
+
+或从源码安装：
+
+```bash
+git clone https://github.com/Jerry-Wu-GitHub/object-pool.git
+cd object-pool
+pip install -e .
+```
+
+## 快速开始
+
+### 同步使用
+
+```python
+from object_pool import Pool, Status
+from datetime import timedelta
+
+# 定义一个简单的状态检测函数
+def check_status(wrapper):
+    # 假设对象有一个 is_alive 属性
+    if wrapper.object.is_alive():
+        return Status.AVAILABLE
+    return Status.INVALID
+
+# 创建对象池
+pool = Pool(detect_status=check_status)
+
+# 添加对象
+obj = MyResource()
+pool.add(obj)
+
+# 借出对象
+with pool.borrow() as resource:
+    resource.do_something()
+# 离开上下文时自动归还
+
+# 手动归还
+pack = pool.borrow()
+pack.close()   # 归还
+```
+
+### 异步使用
+
+```python
+import asyncio
+from object_pool import Pool, Status
+
+async def check_status_async(wrapper):
+    # 异步检测对象健康状态
+    if await wrapper.object.ping():
+        return Status.AVAILABLE
+    return Status.INVALID
+
+async def main():
+    pool = Pool(detect_status=check_status_async)
+    obj = AsyncResource()
+    await pool.add_async(obj)
+
+    pack = await pool.borrow_async(timeout=3.0)
+    try:
+        await pack.object.work()
+    finally:
+        pack.close()   # 归还
+
+    # 或使用异步上下文管理器
+    async with await pool.borrow_async() as resource:
+        await resource.work()
+
+asyncio.run(main())
+```
+
+## 高级用法
+
+### 自定义对象选择器
+
+默认使用随机选择。你可以实现自己的选择逻辑，例如轮询（Round-Robin）或[基于权重的选择](examples/weighted_selector.py)：
+
+```python
+def select_object(object_wrapers: List[ObjectWrapper[DummyObject]]) -> Optional[ObjectWrapper[DummyObject]]:
+    """
+    按照权重选择一个对象。
+    """
+    if not object_wrapers:
+        return None
+    weights = [
+        object_wraper.weight
+        for object_wraper in object_wrapers
+    ]
+    return choices(object_wrapers, weights)[0]
+
+# 注意：选择器可以是同步或异步函数，池内部会自动转换
+```
+
+### 定制包装器和打包器
+
+```python
+class MyWrapper(ObjectWrapper):
+    def __init__(self, obj, **kwargs):
+        super().__init__(obj, **kwargs)
+        self.extra_info = kwargs.get('extra', {})
+
+def my_packer(wrapper):
+    # 返回自定义的打包对象，可以增加额外行为
+    return MyPack(wrapper)
+
+pool = Pool(detect_status=..., wrapper=MyWrapper, packer=my_packer)
+```
+
+### 使用默认数据
+
+通过 `wrapping_data` 为每个对象附加默认属性：
+
+```python
+pool = Pool(..., wrapping_data={"created_at": datetime.now(), "source": "db"})
+pool.add(obj)   # ObjectWrapper 会自动包含 created_at 和 source
+```
+
+### 并发控制
+
+`async_concurrency` 限制了同时执行状态检测或清理操作的并发任务数，避免瞬间压力过大：
+
+```python
+pool = Pool(..., async_concurrency=10)   # 最多同时检测10个对象
+```
+
+## 并发与线程安全
+
+- **协程安全**：`Pool` 使用 `AsyncRLock` 保护关键操作，在**单个事件循环**内多协程并发访问是安全的。
+- **线程安全**：**不保证**多线程安全。如果在多线程环境中使用同步方法（`add`、`borrow` 等），需要外部加锁（如 `threading.Lock`）。
+- **建议**：在 `asyncio` 应用中始终使用异步 API；在传统多线程应用中请自行添加线程锁。
+
+## 依赖
+
+- Python >= 3.10
+
+## 许可证
+
+MIT

object_pool_async-0.1.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+object_pool/__init__.py,sha256=iz_GmUjbrKgb1b1HmDQK1Y193nEw8PZrRAjuKB2tT_4,178
+object_pool/collections.py,sha256=2L7nRssfVJ3HgcdtA5xdLISpMt-yC2WSrMytHneHTKc,814
+object_pool/exceptions.py,sha256=pli0AzVykhjxMi5H1kaxXRzmAXMz2sR39EJ_wBn8TT0,200
+object_pool/pool.py,sha256=dzSHHmoYF6lNR5CJUTm3qqtkPWHfpz7VD_X-HwPlvhg,14189
+object_pool/status.py,sha256=TPxBp6MR_RogQrLynCA44SgQWH8UaYGILHcdCwGwt6w,814
+object_pool/utils.py,sha256=aL8lDKE4ynVIZ6wVV1B2vE28UN0aK2rgZiBux381Fms,2684
+object_pool_async-0.1.2.dist-info/licenses/LICENSE,sha256=errzu9jbnGCiEZ50jZxag9tkLf5opFvlVTDC8yfYlQA,1081
+object_pool_async-0.1.2.dist-info/METADATA,sha256=JocB-D7BauA4hNETnR3JfEfXAgIBuJco3NJzLgInHww,5284
+object_pool_async-0.1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+object_pool_async-0.1.2.dist-info/top_level.txt,sha256=FEd7zgzY4-enb4703gEiD1UND-C343OBScF3aSdEcz8,12
+object_pool_async-0.1.2.dist-info/RECORD,,

object_pool_async-0.1.2.dist-info/WHEEL

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

object_pool_async-0.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jerry
+
+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.

object_pool_async-0.1.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+object_pool