xoscar 0.2.1__cp38-cp38-macosx_10_9_x86_64.whl → 0.3.2__cp38-cp38-macosx_10_9_x86_64.whl

xoscar/__init__.py

@@ -50,7 +50,6 @@ from ._utils import create_actor_ref
 
 # make sure methods are registered
 from .backends import indigen, test
-from .entrypoints import init_extension_entrypoints
 from . import _version
 
 del indigen, test
@@ -59,6 +58,3 @@ _T = TypeVar("_T")
 ActorRefType = Union[ActorRef, _T]
 
 __version__ = _version.get_versions()["version"]
-
-init_extension_entrypoints()
-del init_extension_entrypoints

xoscar/backends/communication/dummy.py

@@ -97,9 +97,9 @@ class DummyServer(Server):
         else tuple()
     )
 
-    _address_to_instances: weakref.WeakValueDictionary[
-        str, "DummyServer"
-    ] = weakref.WeakValueDictionary()
+    _address_to_instances: weakref.WeakValueDictionary[str, "DummyServer"] = (
+        weakref.WeakValueDictionary()
+    )
     _channels: list[ChannelType]
     _tasks: list[asyncio.Task]
     scheme: str | None = "dummy"

xoscar/backends/context.py

@@ -26,7 +26,7 @@ from ..context import BaseActorContext
 from ..core import ActorRef, BufferRef, FileObjectRef, create_local_actor_ref
 from ..debug import debug_async_timeout, detect_cycle_send
 from ..errors import CannotCancelTask
-from ..utils import dataslots
+from ..utils import dataslots, fix_all_zero_ip
 from .allocate_strategy import AddressSpecified, AllocateStrategy
 from .communication import Client, DummyClient, UCXClient
 from .core import ActorCaller
@@ -187,6 +187,7 @@ class IndigenActorContext(BaseActorContext):
 
     async def actor_ref(self, *args, **kwargs):
         actor_ref = create_actor_ref(*args, **kwargs)
+        connect_addr = actor_ref.address
         local_actor_ref = create_local_actor_ref(actor_ref.address, actor_ref.uid)
         if local_actor_ref is not None:
             return local_actor_ref
@@ -195,7 +196,10 @@ class IndigenActorContext(BaseActorContext):
         )
         future = await self._call(actor_ref.address, message, wait=False)
         result = await self._wait(future, actor_ref.address, message)
-        return self._process_result_message(result)
+        res = self._process_result_message(result)
+        if res.address != connect_addr:
+            res.address = fix_all_zero_ip(res.address, connect_addr)
+        return res
 
     async def send(
         self,

xoscar/backends/core.py

@@ -85,7 +85,8 @@ class ActorCaller:
                         f"Remote server {client.dest_address} closed"
                     ) from None
                 future = self._client_to_message_futures[client].pop(message.message_id)
-                future.set_result(message)
+                if not future.done():
+                    future.set_result(message)
             except DeserializeMessageFailed as e:
                 message_id = e.message_id
                 future = self._client_to_message_futures[client].pop(message_id)

xoscar/backends/indigen/pool.py

@@ -187,14 +187,19 @@ class MainActorPool(MainActorPoolBase):
         def start_pool_in_process():
             ctx = multiprocessing.get_context(method=start_method)
             status_queue = ctx.Queue()
+            main_pool_pid = os.getpid()
 
             with _suspend_init_main():
                 process = ctx.Process(
                     target=cls._start_sub_pool,
-                    args=(actor_pool_config, process_index, status_queue),
+                    args=(
+                        actor_pool_config,
+                        process_index,
+                        status_queue,
+                        main_pool_pid,
+                    ),
                     name=f"IndigenActorPool{process_index}",
                 )
-                process.daemon = True
                 process.start()
 
             # wait for sub actor pool to finish starting
@@ -209,15 +214,22 @@ class MainActorPool(MainActorPoolBase):
 
     @classmethod
     async def wait_sub_pools_ready(cls, create_pool_tasks: List[asyncio.Task]):
