xoscar 0.3.2__cp310-cp310-macosx_11_0_arm64.whl → 0.4.1__cp310-cp310-macosx_11_0_arm64.whl

xoscar/aio/__init__.py

@@ -11,15 +11,6 @@
 # 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 asyncio
-import sys
-
 from .file import AioFileObject
 from .lru import alru_cache
 from .parallelism import AioEvent
-
-if sys.version_info[:2] < (3, 9):
-    from ._threads import to_thread
-
-    asyncio.to_thread = to_thread

xoscar/backends/communication/socket.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 
 import asyncio
 import concurrent.futures as futures
+import logging
 import os
 import socket
 import sys
@@ -28,9 +29,9 @@ from typing import Any, Callable, Coroutine, Dict, Type
 from urllib.parse import urlparse
 
 from ..._utils import to_binary
-from ...constants import XOSCAR_UNIX_SOCKET_DIR
+from ...constants import XOSCAR_CONNECT_TIMEOUT, XOSCAR_UNIX_SOCKET_DIR
 from ...serialization import AioDeserializer, AioSerializer, deserialize
-from ...utils import classproperty, implements
+from ...utils import classproperty, implements, is_py_312, is_v6_ip
 from .base import Channel, ChannelType, Client, Server
 from .core import register_client, register_server
 from .utils import read_buffers, write_buffers
@@ -38,6 +39,9 @@ from .utils import read_buffers, write_buffers
 _is_windows: bool = sys.platform.startswith("win")
 
 
+logger = logging.getLogger(__name__)
+
+
 class SocketChannel(Channel):
     __slots__ = "reader", "writer", "_channel_type", "_send_lock", "_recv_lock"
 
@@ -131,11 +135,23 @@ class _BaseSocketServer(Server, metaclass=ABCMeta):
         if timeout is None:
             await self._aio_server.serve_forever()
         else:
-            future = asyncio.create_task(self._aio_server.serve_forever())
-            try:
-                await asyncio.wait_for(future, timeout=timeout)
-            except (futures.TimeoutError, asyncio.TimeoutError):
-                future.cancel()
+            if is_py_312():
+                # For python 3.12, there's a bug for `serve_forever`:
+                # https://github.com/python/cpython/issues/123720,
+                # which is unable to be cancelled.
+                # Here is really a simulation of `wait_for`
+                task = asyncio.create_task(self._aio_server.serve_forever())
+                await asyncio.sleep(timeout)
+                if task.done():
+                    logger.warning(f"`serve_forever` should never be done.")
+                else:
+                    task.cancel()
+            else:
+                future = asyncio.create_task(self._aio_server.serve_forever())
+                try:
+                    await asyncio.wait_for(future, timeout=timeout)
+                except (futures.TimeoutError, asyncio.TimeoutError, TimeoutError):
+                    future.cancel()
 
     @implements(Server.on_connected)
     async def on_connected(self, *args, **kwargs):
@@ -161,7 +177,10 @@ class _BaseSocketServer(Server, metaclass=ABCMeta):
     @implements(Server.stop)
     async def stop(self):
         self._aio_server.close()
