xoscar 0.4.6__tar.gz → 0.5.0__tar.gz

{xoscar-0.4.6 → xoscar-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: xoscar
-Version: 0.4.6
+Version: 0.5.0
 Summary: Python actor framework for heterogeneous computing.
 Home-page: http://github.com/xorbitsai/xoscar
 Author: Qin Xuye
@@ -18,11 +18,41 @@ 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>=1.14.0
+Requires-Dist: pandas>=1.0.0
+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: cloudpickle>=1.5.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: tblib>=1.7.0
+Requires-Dist: uvloop>=0.14.0; sys_platform != "win32"
+Requires-Dist: packaging
 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; 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; 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"
 Provides-Extra: kubernetes
+Requires-Dist: kubernetes>=10.0.0; extra == "kubernetes"
 Provides-Extra: ray
+Requires-Dist: xoscar_ray>=0.0.1; extra == "ray"
+Dynamic: description
+Dynamic: description-content-type
 
 <div align="center">
   <img width="77%" alt="" src="https://raw.githubusercontent.com/xprobe-inc/xoscar/main/doc/source/_static/Xoscar.svg"><br>

{xoscar-0.4.6 → xoscar-0.5.0}/setup.py

@@ -290,6 +290,7 @@ class CMakeBuild(build_ext):
             f"-DBUILD_TMP_DIR={build_temp}",
             f"-DPYTHON_PATH={sys.executable}",
             f"-DCMAKE_BUILD_TYPE={cfg}",  # not used on MSVC, but no harm
+            "-DCMAKE_POLICY_VERSION_MINIMUM=3.10",
         ]
         build_args = []
         # Adding CMake arguments set as environment variable

{xoscar-0.4.6 → xoscar-0.5.0}/xoscar/_utils.pyx

@@ -208,28 +208,32 @@ def create_actor_ref(*args, **kwargs):
 
     address = to_str(kwargs.pop('address', None))
     uid = kwargs.pop('uid', None)
+    proxy_addresses = kwargs.pop("proxy_addresses", None)
 
     if kwargs:
         raise ValueError('Only `address` or `uid` keywords are supported')
 
-    if len(args) == 2:
+    if 2 <= len(args) <= 3:
         if address:
             raise ValueError('address has been specified')
         address = to_str(args[0])
         uid = args[1]
+        if len(args) == 3:
+            proxy_addresses = args[2]
     elif len(args) == 1:
         tp0 = type(args[0])
         if tp0 is ActorRef or tp0 is LocalActorRef:
             existing_ref = <ActorRef>(args[0])
             uid = existing_ref.uid
             address = to_str(address or existing_ref.address)
+            proxy_addresses = existing_ref.proxy_addresses
         else:
             uid = args[0]
 
     if uid is None:
         raise ValueError('Actor uid should be provided')
 
-    return ActorRef(address, uid)
+    return ActorRef(address, uid, proxy_addresses=proxy_addresses)
 
 
 cdef class Timer:

{xoscar-0.4.6 → xoscar-0.5.0}/xoscar/backends/communication/__init__.py

@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .base import Channel, Client, Server
+from .base import Channel, ChannelType, Client, Server
 from .core import gen_local_address, get_client_type, get_server_type
 from .dummy import DummyChannel, DummyClient, DummyServer
 from .socket import (

{xoscar-0.4.6 → xoscar-0.5.0}/xoscar/backends/communication/socket.py

@@ -315,7 +315,11 @@ class SocketClient(Client):
         except asyncio.TimeoutError:
             raise ConnectionError("connect timeout")
         channel = SocketChannel(
-            reader, writer, local_address=local_address, dest_address=dest_address
+            reader,
+            writer,
+            local_address=local_address,
+            dest_address=dest_address,
+            channel_type=ChannelType.remote,
         )
         return SocketClient(local_address, dest_address, channel)
 
@@ -431,6 +435,10 @@ class UnixSocketClient(Client):
                 "Cannot connect unix socket due to file not exists"
             )
         channel = SocketChannel(
-            reader, writer, local_address=local_address, dest_address=dest_address
+            reader,
+            writer,
+            local_address=local_address,
+            dest_address=dest_address,
+            channel_type=ChannelType.ipc,
         )
         return UnixSocketClient(local_address, dest_address, channel)