-        processes = []
+        processes: list[multiprocessing.Process] = []
         ext_addresses = []
+        error = None
         for task in create_pool_tasks:
             process, status = await task
+            processes.append(process)
             if status.status == 1:
                 # start sub pool failed
-                raise status.error.with_traceback(status.traceback)
-            processes.append(process)
-            ext_addresses.append(status.external_addresses)
+                error = status.error.with_traceback(status.traceback)
+            else:
+                ext_addresses.append(status.external_addresses)
+        if error:
+            for p in processes:
+                # error happens, kill all subprocesses
+                p.kill()
+            raise error
         return processes, ext_addresses
 
     @classmethod
@@ -226,6 +238,7 @@ class MainActorPool(MainActorPoolBase):
         actor_config: ActorPoolConfig,
         process_index: int,
         status_queue: multiprocessing.Queue,
+        main_pool_pid: int,
     ):
         ensure_coverage()
 
@@ -259,7 +272,9 @@ class MainActorPool(MainActorPoolBase):
         else:
             asyncio.set_event_loop(asyncio.new_event_loop())
 
-        coro = cls._create_sub_pool(actor_config, process_index, status_queue)
+        coro = cls._create_sub_pool(
+            actor_config, process_index, status_queue, main_pool_pid
+        )
         asyncio.run(coro)
 
     @classmethod
@@ -268,6 +283,7 @@ class MainActorPool(MainActorPoolBase):
         actor_config: ActorPoolConfig,
         process_index: int,
         status_queue: multiprocessing.Queue,
+        main_pool_pid: int,
     ):
         process_status = None
         try:
@@ -276,7 +292,11 @@ class MainActorPool(MainActorPoolBase):
             if env:
                 os.environ.update(env)
             pool = await SubActorPool.create(
-                {"actor_pool_config": actor_config, "process_index": process_index}
+                {
+                    "actor_pool_config": actor_config,
+                    "process_index": process_index,
+                    "main_pool_pid": main_pool_pid,
+                }
             )
             external_addresses = cur_pool_config["external_address"]
             process_status = SubpoolStatus(
@@ -342,14 +362,14 @@ class MainActorPool(MainActorPoolBase):
         def start_pool_in_process():
             ctx = multiprocessing.get_context(method=start_method)
             status_queue = ctx.Queue()
+            main_pool_pid = os.getpid()
 
             with _suspend_init_main():
                 process = ctx.Process(
                     target=self._start_sub_pool,
-                    args=(self._config, process_index, status_queue),
+                    args=(self._config, process_index, status_queue, main_pool_pid),
                     name=f"IndigenActorPool{process_index}",
                 )
-                process.daemon = True
                 process.start()
 
             # wait for sub actor pool to finish starting

xoscar/backends/pool.py

@@ -27,11 +27,12 @@ import traceback
 from abc import ABC, ABCMeta, abstractmethod
 from typing import Any, Callable, Coroutine, Optional, Type, TypeVar
 
+import psutil
+
 from .._utils import TypeDispatcher, create_actor_ref, to_binary
 from ..api import Actor
 from ..core import ActorRef, BufferRef, FileObjectRef, register_local_pool
 from ..debug import debug_async_timeout, record_message_trace
-from ..entrypoints import init_extension_entrypoints
 from ..errors import (
     ActorAlreadyExist,
     ActorNotExist,
@@ -186,8 +187,6 @@ class AbstractActorPool(ABC):
         self._asyncio_task_timeout_detector_task = (
             register_asyncio_task_timeout_detector()
         )
-        # load third party extensions.
-        init_extension_entrypoints()
         # init metrics
         metric_configs = self._config.get_metric_configs()
         metric_backend = metric_configs.get("backend")
@@ -821,7 +820,8 @@ SubProcessHandle = multiprocessing.Process
 
 
 class SubActorPoolBase(ActorPoolBase):
-    __slots__ = ("_main_address",)
+    __slots__ = ("_main_address", "_watch_main_pool_task")
+    _watch_main_pool_task: Optional[asyncio.Task]
 
     def __init__(
         self,
@@ -834,6 +834,7 @@ class SubActorPoolBase(ActorPoolBase):
         config: ActorPoolConfig,
         servers: list[Server],
         main_address: str,
+        main_pool_pid: Optional[int],
     ):
         super().__init__(
             process_index,
@@ -846,6 +847,26 @@ class SubActorPoolBase(ActorPoolBase):
             servers,
         )
         self._main_address = main_address
+        if main_pool_pid:
+            self._watch_main_pool_task = asyncio.create_task(
+                self._watch_main_pool(main_pool_pid)
+            )
+        else:
+            self._watch_main_pool_task = None
+
+    async def _watch_main_pool(self, main_pool_pid: int):
+        main_process = psutil.Process(main_pool_pid)
+        while not self.stopped:
+            try:
+                await asyncio.to_thread(main_process.status)
+                await asyncio.sleep(0.1)
+                continue
+            except (psutil.NoSuchProcess, ProcessLookupError, asyncio.CancelledError):
+                # main pool died
+                break
+
+        if not self.stopped:
+            await self.stop()
 
     async def notify_main_pool_to_destroy(
         self, message: DestroyActorMessage
@@ -900,14 +921,22 @@ class SubActorPoolBase(ActorPoolBase):
 
     @staticmethod
     def _parse_config(config: dict, kw: dict) -> dict:
+        main_pool_pid = config.pop("main_pool_pid", None)
         kw = AbstractActorPool._parse_config(config, kw)
         pool_config: ActorPoolConfig = kw["config"]
         main_process_index = pool_config.get_process_indexes()[0]
         kw["main_address"] = pool_config.get_pool_config(main_process_index)[
             "external_address"
         ][0]
+        kw["main_pool_pid"] = main_pool_pid
         return kw
 
+    async def stop(self):
+        await super().stop()
+        if self._watch_main_pool_task:
+            self._watch_main_pool_task.cancel()
+            await self._watch_main_pool_task
+
 
 class MainActorPoolBase(ActorPoolBase):
     __slots__ = (

xoscar/backends/test/pool.py

@@ -55,7 +55,7 @@ class TestMainActorPool(MainActorPool):
         status_queue: multiprocessing.Queue = multiprocessing.Queue()
         return (
             asyncio.create_task(
-                cls._create_sub_pool(actor_pool_config, process_index, status_queue)
+                cls._create_sub_pool(actor_pool_config, process_index, status_queue, 0)
             ),
             status_queue,
         )
@@ -77,9 +77,14 @@ class TestMainActorPool(MainActorPool):
         actor_config: ActorPoolConfig,
         process_index: int,
         status_queue: multiprocessing.Queue,
+        main_pool_pid: int,
     ):
         pool: TestSubActorPool = await TestSubActorPool.create(
-            {"actor_pool_config": actor_config, "process_index": process_index}
+            {
+                "actor_pool_config": actor_config,
+                "process_index": process_index,
+                "main_pool_pid": main_pool_pid,
+            }
         )
         await pool.start()
         status_queue.put(

xoscar/collective/common.py

@@ -55,30 +55,30 @@ class AllReduceAlgorithm(IntEnum):
 
 
 TypeMappingGloo: Dict[Type[np.dtype], "xp.GlooDataType_t"] = {
-    np.int8: xp.GlooDataType_t.glooInt8,
-    np.uint8: xp.GlooDataType_t.glooUint8,
-    np.int32: xp.GlooDataType_t.glooInt32,
-    np.uint32: xp.GlooDataType_t.glooUint32,
-    np.int64: xp.GlooDataType_t.glooInt64,
-    np.uint64: xp.GlooDataType_t.glooUint64,
-    np.float16: xp.GlooDataType_t.glooFloat16,
-    np.float32: xp.GlooDataType_t.glooFloat32,
-    np.float64: xp.GlooDataType_t.glooFloat64,
+    np.int8: xp.GlooDataType_t.glooInt8,  # type: ignore
+    np.uint8: xp.GlooDataType_t.glooUint8,  # type: ignore
+    np.int32: xp.GlooDataType_t.glooInt32,  # type: ignore
+    np.uint32: xp.GlooDataType_t.glooUint32,  # type: ignore
+    np.int64: xp.GlooDataType_t.glooInt64,  # type: ignore
+    np.uint64: xp.GlooDataType_t.glooUint64,  # type: ignore
+    np.float16: xp.GlooDataType_t.glooFloat16,  # type: ignore
+    np.float32: xp.GlooDataType_t.glooFloat32,  # type: ignore
+    np.float64: xp.GlooDataType_t.glooFloat64,  # type: ignore
 }
 cupy = lazy_import("cupy")
 if cupy is not None:
     from cupy.cuda import nccl
 
     TypeMappingNCCL: Dict[Type[np.dtype], int] = {
-        np.int8: nccl.NCCL_INT8,
-        np.uint8: nccl.NCCL_UINT8,
-        np.int32: nccl.NCCL_INT32,
-        np.uint32: nccl.NCCL_UINT32,
-        np.int64: nccl.NCCL_INT64,
-        np.uint64: nccl.NCCL_UINT64,
-        np.float16: nccl.NCCL_FLOAT16,
-        np.float32: nccl.NCCL_FLOAT32,
-        np.float64: nccl.NCCL_FLOAT64,
+        np.int8: nccl.NCCL_INT8,  # type: ignore
+        np.uint8: nccl.NCCL_UINT8,  # type: ignore
+        np.int32: nccl.NCCL_INT32,  # type: ignore
+        np.uint32: nccl.NCCL_UINT32,  # type: ignore
+        np.int64: nccl.NCCL_INT64,  # type: ignore
+        np.uint64: nccl.NCCL_UINT64,  # type: ignore
+        np.float16: nccl.NCCL_FLOAT16,  # type: ignore
+        np.float32: nccl.NCCL_FLOAT32,  # type: ignore
+        np.float64: nccl.NCCL_FLOAT64,  # type: ignore
     }
 
     ReduceOpMappingNCCL: Dict[CollectiveReduceOp, int] = {

xoscar/utils.py

@@ -462,3 +462,41 @@ def is_windows():
 
 def is_linux():
     return sys.platform.startswith("linux")
+
+
+def is_v4_zero_ip(ip_port_addr: str) -> bool:
+    return ip_port_addr.startswith("0.0.0.0:")
+
+
+def is_v6_zero_ip(ip_port_addr: str) -> bool:
+    # tcp6 addr ":::123", ":: means all zero"
+    arr = ip_port_addr.split(":")
+    if len(arr) <= 2:  # Not tcp6 or udp6
+        return False
+    for part in arr[0:-1]:
+        if part != "":
+            if int(part, 16) != 0:
+                return False
+    return True
+
+
+def fix_all_zero_ip(remote_addr: str, connect_addr: str) -> str:
+    """
+    Use connect_addr to fix ActorRef.address return by remote server.
+    When remote server listen on "0.0.0.0:port" or ":::port", it will return ActorRef.address set to listening addr,
+    it cannot be use by client for the following interaction unless we fix it.
+    (client will treat 0.0.0.0 as 127.0.0.1)
+
+    NOTE: Server might return a different addr from a pool for load-balance purpose.
+    """
+    if remote_addr == connect_addr:
+        return remote_addr
+    if not is_v4_zero_ip(remote_addr) and not is_v6_zero_ip(remote_addr):
+        # Remote server returns on non-zero ip
+        return remote_addr
+    if is_v4_zero_ip(connect_addr) or is_v6_zero_ip(connect_addr):
+        # Client connect to local server
+        return remote_addr
+    remote_port = remote_addr.split(":")[-1]
+    connect_ip = ":".join(connect_addr.split(":")[0:-1])  # Remote the port
+    return f"{connect_ip}:{remote_port}"

{xoscar-0.2.1.dist-info → xoscar-0.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xoscar
-Version: 0.2.1
+Version: 0.3.2
 Summary: Python actor framework for heterogeneous computing.
 Home-page: http://github.com/xorbitsai/xoscar
 Author: Qin Xuye
@@ -18,11 +18,12 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
-Requires-Dist: numpy >=1.14.0
+Requires-Dist: numpy <2.0.0,>=1.14.0
 Requires-Dist: pandas >=1.0.0
 Requires-Dist: cloudpickle >=1.5.0
 Requires-Dist: psutil >=5.9.0
 Requires-Dist: tblib >=1.7.0
+Requires-Dist: packaging
 Requires-Dist: pickle5 ; python_version < "3.8"
 Requires-Dist: uvloop >=0.14.0 ; sys_platform != "win32"
 Requires-Dist: scipy >=1.0.0 ; sys_platform != "win32" or python_version >= "3.10"

{xoscar-0.2.1.dist-info → xoscar-0.3.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-xoscar-0.2.1.dist-info/RECORD,,
-xoscar-0.2.1.dist-info/WHEEL,sha256=wt_0D7ETubDJ-d2If9gFyi_RXCxFIy3PzOgckP8MsJY,109
-xoscar-0.2.1.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
-xoscar-0.2.1.dist-info/METADATA,sha256=rG9DA6iIoOVLoyKK0z5tid9xhSVnWccijS9blRQyfSc,9214
+xoscar-0.3.2.dist-info/RECORD,,
+xoscar-0.3.2.dist-info/WHEEL,sha256=WRwPRH7mjFT-dTZ5lq85StrNRg9EtOV3GBZVL26Gb_o,109
+xoscar-0.3.2.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
+xoscar-0.3.2.dist-info/METADATA,sha256=Sw1MUXmjiJDvY37wnlzYTfiAyRYM3pqIMfefEvjPr94,9246
 xoscar/_utils.pyx,sha256=UR1FtYXAYKIdEWR9HulEpMbSOrkQWi6xGz63d4IQmG0,7059
 xoscar/backend.py,sha256=is436OPkZfSpQXaoqTRVta5eoye_pp45RFgCstAk2hU,1850
 xoscar/core.pxd,sha256=4lBq8J0kjcXcsGuvN7Kv4xcL5liHwTTFWlqyK7XAEnw,1280
@@ -10,17 +10,16 @@ xoscar/context.pxd,sha256=qKa0OyDPZtVymftSh447m-RzFZgmz8rGqQBa7qlauvc,725
 xoscar/batch.py,sha256=DpArS0L3WYJ_HVPG-6hSYEwoAFY1mY2-mlC4Jp5M_Dw,7872
 xoscar/nvutils.py,sha256=qmW4mKLU0WB2yCs198ccQOgLL02zB7Fsa-AotO3NOmg,20412
 xoscar/constants.py,sha256=Yn59lRIOvE1VFwyuZB5G2-gxYIyhIZ1rVovbdFAR2NM,759
-xoscar/__init__.py,sha256=9BapEEmHU9OlpDOIc_4LwXNHfauP1XDW0YRnAUKZp_8,1721
+xoscar/__init__.py,sha256=0zX8kKaio3ZIrlzB79WybcravMJw1OxPWjDspTgJFyQ,1608
 xoscar/api.py,sha256=3hztPoOxg8A_mlhWyWgVP7FMXG0PATA1TP4Rbaj7A-g,13327
-xoscar/_utils.cpython-38-darwin.so,sha256=Gax7PtJkyx_-Au0YJ8IAzfep8KWa0ChQpNWczRNsQB4,191280
-xoscar/utils.py,sha256=TH81N2EWUDfAMdlkPYSh0juZS2EbdvvdhWx_6euQygk,14672
+xoscar/_utils.cpython-38-darwin.so,sha256=dMAe_zrbClyGKdkK_fwghRRVcsmKpu-UiGW0GGszkNU,191288
+xoscar/utils.py,sha256=TYp6wC8xx2AjKcoKt6Xk0bwhFeccBJKCK50YQE1XOV4,16076
 xoscar/debug.py,sha256=9Z8SgE2WaKYQcyDo-5-DxEJQ533v7kWjrvCd28pSx3E,5069
 xoscar/libcpp.pxd,sha256=DJqBxLFOKL4iRr9Kale5UH3rbvPRD1x5bTSOPHFpz9I,1147
-xoscar/entrypoints.py,sha256=t-PfnqYDyjzXbV-Z-hjaQxpf_m95eSx2saAsb-V2ODY,1642
 xoscar/context.pyx,sha256=8CdgPnWcE9eOp3N600WgDQ03MCi8P73eUOGcfV7Zksg,10942
-xoscar/context.cpython-38-darwin.so,sha256=eTBMnKqupkSQ1JZuVjfivBs7VNQKXI4LoljEjuBZTOg,231328
+xoscar/context.cpython-38-darwin.so,sha256=ljX58QrPptyVgyTXRJwepSV5rL63PfNRCLOV8h1nftY,231336
 xoscar/errors.py,sha256=wBlQOKsXf0Fc4skN39tDie0YZT-VIAuLNRgoDl2pZcA,1241
-xoscar/core.cpython-38-darwin.so,sha256=RcQwQZrzCOUV99HLD7RLICUD7Uk1Zu_bR8ENQn0rtI0,500640
+xoscar/core.cpython-38-darwin.so,sha256=Xfg8mJa09SQuBWGWIj2a7MOdHw8zJBQ9n_a-mnMuna0,500640
 xoscar/core.pyx,sha256=Aqc2i8Fetsd5wRAPF4kL0ddnBZn3E2HRNCvup79BbQc,21730
 xoscar/driver.py,sha256=498fowtJr6b3FE8FIOA_Tc1Vwx88nfZw7p0FxrML0h4,1372
 xoscar/profiling.py,sha256=BC5OF0HzSaXv8V7w-y-B8r5gV5DgxHFoTEIF6jCMioQ,8015
@@ -33,10 +32,10 @@ xoscar/metrics/backends/prometheus/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4
 xoscar/metrics/backends/prometheus/prometheus_metric.py,sha256=MxoMvVrg0pOkKpkjJ0PcAuEaaEJR2FZljmPrLjQ1-oc,2050
 xoscar/metrics/backends/console/console_metric.py,sha256=y5CCtH33j3AqI5_Uhwi4mgOcAhyhb4cWv_YvR6fxcbQ,2082
 xoscar/metrics/backends/console/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4BRnvKta_7VLQAL1ms,581
-xoscar/collective/xoscar_pygloo.cpython-38-darwin.so,sha256=j_7pbuNN3_v7myl1c2n2iwU292UtQkUs0z5a9byzjeI,1268160
+xoscar/collective/xoscar_pygloo.cpython-38-darwin.so,sha256=ptd1C1I79zPHLwJUdBND2SQ8DNBK3Vq0YpOxsyhjAeY,1268616
 xoscar/collective/__init__.py,sha256=XsClIkO_3Jd8GDifYuAbZCmJLAo9ZqGvnjUn9iuogmU,774
 xoscar/collective/core.py,sha256=WfMJZloiRiqsLlIMhU4Pa47eo0jE-hoXdbTBwZPM6TM,23498
-xoscar/collective/common.py,sha256=b9JkCnXEl-SWkHbMtmVmyJG7RzqPw4IIpHJfMwruU2M,3273
+xoscar/collective/common.py,sha256=INAnISbfnRicbbbDHTqbSr9ITb89ZphH5BUkSpEdXXU,3561
 xoscar/collective/utils.py,sha256=3S4qF4JEnAUD3RiWVBUj-ZptL83CBSwGYyVZyIasAsE,1178
 xoscar/collective/process_group.py,sha256=zy7LcIFnEcmrcxuECI89v0bQlUbSqQMkVyBw468WBnk,22599
 xoscar/serialization/exception.py,sha256=Jy8Lsk0z-VJyEUaWeuZIwkmxqaoB-nLKMa1D15Cl4js,1634
@@ -47,31 +46,31 @@ xoscar/serialization/numpy.py,sha256=5Kem87CvpJmzUMp3QHk4WeHU30FoQWTJJP2SwIcaQG0
 xoscar/serialization/cuda.py,sha256=iFUEnN4SiquBIhyieyOrfw3TnKnW-tU_vYgqOxO_DrA,3758
 xoscar/serialization/scipy.py,sha256=yOEi0NB8cqQ6e2UnCZ1w006RsB7T725tIL-DM_hNcsU,2482
 xoscar/serialization/aio.py,sha256=S9e3rHMBwqqKmJtDz7KzYAqWc8w9bttA0Dj83IBfEU0,4577
-xoscar/serialization/core.cpython-38-darwin.so,sha256=M7bL9_9CvkVqbQz8bdLzFm4b6997cxDHit4mZ660YiM,476160
+xoscar/serialization/core.cpython-38-darwin.so,sha256=mi0BA8J8w5u3XjmfoFY_f1yvgnaxZsvfzzjQoUxEAKw,476160
 xoscar/serialization/core.pyx,sha256=E3xIKmdI2gn99JduR3yuU_YTm-lOyG0Tkc7fZVBWCho,30131
 xoscar/backends/config.py,sha256=EG26f0GwX_f4dAhwTW77RBjiK9h8R_3JrD-rBF1bAq8,4984
 xoscar/backends/allocate_strategy.py,sha256=tC1Nbq2tJohahUwd-zoRYHEDX65wyuX8tmeY45uWj_w,4845
-xoscar/backends/message.cpython-38-darwin.so,sha256=udOZBvJmAmUxvHoe7Va8dTxhaNpYLgqT5nR-fsl7bK0,418016
+xoscar/backends/message.cpython-38-darwin.so,sha256=x0nu6jtsBT_fqOpHPwz8qWoXo7eNMLJ50pcxtVAIGHI,418016
 xoscar/backends/__init__.py,sha256=VHEBQcUWM5bj027W8EUf9PiJUAP7JoMrRw3Tsvy5ySw,643
-xoscar/backends/core.py,sha256=o6g3ZOW7PkGmiu-nNtp6I3Sd_2KkQDwOsKz-FdgRFs0,7390
-xoscar/backends/context.py,sha256=b4mDqcrA7uBsy9Rb5laxlbujCyj8GpBglpjkNcg-Mg0,15285
+xoscar/backends/core.py,sha256=aHb3mMZ9vJe6pxg0P8kSOKvjXF1IaqgOgyhKVhHpNLM,7432
+xoscar/backends/context.py,sha256=Vr_PibRxYCDQ_gYK7r-BOlw9TXw8VQbFsVTH7K7mHPk,15470
 xoscar/backends/router.py,sha256=mhSvM5KVfV882jricVcpyxAqHEvhS4zL6ivczC6fOTE,7746
 xoscar/backends/message.pyx,sha256=_rXcsWPcWu77Z_38rvjDBdQojpY5xJoaHQrt57_LVyo,17612
-xoscar/backends/pool.py,sha256=NqsCCL3LYqlDYrsZiI8hKeg4UpHom4jcsKGEhzueuWY,58156
+xoscar/backends/pool.py,sha256=bvS1r31O01E8jTdoWOhSqcFymksNqO2nX3Fkqary8Ro,59149
 xoscar/backends/indigen/backend.py,sha256=znl_fZzWGEtLH8hZ9j9Kkf0fva25jEem2_KO7I1RVvc,1612
 xoscar/backends/indigen/__init__.py,sha256=tKHP5ClzedBRBpZsLRVErR3EUNbbDm4CY4u0rCFJr44,685
 xoscar/backends/indigen/driver.py,sha256=VGzkacYKykegW5qhCuhx01gdgBZEKJjNIyfNCnA6Nm8,952
-xoscar/backends/indigen/pool.py,sha256=Fa8rqH3_OkrwMRtO3UJWjDDB-u58ckmN1tOMRGjsX8I,16122
+xoscar/backends/indigen/pool.py,sha256=3C1N2sbq02maUjl7jDhRkyYAoYmZD8hZBct6wxblq_Y,16709
 xoscar/backends/test/backend.py,sha256=nv9WFhH5Bbq4Q1HB9yfpciZBaeHT4IQAtzugBWESrUY,1263
 xoscar/backends/test/__init__.py,sha256=j2ZfD6prD9WjUxRUDC7Eq5Z7N7TkL6fFr59oNyc_vY4,682
-xoscar/backends/test/pool.py,sha256=43pMkebFAFLilvla5-AOS5W91shLycvfkbKwjdmlNWQ,7131
+xoscar/backends/test/pool.py,sha256=TW4X6J-92Pti66103poQBNDBznX6CBD3RLOc_zixjTo,7257
 xoscar/backends/communication/ucx.py,sha256=eidp4l-YAzFMCYaeUcvpK4ecapg-92fXFKO-t_bBkTU,19267
 xoscar/backends/communication/__init__.py,sha256=tB05BlK63iWQnfJgRzKt4mFKRtmWUki5hUGSZQwAotc,1050
 xoscar/backends/communication/core.py,sha256=sJeE3foRIqVPXldzYpFKHDSsabfAIFBU4JuXY4OyklY,2130
 xoscar/backends/communication/utils.py,sha256=AmovE-hmWLXNCPwHafYuaRjOk8m42BUyT3XBqfXQRVI,3664
 xoscar/backends/communication/errors.py,sha256=V3CdBe2xX9Rwv32f2dH2Msc84yaUhlyerZ42-739o1Q,723
 xoscar/backends/communication/socket.py,sha256=VBPiesyjX8c3ECWn8kv8qGwK3xCBqh_CHPrNDapYH6w,11819
-xoscar/backends/communication/dummy.py,sha256=Xgn-gQ8bM3P9jzozQHGOk6gaNGnxckDJ2Su07y8wAhk,7796
+xoscar/backends/communication/dummy.py,sha256=gaKPNiN4x2aGZV3IGaaa8eaweBVjRh8B19jU1B5t2yw,7798
 xoscar/backends/communication/base.py,sha256=0P4Tr35GSWpRp394e9jVWUUoKKa-gIk177eYPw1BnSU,7421
 xoscar/aio/__init__.py,sha256=4Rv9V_wDIKlg7VcJeo1GVlvobwskYb1jYXef-0GQOaY,809
 xoscar/aio/_threads.py,sha256=WE9_NZY3K9n5bAzXRbj1Bc4dxS-1m1erMfZsUu-ULU4,1313

{xoscar-0.2.1.dist-info → xoscar-0.3.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: false
 Tag: cp38-cp38-macosx_10_9_x86_64
 

xoscar/entrypoints.py

@@ -1,42 +0,0 @@
-# Copyright 2022-2023 XProbe Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import functools
-import logging
-import warnings
-
-logger = logging.getLogger(__name__)
-
-
-# from https://github.com/numba/numba/blob/master/numba/core/entrypoints.py
-# Must put this here to avoid extensions re-triggering initialization
-@functools.lru_cache(maxsize=None)
-def init_extension_entrypoints():
-    """Execute all `xoscar_extensions` entry points with the name `init`
-    If extensions have already been initialized, this function does nothing.
-    """
-    from pkg_resources import iter_entry_points  # type: ignore
-
-    for entry_point in iter_entry_points("xoscar_extensions", "init"):
-        logger.info("Loading extension: %s", entry_point)
-        try:
-            func = entry_point.load()
-            func()
-        except Exception as e:
-            msg = "Xoscar extension module '{}' failed to load due to '{}({})'."
-            warnings.warn(
-                msg.format(entry_point.module_name, type(e).__name__, str(e)),
-                stacklevel=2,
-            )
-            logger.info("Extension loading failed for: %s", entry_point)