-        await self._aio_server.wait_closed()
+        # Python 3.12: # https://github.com/python/cpython/issues/104344
+        # `wait_closed` leads to hang
+        if not is_py_312():
+            await self._aio_server.wait_closed()
         # close all channels
         await asyncio.gather(
             *(channel.close() for channel in self._channels if not channel.closed)
@@ -201,17 +220,37 @@ class SocketServer(_BaseSocketServer):
     def channel_type(self) -> int:
         return ChannelType.remote
 
+    @classmethod
+    def parse_config(cls, config: dict) -> dict:
+        if config is None or not config:
+            return dict()
+        # we only need the following config
+        keys = ["listen_elastic_ip"]
+        parsed_config = {key: config[key] for key in keys if key in config}
+
+        return parsed_config
+
     @staticmethod
     @implements(Server.create)
     async def create(config: Dict) -> "Server":
         config = config.copy()
         if "address" in config:
             address = config.pop("address")
-            host, port = address.split(":", 1)
+            host, port = address.rsplit(":", 1)
             port = int(port)
         else:
             host = config.pop("host")
             port = int(config.pop("port"))
+        _host = host
+        if config.pop("listen_elastic_ip", False):
+            # The Actor.address will be announce to client, and is not on our host,
+            # cannot actually listen on it,
+            # so we have to keep SocketServer.host untouched to make sure Actor.address not changed
+            if is_v6_ip(host):
+                _host = "::"
+            else:
+                _host = "0.0.0.0"
+
         handle_channel = config.pop("handle_channel")
         if "start_serving" not in config:
             config["start_serving"] = False
@@ -224,7 +263,7 @@ class SocketServer(_BaseSocketServer):
 
         port = port if port != 0 else None
         aio_server = await asyncio.start_server(
-            handle_connection, host=host, port=port, **config
+            handle_connection, host=_host, port=port, **config
         )
 
         # get port of the socket if not specified
@@ -250,9 +289,15 @@ class SocketClient(Client):
     async def connect(
         dest_address: str, local_address: str | None = None, **kwargs
     ) -> "Client":
-        host, port_str = dest_address.split(":", 1)
+        host, port_str = dest_address.rsplit(":", 1)
         port = int(port_str)
-        (reader, writer) = await asyncio.open_connection(host=host, port=port, **kwargs)
+        config = kwargs.get("config", {})
+        connect_timeout = config.get("connect_timeout", XOSCAR_CONNECT_TIMEOUT)
+        fut = asyncio.open_connection(host=host, port=port)
+        try:
+            reader, writer = await asyncio.wait_for(fut, timeout=connect_timeout)
+        except asyncio.TimeoutError:
+            raise ConnectionError("connect timeout")
         channel = SocketChannel(
             reader, writer, local_address=local_address, dest_address=dest_address
         )

xoscar/backends/communication/ucx.py

@@ -28,13 +28,13 @@ import numpy as np
 from ...nvutils import get_cuda_context, get_index_and_uuid
 from ...serialization import deserialize
 from ...serialization.aio import BUFFER_SIZES_NAME, AioSerializer, get_header_length
-from ...utils import classproperty, implements, is_cuda_buffer, lazy_import
+from ...utils import classproperty, implements, is_cuda_buffer, is_v6_ip, lazy_import
 from ..message import _MessageBase
 from .base import Channel, ChannelType, Client, Server
 from .core import register_client, register_server
 from .errors import ChannelClosed
 
-ucp = lazy_import("ucp")
+ucp = lazy_import("ucxx")
 numba_cuda = lazy_import("numba.cuda")
 rmm = lazy_import("rmm")
 
@@ -86,7 +86,7 @@ class UCXInitializer:
                 tls += ",cuda_copy"
 
             if ucx_config.get("infiniband"):  # pragma: no cover
-                tls = "rc," + tls
+                tls = "ib," + tls
             if ucx_config.get("nvlink"):  # pragma: no cover
                 tls += ",cuda_ipc"
 
@@ -177,7 +177,8 @@ class UCXInitializer:
         new_environ.update(envs)
         os.environ = new_environ  # type: ignore
         try:
-            ucp.init(options=options, env_takes_precedence=True)
+            # let UCX determine the appropriate transports
+            ucp.init()
         finally:
             os.environ = original_environ
 
@@ -313,7 +314,7 @@ class UCXChannel(Channel):
                         await self.ucp_endpoint.send(buf)
                 for buffer in buffers:
                     await self.ucp_endpoint.send(buffer)
-        except ucp.exceptions.UCXBaseException:  # pragma: no cover
+        except ucp.exceptions.UCXError:  # pragma: no cover
             self.abort()
             raise ChannelClosed("While writing, the connection was closed")
 
@@ -401,11 +402,21 @@ class UCXServer(Server):
             prefix = f"{UCXServer.scheme}://"
             if address.startswith(prefix):
                 address = address[len(prefix) :]
-            host, port = address.split(":", 1)
+            host, port = address.rsplit(":", 1)
             port = int(port)
         else:
             host = config.pop("host")
             port = int(config.pop("port"))
+        _host = host
+        if config.pop("listen_elastic_ip", False):
+            # The Actor.address will be announce to client, and is not on our host,
+            # cannot actually listen on it,
+            # so we have to keep SocketServer.host untouched to make sure Actor.address not changed
+            if is_v6_ip(host):
+                _host = "::"
+            else:
+                _host = "0.0.0.0"
+
         handle_channel = config.pop("handle_channel")
 
         # init
@@ -414,7 +425,7 @@ class UCXServer(Server):
         async def serve_forever(client_ucp_endpoint: "ucp.Endpoint"):  # type: ignore
             try:
                 await server.on_connected(
-                    client_ucp_endpoint, local_address=server.address
+                    client_ucp_endpoint, local_address="%s:%d" % (_host, port)
                 )
             except ChannelClosed:  # pragma: no cover
                 logger.exception("Connection closed before handshake completed")
@@ -498,7 +509,7 @@ class UCXClient(Client):
         prefix = f"{UCXClient.scheme}://"
         if dest_address.startswith(prefix):
             dest_address = dest_address[len(prefix) :]
-        host, port_str = dest_address.split(":", 1)
+        host, port_str = dest_address.rsplit(":", 1)
         port = int(port_str)
         kwargs = kwargs.copy()
         ucx_config = kwargs.pop("config", dict()).get("ucx", dict())
@@ -506,7 +517,7 @@ class UCXClient(Client):
 
         try:
             ucp_endpoint = await ucp.create_endpoint(host, port)
-        except ucp.exceptions.UCXBaseException as e:  # pragma: no cover
+        except ucp.exceptions.UCXError as e:  # pragma: no cover
             raise ChannelClosed(
                 f"Connection closed before handshake completed, "
                 f"local address: {local_address}, dest address: {dest_address}"

xoscar/backends/core.py

@@ -70,50 +70,61 @@ class ActorCaller:
         return client
 
     async def _listen(self, client: Client):
-        while not client.closed:
-            try:
+        try:
+            while not client.closed:
                 try:
-                    message: _MessageBase = await client.recv()
-                except (EOFError, ConnectionError, BrokenPipeError):
-                    # remote server closed, close client and raise ServerClosed
                     try:
-                        await client.close()
-                    except (ConnectionError, BrokenPipeError):
-                        # close failed, ignore it
+                        message: _MessageBase = await client.recv()
+                    except (EOFError, ConnectionError, BrokenPipeError) as e:
+                        # AssertionError is from get_header
+                        # remote server closed, close client and raise ServerClosed
+                        logger.debug(f"{client.dest_address} close due to {e}")
+                        try:
+                            await client.close()
+                        except (ConnectionError, BrokenPipeError):
+                            # close failed, ignore it
+                            pass
+                        raise ServerClosed(
+                            f"Remote server {client.dest_address} closed: {e}"
+                        ) from None
+                    future = self._client_to_message_futures[client].pop(
+                        message.message_id
+                    )
+                    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)
+                    future.set_exception(e.__cause__)  # type: ignore
+                except Exception as e:  # noqa: E722  # pylint: disable=bare-except
+                    message_futures = self._client_to_message_futures[client]
+                    self._client_to_message_futures[client] = dict()
+                    for future in message_futures.values():
+                        future.set_exception(copy.copy(e))
+                finally:
+                    # message may have Ray ObjectRef, delete it early in case next loop doesn't run
+                    # as soon as expected.
+                    try:
+                        del message
+                    except NameError:
                         pass
-                    raise ServerClosed(
-                        f"Remote server {client.dest_address} closed"
-                    ) from None
-                future = self._client_to_message_futures[client].pop(message.message_id)
-                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)
-                future.set_exception(e.__cause__)  # type: ignore
-            except Exception as e:  # noqa: E722  # pylint: disable=bare-except
-                message_futures = self._client_to_message_futures[client]
-                self._client_to_message_futures[client] = dict()
-                for future in message_futures.values():
-                    future.set_exception(copy.copy(e))
-            finally:
-                # message may have Ray ObjectRef, delete it early in case next loop doesn't run
-                # as soon as expected.
-                try:
-                    del message
-                except NameError:
-                    pass
-                try:
-                    del future
-                except NameError:
-                    pass
-                await asyncio.sleep(0)
+                    try:
+                        del future
+                    except NameError:
+                        pass
+                    await asyncio.sleep(0)
 