{xoscar-0.4.6 → xoscar-0.5.0}/xoscar/backends/config.py

@@ -33,6 +33,8 @@ class ActorPoolConfig:
             self._conf["metrics"] = dict()
         if "comm" not in self._conf:
             self._conf["comm"] = dict()
+        if "proxy" not in self._conf:
+            self._conf["proxy"] = dict()
 
     @property
     def n_pool(self):
@@ -143,3 +145,13 @@ class ActorPoolConfig:
 
     def get_comm_config(self) -> dict:
         return self._conf["comm"]
+
+    def get_proxy_config(self) -> dict:
+        return self._conf["proxy"]
+
+    def add_proxy_config(self, proxy_config: dict[str, str] | None):
+        if proxy_config:
+            self._conf["proxy"].update(proxy_config)
+
+    def remove_proxy(self, from_addr: str):
+        del self._conf["proxy"][from_addr]

{xoscar-0.4.6 → xoscar-0.5.0}/xoscar/backends/context.py

@@ -72,15 +72,24 @@ class IndigenActorContext(BaseActorContext):
         self._caller.cancel_tasks()
 
     async def _call(
-        self, address: str, message: _MessageBase, wait: bool = True
+        self,
+        address: str,
+        message: _MessageBase,
+        wait: bool = True,
+        proxy_addresses: list[str] | None = None,
     ) -> Union[ResultMessage, ErrorMessage, asyncio.Future]:
         return await self._caller.call(
-            Router.get_instance_or_empty(), address, message, wait=wait
+            Router.get_instance_or_empty(),
+            address,
+            message,
+            wait=wait,
+            proxy_addresses=proxy_addresses,
         )
 
     async def _call_with_client(
         self, client: Client, message: _MessageBase, wait: bool = True
     ) -> Union[ResultMessage, ErrorMessage, asyncio.Future]:
+        # NOTE: used by copyto, cannot support proxy
         return await self._caller.call_with_client(client, message, wait)
 
     async def _call_send_buffers(
@@ -146,7 +155,12 @@ class IndigenActorContext(BaseActorContext):
         message = HasActorMessage(
             new_message_id(), actor_ref, protocol=DEFAULT_PROTOCOL
         )
-        future = await self._call(actor_ref.address, message, wait=False)
+        future = await self._call(
+            actor_ref.address,
+            message,
+            wait=False,
+            proxy_addresses=actor_ref.proxy_addresses,
+        )
         result = await self._wait(future, actor_ref.address, message)  # type: ignore
         return self._process_result_message(result)
 
@@ -154,7 +168,12 @@ class IndigenActorContext(BaseActorContext):
         message = DestroyActorMessage(
             new_message_id(), actor_ref, protocol=DEFAULT_PROTOCOL
         )
-        future = await self._call(actor_ref.address, message, wait=False)
+        future = await self._call(
+            actor_ref.address,
+            message,
+            wait=False,
+            proxy_addresses=actor_ref.proxy_addresses,
+        )
         result = await self._wait(future, actor_ref.address, message)  # type: ignore
         return self._process_result_message(result)
 
@@ -168,7 +187,7 @@ class IndigenActorContext(BaseActorContext):
             protocol=DEFAULT_PROTOCOL,
         )
         main_address = self._process_result_message(
-            await self._call(actor_ref.address, control_message)  # type: ignore
+            await self._call(actor_ref.address, control_message, proxy_addresses=actor_ref.proxy_addresses)  # type: ignore
         )
         real_actor_ref = await self.actor_ref(actor_ref)
         if real_actor_ref.address == main_address:
@@ -182,7 +201,9 @@ class IndigenActorContext(BaseActorContext):
             protocol=DEFAULT_PROTOCOL,
         )
         # stop server
-        result = await self._call(main_address, stop_message)
+        result = await self._call(
+            main_address, stop_message, proxy_addresses=actor_ref.proxy_addresses
+        )
         return self._process_result_message(result)  # type: ignore
 
     async def actor_ref(self, *args, **kwargs):