-        message_futures = self._client_to_message_futures[client]
-        self._client_to_message_futures[client] = dict()
-        error = ServerClosed(f"Remote server {client.dest_address} closed")
-        for future in message_futures.values():
-            future.set_exception(copy.copy(error))
+            message_futures = self._client_to_message_futures[client]
+            self._client_to_message_futures[client] = dict()
+            error = ServerClosed(f"Remote server {client.dest_address} closed")
+            for future in message_futures.values():
+                future.set_exception(copy.copy(error))
+        finally:
+            try:
+                await client.close()
+            except:  # noqa: E722  # nosec  # pylint: disable=bare-except
+                # ignore all error if fail to close at last
+                pass
 
     async def call_with_client(
         self, client: Client, message: _MessageBase, wait: bool = True

xoscar/backends/indigen/pool.py

@@ -132,7 +132,7 @@ class MainActorPool(MainActorPoolBase):
         """Get external address for every process"""
         assert n_process is not None
         if ":" in address:
-            host, port_str = address.split(":", 1)
+            host, port_str = address.rsplit(":", 1)
             port = int(port_str)
             if ports:
                 if len(ports) != n_process:
@@ -324,6 +324,7 @@ class MainActorPool(MainActorPoolBase):
         start_method: str | None = None,
         kwargs: dict | None = None,
     ):