@@ -194,7 +215,12 @@ class IndigenActorContext(BaseActorContext):
         message = ActorRefMessage(
             new_message_id(), actor_ref, protocol=DEFAULT_PROTOCOL
         )
-        future = await self._call(actor_ref.address, message, wait=False)
+        future = await self._call(
+            actor_ref.address,
+            message,
+            wait=False,
+            proxy_addresses=actor_ref.proxy_addresses,
+        )
         result = await self._wait(future, actor_ref.address, message)
         res = self._process_result_message(result)
         if res.address != connect_addr:
@@ -225,7 +251,12 @@ class IndigenActorContext(BaseActorContext):
             actor_ref.address,
         ):
             detect_cycle_send(send_message, wait_response)
-            future = await self._call(actor_ref.address, send_message, wait=False)
+            future = await self._call(
+                actor_ref.address,
+                send_message,
+                wait=False,
+                proxy_addresses=actor_ref.proxy_addresses,
+            )
             if wait_response:
                 result = await self._wait(future, actor_ref.address, send_message)  # type: ignore
                 return self._process_result_message(result)
@@ -315,6 +346,8 @@ class IndigenActorContext(BaseActorContext):
     async def _get_client(self, address: str) -> Client:
         router = Router.get_instance()
         assert router is not None, "`copy_to` can only be used inside pools"
+        if router.get_proxy(address):
+            raise RuntimeError("Cannot run `copy_to` when enabling proxy")
         return await self._get_copy_to_client(router, address)
 
     async def copy_to_buffers(

{xoscar-0.4.6 → xoscar-0.5.0}/xoscar/backends/core.py

@@ -26,8 +26,15 @@ from typing import Type, Union
 from .._utils import Timer
 from ..errors import ServerClosed
 from ..profiling import get_profiling_data
-from .communication import Client, UCXClient
-from .message import DeserializeMessageFailed, ErrorMessage, ResultMessage, _MessageBase
+from .communication import ChannelType, Client, UCXClient
+from .message import (
+    DeserializeMessageFailed,
+    ErrorMessage,
+    ForwardMessage,
+    MessageType,
+    ResultMessage,
+    _MessageBase,
+)
 from .router import Router
 
 ResultMessageType = Union[ResultMessage, ErrorMessage]
@@ -67,8 +74,15 @@ class ActorCallerThreadLocal:
         self._listen_client(client)
         return client
 
-    async def get_client(self, router: Router, dest_address: str) -> Client:
-        client = await router.get_client(dest_address, from_who=self)
+    async def get_client(
+        self,
+        router: Router,
+        dest_address: str,
+        proxy_addresses: list[str] | None = None,
+    ) -> Client:
+        client = await router.get_client(
+            dest_address, from_who=self, proxy_addresses=proxy_addresses
+        )
         self._listen_client(client)
         return client
 
@@ -191,8 +205,20 @@ class ActorCallerThreadLocal:
         dest_address: str,
         message: _MessageBase,
         wait: bool = True,
+        proxy_addresses: list[str] | None = None,
     ) -> ResultMessage | ErrorMessage | asyncio.Future:
-        client = await self.get_client(router, dest_address)
+        client = await self.get_client(
+            router, dest_address, proxy_addresses=proxy_addresses
+        )
+        if (
+            client.channel_type == ChannelType.remote
+            and client.dest_address != dest_address
+            and message.message_type != MessageType.control
+        ):
+            # wrap message with forward message
+            message = ForwardMessage(
+                message_id=message.message_id, address=dest_address, raw_message=message
+            )
         return await self.call_with_client(client, message, wait)
 
     async def stop(self):

xoscar-0.5.0/xoscar/backends/message.pyi

@@ -0,0 +1,255 @@
+# Copyright 2022-2023 XProbe Inc.
+# derived from copyright 1999-2022 Alibaba Group Holding Ltd.
+#
+# 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.
+
+from __future__ import annotations
+
+from enum import Enum
+from types import TracebackType
+from typing import Any, List, Type
+
+from ..core import ActorRef, BufferRef
+
+DEFAULT_PROTOCOL: int = 0
+
+class MessageType(Enum):
+    control = 0
+    result = 1
+    error = 2
+    create_actor = 3
+    destroy_actor = 4
+    has_actor = 5
+    actor_ref = 6
+    send = 7
+    tell = 8
+    cancel = 9
+    copy_to_buffers = 10
+    copy_to_fileobjs = 11
+    forward = 12  # message forwarded to other pool
+
+class ControlMessageType(Enum):
+    stop = 0
+    restart = 1
+    sync_config = 2
+    get_config = 3
+    wait_pool_recovered = 4
+    add_sub_pool_actor = 5
+    # indicate that the following data will be used for copy_to
+    switch_to_copy_to = 6
+
+class _MessageBase:
+    message_type: MessageType
+    protocol: int
+    message_id: bytes
+    message_trace: list
+    profiling_context: Any
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+        profiling_context: Any = None,
+    ): ...
+    def __repr__(self): ...
+
+class CopyToBuffersMessage(_MessageBase):
+    message_type = MessageType.copy_to_buffers
+
+    content: object
+
+    def __int__(
+        self,
+        message_id: bytes | None = None,
+        content: object = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class CopyToFileObjectsMessage(CopyToBuffersMessage):
+    message_type = MessageType.copy_to_fileobjs
+
+class ControlMessage(_MessageBase):
+    message_type = MessageType.control
+
+    address: str
+    control_message_type: ControlMessageType
+    content: Any
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        address: str | None = None,
+        control_message_type: ControlMessageType | None = None,
+        content: Any = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class ResultMessage(_MessageBase):
+    message_type = MessageType.result
+
+    result: Any
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        result: Any = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+        profiling_context: Any = None,
+    ): ...
+
+class ErrorMessage(_MessageBase):
+    message_type = MessageType.error
+
+    address: str
+    pid: int
+    error_type: Type
+    error: BaseException
+    traceback: TracebackType
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        address: str | None = None,
+        pid: int = -1,
+        error_type: Type[BaseException] | None = None,
+        error: BaseException | None = None,
+        traceback: TracebackType | None = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+    def as_instanceof_cause(self) -> BaseException: ...
+
+class CreateActorMessage(_MessageBase):
+    message_type = MessageType.create_actor
+
+    actor_cls: Type
+    actor_id: bytes
+    args: tuple
+    kwargs: dict
+    allocate_strategy: Any
+    from_main: bool
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        actor_cls: Type | None = None,
+        actor_id: bytes | None = None,
+        args: tuple | None = None,
+        kwargs: dict | None = None,
+        allocate_strategy: Any = None,
+        from_main: bool = False,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class DestroyActorMessage(_MessageBase):
+    message_type = MessageType.destroy_actor
+
+    actor_ref: ActorRef
+    from_main: bool
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        actor_ref: ActorRef = None,
+        from_main: bool = False,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class HasActorMessage(_MessageBase):
+    message_type = MessageType.has_actor
+
+    actor_ref: ActorRef
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        actor_ref: ActorRef = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class ActorRefMessage(_MessageBase):
+    message_type = MessageType.actor_ref
+
+    actor_ref: ActorRef
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        actor_ref: ActorRef = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class SendMessage(_MessageBase):
+    message_type = MessageType.send
+
+    actor_ref: ActorRef
+    content: Any
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        actor_ref: ActorRef = None,
+        content: object = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+        profiling_context: Any = None,
+    ): ...
+
+class TellMessage(SendMessage):
+    message_type = MessageType.tell
+
+class CancelMessage(_MessageBase):
+    message_type = MessageType.cancel
+
+    address: str
+    cancel_message_id: bytes
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        address: str | None = None,
+        cancel_message_id: bytes | None = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class ForwardMessage(_MessageBase):
+    message_type = MessageType.forward
+
+    address: str
+    raw_message: _MessageBase
+
+    def __init__(
+        self,
+        message_id: bytes | None = None,
+        address: str | None = None,
+        raw_message: _MessageBase | None = None,
+        protocol: int = DEFAULT_PROTOCOL,
+        message_trace: list | None = None,
+    ): ...
+
+class DeserializeMessageFailed(RuntimeError):
+    message_id: bytes
+
+    def __init__(self, message_id: bytes): ...
+    def __str__(self): ...
+
+def new_message_id() -> bytes: ...