+        # external_address has port 0, subprocess will bind random port.
         external_address = (
             external_address
             or MainActorPool.get_external_addresses(self.external_address, n_process=1)[
@@ -393,7 +394,7 @@ class MainActorPool(MainActorPoolBase):
             content=self._config,
         )
         await self.handle_control_command(control_message)
-
+        # The actual port will return in process_status.
         return process_status.external_addresses[0]
 
     async def remove_sub_pool(
@@ -416,22 +417,21 @@ class MainActorPool(MainActorPoolBase):
     async def kill_sub_pool(
         self, process: multiprocessing.Process, force: bool = False
     ):
-        if (
-            "COV_CORE_SOURCE" in os.environ and not force and not _is_windows
-        ):  # pragma: no cover
-            # must shutdown gracefully, or coverage info lost
-            try:
-                os.kill(process.pid, signal.SIGINT)  # type: ignore
-            except OSError:  # pragma: no cover
-                pass
-            process.terminate()
+        if not force:  # pragma: no cover
+            # must shutdown gracefully, or subprocess created by model will not exit
+            if not _is_windows:
+                try:
+                    os.kill(process.pid, signal.SIGINT)  # type: ignore
+                except OSError:  # pragma: no cover
+                    pass
+            process.terminate()  # SIGTERM
             wait_pool = futures.ThreadPoolExecutor(1)
             try:
                 loop = asyncio.get_running_loop()
                 await loop.run_in_executor(wait_pool, process.join, 3)
             finally:
                 wait_pool.shutdown(False)
-        process.kill()
+        process.kill()  # SIGKILL
         await asyncio.to_thread(process.join, 5)
 
     async def is_sub_pool_alive(self, process: multiprocessing.Process):

xoscar/backends/message.pyx

@@ -13,6 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import asyncio
 from enum import Enum
 from types import TracebackType
 from typing import Any, Type
@@ -21,7 +22,9 @@ from tblib import pickling_support
 
 from ..core cimport ActorRef, BufferRef
 from ..serialization.core cimport Serializer
+
 from ..utils import wrap_exception
+
 from .._utils cimport new_random_id
 
 # make sure traceback can be pickled
@@ -245,6 +248,11 @@ cdef class ErrorMessage(_MessageBase):
         if issubclass(self.error_type, _AsCauseBase):
             return self.error.with_traceback(self.traceback)
 
+        # for being compatible with Python 3.12 `asyncio.wait_for`
+        # https://github.com/python/cpython/pull/113850
+        if isinstance(self.error, asyncio.CancelledError):
+            return asyncio.CancelledError(f"[address={self.address}, pid={self.pid}]").with_traceback(self.traceback)
+
         return wrap_exception(
             self.error,
             (_AsCauseBase,),

xoscar/backends/pool.py

@@ -41,7 +41,7 @@ from ..errors import (
     ServerClosed,
 )
 from ..metrics import init_metrics
-from ..utils import implements, register_asyncio_task_timeout_detector
+from ..utils import implements, is_zero_ip, register_asyncio_task_timeout_detector
 from .allocate_strategy import AddressSpecified, allocated_type
 from .communication import (
     Channel,
@@ -164,7 +164,10 @@ class AbstractActorPool(ABC):
     ):
         # register local pool for local actor lookup.
         # The pool is weakrefed, so we don't need to unregister it.
-        register_local_pool(external_address, self)
+        if not is_zero_ip(external_address):
+            # Only register_local_pool when we listen on non-zero ip (because all-zero ip is wildcard address),
+            # avoid mistaken with another remote service listen on non-zero ip with the same port.
+            register_local_pool(external_address, self)
         self.process_index = process_index
         self.label = label
         self.external_address = external_address
@@ -548,23 +551,31 @@ class AbstractActorPool(ABC):
         return False
 
     async def on_new_channel(self, channel: Channel):
-        while not self._stopped.is_set():
-            try:
-                message = await channel.recv()
-            except EOFError:
-                # no data to read, check channel
+        try:
+            while not self._stopped.is_set():
                 try:
-                    await channel.close()
-                except (ConnectionError, EOFError):
-                    # close failed, ignore
-                    pass
-                return
-            if await self._handle_ucx_meta_message(message, channel):
-                continue
-            asyncio.create_task(self.process_message(message, channel))
-            # delete to release the reference of message
-            del message
-            await asyncio.sleep(0)
+                    message = await channel.recv()
+                except (EOFError, ConnectionError, BrokenPipeError) as e:
+                    logger.debug(f"pool: close connection due to {e}")
+                    # no data to read, check channel
+                    try:
+                        await channel.close()
+                    except (ConnectionError, EOFError):
+                        # close failed, ignore
+                        pass
+                    return
+                if await self._handle_ucx_meta_message(message, channel):
+                    continue
+                asyncio.create_task(self.process_message(message, channel))
+                # delete to release the reference of message
+                del message
+                await asyncio.sleep(0)
+        finally:
+            try:
+                await channel.close()
+            except:  # noqa: E722  # nosec  # pylint: disable=bare-except
+                # ignore all error if fail to close at last
+                pass
 
     async def __aenter__(self):
         await self.start()

xoscar/collective/core.py

@@ -95,7 +95,7 @@ class RankActor(Actor):
         return self._backend
 
     def _get_ip(self) -> str:
-        return self.address.split(":")[0]
+        return self.address.rsplit(":", 1)[0]
 
     def _process_group_name(self, ranks: List[int]) -> str:
         return hashlib.sha1(

xoscar/constants.py

@@ -19,3 +19,5 @@ XOSCAR_TEMP_DIR = Path(os.getenv("XOSCAR_DIR", Path.home())) / ".xoscar"
 
 # unix socket.
 XOSCAR_UNIX_SOCKET_DIR = XOSCAR_TEMP_DIR / "socket"
+
+XOSCAR_CONNECT_TIMEOUT = 8

xoscar/serialization/aio.py

@@ -77,7 +77,11 @@ MALFORMED_MSG = "Received malformed data, please check Xoscar version on both si
 def get_header_length(header_bytes: bytes):
     version = struct.unpack("B", header_bytes[:1])[0]
     # now we only have default version
-    assert version == DEFAULT_SERIALIZATION_VERSION, MALFORMED_MSG
+    if version != DEFAULT_SERIALIZATION_VERSION:
+        # when version not matched,
+        # we will immediately abort the connection
+        # EOFError will be captured by channel
+        raise EOFError(MALFORMED_MSG)
     # header length
     header_length = struct.unpack("<Q", header_bytes[1:9])[0]
     # compress

xoscar/serialization/core.pyx

@@ -55,7 +55,6 @@ from .pyfury import get_fury
 
 BUFFER_PICKLE_PROTOCOL = max(pickle.DEFAULT_PROTOCOL, 5)
 cdef bint HAS_PICKLE_BUFFER = pickle.HIGHEST_PROTOCOL >= 5
-cdef bint _PANDAS_HAS_MGR = hasattr(pd.Series([0]), "_mgr")
 
 cdef TypeDispatcher _serial_dispatcher = TypeDispatcher()
 cdef dict _deserializers = dict()
@@ -260,16 +259,7 @@ def unpickle_buffers(list buffers):
     else:
         result = cloudpickle.loads(buffers[0], buffers=buffers[1:])
 
-    # as pandas prior to 1.1.0 use _data instead of _mgr to hold BlockManager,
-    # deserializing from high versions may produce mal-functioned pandas objects,
-    # thus the patch is needed
-    if _PANDAS_HAS_MGR:
-        return result
-    else:  # pragma: no cover
-        if hasattr(result, "_mgr") and isinstance(result, (pd.DataFrame, pd.Series)):
-            result._data = getattr(result, "_mgr")
-            delattr(result, "_mgr")
-        return result
+    return result
 
 
 cdef class PickleSerializer(Serializer):

xoscar/utils.py

@@ -19,17 +19,18 @@ import asyncio
 import dataclasses
 import functools
 import importlib
+import importlib.util as importlib_utils
 import inspect
 import io
 import logging
 import os
-import pkgutil
 import random
 import socket
 import sys
 import time
 import uuid
 from abc import ABC
+from functools import lru_cache
 from types import TracebackType
 from typing import Callable, Type, Union
 
@@ -266,7 +267,7 @@ def lazy_import(
             self._on_loads.append(func)
             return func
 
-    if pkgutil.find_loader(prefix_name) is not None:
+    if importlib_utils.find_spec(prefix_name) is not None:
         return LazyModule()
     elif placeholder:
         return ModulePlaceholder(prefix_name)
@@ -464,13 +465,18 @@ def is_linux():
     return sys.platform.startswith("linux")
 
 
+@lru_cache
+def is_py_312():
+    return sys.version_info[:2] == (3, 12)
+
+
 def is_v4_zero_ip(ip_port_addr: str) -> bool:
-    return ip_port_addr.startswith("0.0.0.0:")
+    return ip_port_addr.split("://")[-1].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(":")
+    arr = ip_port_addr.split("://")[-1].split(":")
     if len(arr) <= 2:  # Not tcp6 or udp6
         return False
     for part in arr[0:-1]:
@@ -480,6 +486,15 @@ def is_v6_zero_ip(ip_port_addr: str) -> bool:
     return True
 
 
+def is_zero_ip(ip_port_addr: str) -> bool:
+    return is_v4_zero_ip(ip_port_addr) or is_v6_zero_ip(ip_port_addr)
+
+
+def is_v6_ip(ip_port_addr: str) -> bool:
+    arr = ip_port_addr.split("://", 1)[-1].split(":")
+    return len(arr) > 1
+
+
 def fix_all_zero_ip(remote_addr: str, connect_addr: str) -> str:
     """
     Use connect_addr to fix ActorRef.address return by remote server.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xoscar
-Version: 0.3.2
+Version: 0.4.1
 Summary: Python actor framework for heterogeneous computing.
 Home-page: http://github.com/xorbitsai/xoscar
 Author: Qin Xuye
@@ -11,48 +11,46 @@ License: Apache License 2.0
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
-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: numpy>=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"
-Requires-Dist: scipy <=1.9.1,>=1.0.0 ; sys_platform == "win32" and python_version < "3.10"
+Requires-Dist: uvloop>=0.14.0; sys_platform != "win32"
+Requires-Dist: scipy>=1.0.0; sys_platform != "win32" or python_version >= "3.10"
+Requires-Dist: scipy<=1.9.1,>=1.0.0; sys_platform == "win32" and python_version < "3.10"
 Provides-Extra: dev
-Requires-Dist: cython >=0.29 ; extra == 'dev'
-Requires-Dist: pytest >=3.5.0 ; extra == 'dev'
-Requires-Dist: pytest-cov >=2.5.0 ; extra == 'dev'
-Requires-Dist: pytest-timeout >=1.2.0 ; extra == 'dev'
-Requires-Dist: pytest-forked >=1.0 ; extra == 'dev'
-Requires-Dist: pytest-asyncio >=0.14.0 ; extra == 'dev'
-Requires-Dist: ipython >=6.5.0 ; extra == 'dev'
-Requires-Dist: sphinx <5.0.0,>=3.0.0 ; extra == 'dev'
-Requires-Dist: pydata-sphinx-theme >=0.3.0 ; extra == 'dev'
-Requires-Dist: sphinx-intl >=0.9.9 ; extra == 'dev'
-Requires-Dist: flake8 >=3.8.0 ; extra == 'dev'
-Requires-Dist: black ; extra == 'dev'
-Requires-Dist: mock >=4.0.0 ; (python_version < "3.8") and extra == 'dev'
+Requires-Dist: cython>=0.29; extra == "dev"
+Requires-Dist: pytest>=3.5.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.5.0; extra == "dev"
+Requires-Dist: pytest-timeout>=1.2.0; extra == "dev"
+Requires-Dist: pytest-forked>=1.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.14.0; extra == "dev"
+Requires-Dist: ipython>=6.5.0; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: pydata-sphinx-theme>=0.3.0; extra == "dev"
+Requires-Dist: sphinx-intl>=0.9.9; extra == "dev"
+Requires-Dist: flake8>=3.8.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
 Provides-Extra: doc
-Requires-Dist: ipython >=6.5.0 ; extra == 'doc'
-Requires-Dist: sphinx <5.0.0,>=3.0.0 ; extra == 'doc'
-Requires-Dist: pydata-sphinx-theme >=0.3.0 ; extra == 'doc'
-Requires-Dist: sphinx-intl >=0.9.9 ; extra == 'doc'
+Requires-Dist: ipython>=6.5.0; extra == "doc"
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: pydata-sphinx-theme>=0.3.0; extra == "doc"
+Requires-Dist: sphinx-intl>=0.9.9; extra == "doc"
 Provides-Extra: extra
-Requires-Dist: pyarrow >=5.0.0 ; extra == 'extra'
+Requires-Dist: pyarrow>=5.0.0; extra == "extra"
 Provides-Extra: kubernetes
-Requires-Dist: kubernetes >=10.0.0 ; extra == 'kubernetes'
+Requires-Dist: kubernetes>=10.0.0; extra == "kubernetes"
 Provides-Extra: ray
-Requires-Dist: xoscar-ray >=0.0.1 ; extra == 'ray'
+Requires-Dist: xoscar-ray>=0.0.1; extra == "ray"
 
 <div align="center">
   <img width="77%" alt="" src="https://raw.githubusercontent.com/xprobe-inc/xoscar/main/doc/source/_static/Xoscar.svg"><br>

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

@@ -1,7 +1,7 @@
-xoscar-0.3.2.dist-info/RECORD,,
-xoscar-0.3.2.dist-info/WHEEL,sha256=E2L8cNry8_qENFWMb8KxRWLe-RhZW94hLc32Xo3HiTg,110
-xoscar-0.3.2.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
-xoscar-0.3.2.dist-info/METADATA,sha256=Sw1MUXmjiJDvY37wnlzYTfiAyRYM3pqIMfefEvjPr94,9246
+xoscar-0.4.1.dist-info/RECORD,,
+xoscar-0.4.1.dist-info/WHEEL,sha256=2EkzLoFb7so8tT6oZZZ9qCoSorU44itt69ft8KTz84A,110
+xoscar-0.4.1.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
+xoscar-0.4.1.dist-info/METADATA,sha256=s1flP4I8DrL3z4TI3mPEAZpBJTlNTM9UwVVmRNXB1-Y,9042
 xoscar/_utils.pyx,sha256=UR1FtYXAYKIdEWR9HulEpMbSOrkQWi6xGz63d4IQmG0,7059
 xoscar/backend.py,sha256=is436OPkZfSpQXaoqTRVta5eoye_pp45RFgCstAk2hU,1850
 xoscar/core.pxd,sha256=4lBq8J0kjcXcsGuvN7Kv4xcL5liHwTTFWlqyK7XAEnw,1280
@@ -9,19 +9,19 @@ xoscar/_version.py,sha256=ClSPrUjgGRGHIkVMQV9XQnkQ-n0akJMnq_rh819nqFE,23719
 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/_utils.cpython-310-darwin.so,sha256=JDJSsLPX1G2EtvD92my6Em1dPx_hBZAeW_QEPZB0CLU,167616
+xoscar/constants.py,sha256=QHHSREw6uWBBjQDCFqlNfTvBZgniJPGy42KSIsR8Fqw,787
+xoscar/_utils.cpython-310-darwin.so,sha256=L7yQM7lAT1oEOPr_74DOnX1ixaZFG-BF5xDXPCxhYl0,167616
 xoscar/__init__.py,sha256=0zX8kKaio3ZIrlzB79WybcravMJw1OxPWjDspTgJFyQ,1608
 xoscar/api.py,sha256=3hztPoOxg8A_mlhWyWgVP7FMXG0PATA1TP4Rbaj7A-g,13327
-xoscar/utils.py,sha256=TYp6wC8xx2AjKcoKt6Xk0bwhFeccBJKCK50YQE1XOV4,16076
+xoscar/utils.py,sha256=jUw6OICZUPBbmS1b3GE4vLctJf6fCKXrYtLtBuK-Oqc,16483
 xoscar/debug.py,sha256=9Z8SgE2WaKYQcyDo-5-DxEJQ533v7kWjrvCd28pSx3E,5069
 xoscar/libcpp.pxd,sha256=DJqBxLFOKL4iRr9Kale5UH3rbvPRD1x5bTSOPHFpz9I,1147
 xoscar/context.pyx,sha256=8CdgPnWcE9eOp3N600WgDQ03MCi8P73eUOGcfV7Zksg,10942
 xoscar/errors.py,sha256=wBlQOKsXf0Fc4skN39tDie0YZT-VIAuLNRgoDl2pZcA,1241
 xoscar/core.pyx,sha256=Aqc2i8Fetsd5wRAPF4kL0ddnBZn3E2HRNCvup79BbQc,21730
 xoscar/driver.py,sha256=498fowtJr6b3FE8FIOA_Tc1Vwx88nfZw7p0FxrML0h4,1372
-xoscar/context.cpython-310-darwin.so,sha256=8akzNtrNTHrWNxHGA1I14Ig0pENi-n0O0_A88MS2oes,210160
-xoscar/core.cpython-310-darwin.so,sha256=HpKjl6lbmBOXHAsPDjTibwzfzJa5d6hkL3PbKEqu3vY,424856
+xoscar/context.cpython-310-darwin.so,sha256=iQnZpcGfyiRB-JeWCuzlukuHeHtHshXrRI7qCMbKMp0,210160
+xoscar/core.cpython-310-darwin.so,sha256=77Djano2hA2LMJAV36OS9wGmVj2pjWM5ZsMEKHIJsbk,424856
 xoscar/profiling.py,sha256=BC5OF0HzSaXv8V7w-y-B8r5gV5DgxHFoTEIF6jCMioQ,8015
 xoscar/_utils.pxd,sha256=5KYAL3jfPdejsHnrGGT2s--ZUX5SXznQWpHVSno429k,1157
 xoscar/metrics/__init__.py,sha256=9Badi7rxYikGm2dQiNCrj9GgMRBxwuR3JaEKcFZmfak,705
@@ -32,9 +32,9 @@ 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-310-darwin.so,sha256=h9LvFxBOi_FjQUxk3SpXwA5GCPaNqIZ-ZwOMHq7FVzA,1159104
+xoscar/collective/xoscar_pygloo.cpython-310-darwin.so,sha256=k_vzUB-mwxF6uDWLM1owJuA42afYGeUFZZgQG8eu2X0,1020576
 xoscar/collective/__init__.py,sha256=XsClIkO_3Jd8GDifYuAbZCmJLAo9ZqGvnjUn9iuogmU,774
-xoscar/collective/core.py,sha256=WfMJZloiRiqsLlIMhU4Pa47eo0jE-hoXdbTBwZPM6TM,23498
+xoscar/collective/core.py,sha256=NVR-7Iaq3aDPCN6fgXcq9Ew6uFEszRwxYqmUG9FLcws,23502
 xoscar/collective/common.py,sha256=INAnISbfnRicbbbDHTqbSr9ITb89ZphH5BUkSpEdXXU,3561
 xoscar/collective/utils.py,sha256=3S4qF4JEnAUD3RiWVBUj-ZptL83CBSwGYyVZyIasAsE,1178
 xoscar/collective/process_group.py,sha256=zy7LcIFnEcmrcxuECI89v0bQlUbSqQMkVyBw468WBnk,22599
@@ -45,35 +45,34 @@ xoscar/serialization/__init__.py,sha256=5Y_C3cYbQJIZ09LRjeCf-jrkLma7mfN8I5bznHrd
 xoscar/serialization/numpy.py,sha256=5Kem87CvpJmzUMp3QHk4WeHU30FoQWTJJP2SwIcaQG0,2919
 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.pyx,sha256=E3xIKmdI2gn99JduR3yuU_YTm-lOyG0Tkc7fZVBWCho,30131
-xoscar/serialization/core.cpython-310-darwin.so,sha256=E09XXCDdZ03eKZaHTxrq0tjH2HpSswDVNraah7qgYQQ,379208
+xoscar/serialization/aio.py,sha256=5DySPgDxU43ec7_5Ct44-Oqt7YNSJBfuf8VdQgQlChA,4731
+xoscar/serialization/core.pyx,sha256=bjR-zXGm9qersk7kYPzpjpMIxDl_Auur4BCubRfKmfA,29626
+xoscar/serialization/core.cpython-310-darwin.so,sha256=kKi7k6G3NJoGYeo3yyXtFy15WO_KyDQtDLxdc8Mx3s4,378952
 xoscar/backends/config.py,sha256=EG26f0GwX_f4dAhwTW77RBjiK9h8R_3JrD-rBF1bAq8,4984
 xoscar/backends/allocate_strategy.py,sha256=tC1Nbq2tJohahUwd-zoRYHEDX65wyuX8tmeY45uWj_w,4845
-xoscar/backends/message.cpython-310-darwin.so,sha256=K0muMTcS_VgQKJ6jf_Mzb-Qfw0tow5nyKMl-yAV0OY0,344512
+xoscar/backends/message.cpython-310-darwin.so,sha256=oxLCon0ha0Mh2wyg79R1IXCDUVloG5HFXQnCLmvTJbY,345264
 xoscar/backends/__init__.py,sha256=VHEBQcUWM5bj027W8EUf9PiJUAP7JoMrRw3Tsvy5ySw,643
-xoscar/backends/core.py,sha256=aHb3mMZ9vJe6pxg0P8kSOKvjXF1IaqgOgyhKVhHpNLM,7432
+xoscar/backends/core.py,sha256=YcXVrMrTUjnrnH-RhrtUyxnCbwon8miq2UigCQv-y_Q,8039
 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=bvS1r31O01E8jTdoWOhSqcFymksNqO2nX3Fkqary8Ro,59149
+xoscar/backends/message.pyx,sha256=uyzilPc_7SqNwGUL4U-Zbfqku8bfZyRW_Lt_S3I_LEU,17930
+xoscar/backends/pool.py,sha256=Z7Wdab9dBF3SdQpmzgZhY0d09oTvg5gpFgzYH7vuc4w,59841
 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=3C1N2sbq02maUjl7jDhRkyYAoYmZD8hZBct6wxblq_Y,16709
+xoscar/backends/indigen/pool.py,sha256=mWYkOP4VVoUsXFgfpwruPuWblF6Waan5vxit8B-9_oQ,16852
 xoscar/backends/test/backend.py,sha256=nv9WFhH5Bbq4Q1HB9yfpciZBaeHT4IQAtzugBWESrUY,1263
 xoscar/backends/test/__init__.py,sha256=j2ZfD6prD9WjUxRUDC7Eq5Z7N7TkL6fFr59oNyc_vY4,682
 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/ucx.py,sha256=7GAKIzlbxy-NpaDE9VLPde90tKxeU8lVZH8c_3ByuZ0,19703
 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/socket.py,sha256=ZSDqS_Z9-Oxs2Q2fqWUuUJ9hNf4w8lNJ8gUv5r6Ji_Y,13691
 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/aio/__init__.py,sha256=kViDKR_kJe59VQViHITKEfBcIgN4ZJblUyd8zl0E3ZI,675
 xoscar/aio/file.py,sha256=PBtkLp-Q7XtYl-zk00s18TtgIrkNr60J3Itf66ctO1o,1486
 xoscar/aio/lru.py,sha256=rpXCqSLtPV5xnWtd6uDwQQFGgIPEgvmWEQDkPNUx9cM,6311
 xoscar/aio/parallelism.py,sha256=VSsjk8wP-Bw7tLeUsTyLVNgp91thjxEfE3pCrw_vF5Q,1293

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

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: bdist_wheel (0.45.1)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_11_0_arm64
 

xoscar/aio/_threads.py

@@ -1,35 +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 contextvars
-import functools
-from asyncio import events
-
-__all__ = ("to_thread",)
-
-
-async def to_thread(func, *args, **kwargs):
-    """Asynchronously run function *func* in a separate thread.
-
-    Any *args and **kwargs supplied for this function are directly passed
-    to *func*. Also, the current :class:`contextvars.Context` is propagated,
-    allowing context variables from the main thread to be accessed in the
-    separate thread.
-
-    Return a coroutine that can be awaited to get the eventual result of *func*.
-    """
-    loop = events.get_running_loop()
-    ctx = contextvars.copy_context()
-    func_call = functools.partial(ctx.run, func, *args, **kwargs)
-    return await loop.run_in_executor(None, func_call)