xoscar 0.4.5__cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 0.5.0__cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

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/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/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/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/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/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/backends/indigen/pool.py

@@ -16,6 +16,7 @@
 from __future__ import annotations
 
 import asyncio
+import atexit
 import concurrent.futures as futures
 import configparser
 import contextlib
@@ -29,6 +30,7 @@ import sys
 import threading
 import uuid
 from dataclasses import dataclass
+from multiprocessing import util
 from types import TracebackType
 from typing import List, Optional
 
@@ -79,6 +81,19 @@ logger = logging.getLogger(__name__)
 _init_main_suspended_local = threading.local()
 
 
+def _terminate_children():
+    for c in multiprocessing.active_children():
+        try:
+            c.terminate()
+        except Exception:
+            pass
+
+
+if util:
+    # Import multiprocessing.util to register _exit_function at exit.
+    atexit.register(_terminate_children)
+
+
 def _patch_spawn_get_preparation_data():
     try:
         from multiprocessing import spawn as mp_spawn
@@ -309,6 +324,7 @@ class MainActorPool(MainActorPoolBase):
             raise
         finally:
             status_queue.put(process_status)
+            status_queue.cancel_join_thread()
         await pool.join()
 
     async def append_sub_pool(

xoscar/backends/message.pyx

@@ -47,6 +47,7 @@ class MessageType(Enum):
     cancel = 9
     copy_to_buffers = 10
     copy_to_fileobjs = 11
+    forward = 12
 
 
 class ControlMessageType(Enum):
@@ -350,13 +351,14 @@ cdef class DestroyActorMessage(_MessageBase):
     cdef _MessageSerialItem serial(self):
         cdef _MessageSerialItem item = _MessageBase.serial(self)
         item.serialized += (
-            self.actor_ref.address, self.actor_ref.uid, self.from_main
+            self.actor_ref.address, self.actor_ref.uid,
+            self.actor_ref.proxy_addresses, self.from_main
         )
         return item
 
     cdef deserial_members(self, tuple serialized, list subs):
         _MessageBase.deserial_members(self, serialized, subs)
-        self.actor_ref = ActorRef(serialized[-3], serialized[-2])
+        self.actor_ref = ActorRef(serialized[-4], serialized[-3], serialized[-2])
         self.from_main = serialized[-1]
 
 
@@ -381,13 +383,13 @@ cdef class HasActorMessage(_MessageBase):
     cdef _MessageSerialItem serial(self):
         cdef _MessageSerialItem item = _MessageBase.serial(self)
         item.serialized += (
-            self.actor_ref.address, self.actor_ref.uid
+            self.actor_ref.address, self.actor_ref.uid, self.actor_ref.proxy_addresses
         )
         return item
 
     cdef deserial_members(self, tuple serialized, list subs):
         _MessageBase.deserial_members(self, serialized, subs)
-        self.actor_ref = ActorRef(serialized[-2], serialized[-1])
+        self.actor_ref = ActorRef(serialized[-3], serialized[-2], serialized[-1])
 
 
 cdef class ActorRefMessage(_MessageBase):
@@ -411,13 +413,13 @@ cdef class ActorRefMessage(_MessageBase):
     cdef _MessageSerialItem serial(self):
         cdef _MessageSerialItem item = _MessageBase.serial(self)
         item.serialized += (
-            self.actor_ref.address, self.actor_ref.uid
+            self.actor_ref.address, self.actor_ref.uid, self.actor_ref.proxy_addresses
         )
         return item
 
     cdef deserial_members(self, tuple serialized, list subs):
         _MessageBase.deserial_members(self, serialized, subs)
-        self.actor_ref = ActorRef(serialized[-2], serialized[-1])
+        self.actor_ref = ActorRef(serialized[-3], serialized[-2], serialized[-1])
 
 
 cdef class SendMessage(_MessageBase):
@@ -449,14 +451,14 @@ cdef class SendMessage(_MessageBase):
     cdef _MessageSerialItem serial(self):
         cdef _MessageSerialItem item = _MessageBase.serial(self)
         item.serialized += (
-            self.actor_ref.address, self.actor_ref.uid
+            self.actor_ref.address, self.actor_ref.uid, self.actor_ref.proxy_addresses
         )
         item.subs = [self.content]
         return item
 
     cdef deserial_members(self, tuple serialized, list subs):
         _MessageBase.deserial_members(self, serialized, subs)
-        self.actor_ref = ActorRef(serialized[-2], serialized[-1])
+        self.actor_ref = ActorRef(serialized[-3], serialized[-2], serialized[-1])
         self.content = subs[0]
 
 
@@ -533,6 +535,50 @@ cdef class CopyToFileObjectsMessage(CopyToBuffersMessage):
     message_type = MessageType.copy_to_fileobjs
 
 
+cdef class ForwardMessage(_MessageBase):
+    message_type =  MessageType.forward
+
+    cdef:
+        public str address
+        public _MessageBase raw_message
+
+    def __init__(
+        self,
+        bytes message_id = None,
+        str address = None,
+        _MessageBase raw_message = None,
+        int protocol = DEFAULT_PROTOCOL,
+        list message_trace = None,
+    ):
+        _MessageBase.__init__(
+            self,
+            message_id,
+            protocol=protocol,
+            message_trace=message_trace
+        )
+        self.address = address
+        self.raw_message = raw_message
+
+    cdef _MessageSerialItem serial(self):
+        cdef _MessageSerialItem item = _MessageBase.serial(self)
+        cdef _MessageSerialItem raw_message_serialized = self.raw_message.serial()
+        item.serialized += (self.address,)
+        item.serialized += raw_message_serialized.serialized
+        item.subs += raw_message_serialized.subs
+        return item
+
+    cdef deserial_members(self, tuple serialized, list subs):
+        # 5 is magic number that means serialized for _MessageBase
+        base_serialized = serialized[:5]
+        _MessageBase.deserial_members(self, base_serialized, [])
+        self.address = serialized[5]
+        # process raw message
+        tp = _message_type_to_message_cls[serialized[6]]
+        cdef _MessageBase raw_message = <_MessageBase>(tp())
+        raw_message.deserial_members(serialized[6:], subs)
+        self.raw_message = raw_message
+
+
 cdef dict _message_type_to_message_cls = {
     MessageType.control.value: ControlMessage,
     MessageType.result.value: ResultMessage,
@@ -545,7 +591,8 @@ cdef dict _message_type_to_message_cls = {
     MessageType.tell.value: TellMessage,
     MessageType.cancel.value: CancelMessage,
     MessageType.copy_to_buffers.value: CopyToBuffersMessage,
-    MessageType.copy_to_fileobjs.value: CopyToFileObjectsMessage
+    MessageType.copy_to_fileobjs.value: CopyToFileObjectsMessage,
+    MessageType.forward.value: ForwardMessage,
 }
 
 

xoscar/backends/pool.py

@@ -62,6 +62,7 @@ from .message import (
     CreateActorMessage,
     DestroyActorMessage,
     ErrorMessage,
+    ForwardMessage,
     HasActorMessage,
     MessageType,
     ResultMessage,
@@ -123,6 +124,7 @@ def _register_message_handler(pool_type: Type["AbstractActorPool"]):
         (MessageType.send, pool_type.send),
         (MessageType.tell, pool_type.tell),
         (MessageType.cancel, pool_type.cancel),
+        (MessageType.forward, pool_type.forward),
         (MessageType.control, pool_type.handle_control_command),
         (MessageType.copy_to_buffers, pool_type.handle_copy_to_buffers_message),
         (MessageType.copy_to_fileobjs, pool_type.handle_copy_to_fileobjs_message),
@@ -311,6 +313,22 @@ class AbstractActorPool(ABC):
             result or error message
         """
 
+    async def forward(self, message: ForwardMessage) -> ResultMessageType:
+        """
+        Forward message
+
+        Parameters
+        ----------
+        message: ForwardMessage
+            Forward message.
+
+        Returns
+        -------
+        result_message
+            result or error message
+        """
+        return await self.call(message.address, message.raw_message)
+
     def _sync_pool_config(self, actor_pool_config: ActorPoolConfig):
         self._config = actor_pool_config
         # remove router from global one
@@ -377,7 +395,7 @@ class AbstractActorPool(ABC):
         try:
             await channel.send(result)
         except (ChannelClosed, ConnectionResetError):
-            if not self._stopped.is_set():
+            if not self._stopped.is_set() and not channel.closed:
                 raise
         except Exception as ex:
             logger.exception(
@@ -443,6 +461,7 @@ class AbstractActorPool(ABC):
             gen_local_address(process_index),
             actor_pool_config.external_to_internal_address_map,
             comm_config=actor_pool_config.get_comm_config(),
+            proxy_config=actor_pool_config.get_proxy_config(),
         )
         kw["env"] = curr_pool_config["env"]
 
@@ -605,7 +624,8 @@ class ActorPoolBase(AbstractActorPool, metaclass=ABCMeta):
             self._actors[actor_id] = actor
             await self._run_coro(message.message_id, actor.__post_create__())
 
-            result = ActorRef(address, actor_id)
+            proxies = self._router.get_proxies(address)
+            result = ActorRef(address, actor_id, proxy_addresses=proxies)
             # ensemble result message
             processor.result = ResultMessage(
                 message.message_id, result, protocol=message.protocol
@@ -647,9 +667,10 @@ class ActorPoolBase(AbstractActorPool, metaclass=ABCMeta):
             actor_id = message.actor_ref.uid
             if actor_id not in self._actors:
                 raise ActorNotExist(f"Actor {actor_id} does not exist")
+            proxies = self._router.get_proxies(self.external_address)
             result = ResultMessage(
                 message.message_id,
-                ActorRef(self.external_address, actor_id),
+                ActorRef(self.external_address, actor_id, proxy_addresses=proxies),
                 protocol=message.protocol,
             )
             processor.result = result
@@ -762,6 +783,7 @@ class ActorPoolBase(AbstractActorPool, metaclass=ABCMeta):
                 gen_local_address(process_index),
                 actor_pool_config.external_to_internal_address_map,
                 comm_config=actor_pool_config.get_comm_config(),
+                proxy_config=actor_pool_config.get_proxy_config(),
             )
 
     @classmethod
@@ -1155,6 +1177,7 @@ class MainActorPoolBase(ActorPoolBase):
         actor_ref = message.actor_ref
         actor_ref.uid = to_binary(actor_ref.uid)
         if actor_ref.address == self.external_address and actor_ref.uid in self._actors:
+            actor_ref.proxy_addresses = self._router.get_proxies(actor_ref.address)
             return ResultMessage(
                 message.message_id, actor_ref, protocol=message.protocol
             )
@@ -1163,6 +1186,7 @@ class MainActorPoolBase(ActorPoolBase):
         for address, item in self._allocated_actors.items():
             ref = create_actor_ref(address, actor_ref.uid)
             if ref in item:
+                ref.proxy_addresses = self._router.get_proxies(ref.address)
                 return ResultMessage(message.message_id, ref, protocol=message.protocol)
 
         with _ErrorProcessor(
@@ -1503,6 +1527,7 @@ async def create_actor_pool(
     suspend_sigint: bool | None = None,
     use_uvloop: str | bool = "auto",
     logging_conf: dict | None = None,
+    proxy_conf: dict | None = None,
     on_process_down: Callable[[MainActorPoolType, str], None] | None = None,
     on_process_recover: Callable[[MainActorPoolType, str], None] | None = None,
     extra_conf: dict | None = None,
@@ -1549,6 +1574,8 @@ async def create_actor_pool(
     )
     actor_pool_config = ActorPoolConfig()
     actor_pool_config.add_metric_configs(kwargs.get("metrics", {}))
+    # add proxy config
+    actor_pool_config.add_proxy_config(proxy_conf)
     # add main config
     process_index_gen = pool_cls.process_index_gen(address)
     main_process_index = next(process_index_gen)

xoscar/backends/router.py

@@ -17,10 +17,15 @@ from __future__ import annotations
 
 import asyncio
 import threading
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Optional, Type, Union
 
 from .communication import Client, get_client_type
 
+_CACHE_KEY_TYPE = Union[
+    tuple[str, Any, Optional[Type[Client]]],
+    tuple[str, Any, Optional[Type[Client]], Optional[tuple[str, ...]]],
+]
+
 
 class Router:
     """
@@ -32,6 +37,7 @@ class Router:
         "_local_mapping",
         "_mapping",
         "_comm_config",
+        "_proxy_config",
         "_cache_local",
     )
 
@@ -56,6 +62,7 @@ class Router:
         local_address: str | None,
         mapping: dict[str, str] | None = None,
         comm_config: dict | None = None,
+        proxy_config: dict | None = None,
     ):
         self._curr_external_addresses = external_addresses
         self._local_mapping = dict()
@@ -65,10 +72,11 @@ class Router:
             mapping = dict()
         self._mapping = mapping
         self._comm_config = comm_config or dict()
+        self._proxy_config = proxy_config or dict()
         self._cache_local = threading.local()
 
     @property
-    def _cache(self) -> dict[tuple[str, Any, Optional[Type[Client]]], Client]:
+    def _cache(self) -> dict[_CACHE_KEY_TYPE, Client]:
         try:
             return self._cache_local.cache
         except AttributeError:
@@ -92,6 +100,7 @@ class Router:
         self._local_mapping.update(router._local_mapping)
         self._mapping.update(router._mapping)
         self._comm_config.update(router._comm_config)
+        self._proxy_config.update(router._proxy_config)
         self._cache_local = threading.local()
 
     def remove_router(self, router: "Router"):
@@ -124,14 +133,23 @@ class Router:
         external_address: str,
         from_who: Any = None,
         cached: bool = True,
+        proxy_addresses: list[str] | None = None,
         **kw,
     ) -> Client:
         async with self._lock:
-            if cached and (external_address, from_who, None) in self._cache:
-                cached_client = self._cache[external_address, from_who, None]
+            proxy_addrs: tuple[str, ...] | None = (
+                tuple(proxy_addresses) if proxy_addresses else None
+            )
+            if (
+                cached
+                and (external_address, from_who, None, proxy_addrs) in self._cache
+            ):
+                cached_client = self._cache[
+                    external_address, from_who, None, proxy_addrs
+                ]
                 if cached_client.closed:
                     # closed before, ignore it
-                    del self._cache[external_address, from_who, None]
+                    del self._cache[external_address, from_who, None, proxy_addrs]
                 else:
                     return cached_client
 
@@ -139,10 +157,22 @@ class Router:
             if address is None:
                 # no inner address, just use external address
                 address = external_address
+                # check if proxy address exists
+                proxy_address = proxy_addresses[-1] if proxy_addresses else None
+                if proxy_address is None:
+                    proxy_address = self.get_proxy(address)
+                    if proxy_address and proxy_address != self.external_address:
+                        address = proxy_address
+                else:
+                    if new_proxy_address := self.get_proxy(proxy_address):
+                        address = new_proxy_address
+                    else:
+                        address = proxy_address
+
             client_type: Type[Client] = get_client_type(address)
             client = await self._create_client(client_type, address, **kw)
             if cached:
-                self._cache[external_address, from_who, None] = client
+                self._cache[external_address, from_who, None, proxy_addrs] = client
             return client
 
     async def _create_client(
@@ -158,7 +188,7 @@ class Router:
 
     def _get_client_type_to_addresses(
         self, external_address: str
-    ) -> Dict[Type[Client], str]:
+    ) -> dict[Type[Client], str]:
         client_type_to_addresses = dict()
         client_type_to_addresses[get_client_type(external_address)] = external_address
         if external_address in self._curr_external_addresses:  # pragma: no cover
@@ -173,7 +203,7 @@ class Router:
             client_type_to_addresses[client_type] = addr  # type: ignore
         return client_type_to_addresses
 
-    def get_all_client_types(self, external_address: str) -> List[Type[Client]]:
+    def get_all_client_types(self, external_address: str) -> list[Type[Client]]:
         return list(self._get_client_type_to_addresses(external_address))
 
     async def get_client_via_type(
@@ -205,3 +235,51 @@ class Router:
             if cached:
                 self._cache[external_address, from_who, client_type] = client
             return client
+
+    def get_proxy(self, from_addr: str) -> str | None:
+        """
+        Get proxy address that sent to.
+
+        Some patterns can be supported:
+
+        1. Direct address mapping, e.g. mapping 127.0.0.1:12345 -> 127.0.0.1:12346
+           The message will be sent to 127.0.0.1:12346 as forward one.
+        2. Host match, e.g. mapping 127.0.0.1 -> 127.0.0.1:12346
+           All the messages that match the host, e.g. 127.0.0.1:12345 and 127.0.0.1:12347
+           will be sent to 127.0.0.1:12346 as forward one.
+        3. Wildcard, e.g. mapping * -> 127.0.0.1:12346
+           All the messages will be sent to 127.0.0.1:12346 as forward one.
+        """
+
+        host = from_addr.split(":", 1)[0]
+
+        proxy_map = self._proxy_config
+        addr = proxy_map.get(from_addr)
+        if addr and addr != from_addr:
+            return addr
+        addr = proxy_map.get(host)
+        if addr and addr != from_addr:
+            return addr
+        addr = proxy_map.get("*")
+        if addr and addr != from_addr:
+            return addr
+        return None
+
+    def get_proxies(self, from_addr: str) -> list[str] | None:
+        """
+        Get all proxies
+
+        e.g. Proxy mapping {'a': 'b', 'b': 'c'}
+        get_proxies('a') will return ['b', 'c']
+        """
+
+        proxies: list[str] = []
+        while True:
+            proxy = self.get_proxy(from_addr)
+            if not proxies and not proxy:
+                return None
+            elif not proxy:
+                return proxies
+            else:
+                proxies.append(proxy)
+                from_addr = proxy

xoscar/core.pxd

@@ -18,6 +18,7 @@ cdef class ActorRef:
     cdef object __weakref__
     cdef public str address
     cdef public object uid
+    cdef public list proxy_addresses
     cdef dict _methods
 
 

xoscar/core.pyx

@@ -95,7 +95,7 @@ cpdef create_local_actor_ref(address, uid):
     return None
 
 
-cpdef create_actor_ref(address, uid):
+cpdef create_actor_ref(address, uid, list proxy_addresses = None):
     """
     Create an actor reference.
     TODO(fyrestone): Remove the create_actor_ref in _utils.pyx
@@ -105,18 +105,20 @@ cpdef create_actor_ref(address, uid):
     ActorRef or LocalActorRef
     """
     actor = _get_local_actor(address, uid)
-    return ActorRef(address, uid) if actor is None else LocalActorRef(actor)
+    return ActorRef(address, uid, proxy_addresses=proxy_addresses) \
+        if actor is None else LocalActorRef(actor)
 
 
 cdef class ActorRef:
     """
     Reference of an Actor at user side
     """
-    def __init__(self, str address, object uid):
+    def __init__(self, str address, object uid, list proxy_addresses = None):
         if isinstance(uid, str):
             uid = uid.encode()
         self.uid = uid
         self.address = address
+        self.proxy_addresses = proxy_addresses
         self._methods = dict()
 
     def destroy(self, object callback=None):
@@ -124,7 +126,7 @@ cdef class ActorRef:
         return ctx.destroy_actor(self)
 
     def __reduce__(self):
-        return create_actor_ref, (self.address, self.uid)
+        return create_actor_ref, (self.address, self.uid, self.proxy_addresses)
 
     def __getattr__(self, item):
         if item.startswith('_') and item not in ["__xoscar_next__", "__xoscar_destroy_generator__"]:
@@ -146,7 +148,11 @@ cdef class ActorRef:
         return False
 
     def __repr__(self):
-        return 'ActorRef(uid={!r}, address={!r})'.format(self.uid, self.address)
+        if not self.proxy_addresses:
+            return 'ActorRef(uid={!r}, address={!r})'.format(self.uid, self.address)
+        else:
+            return (f"ActorRef(uid={self.uid}, address={self.address}, "
+                    f"proxy_addresses={self.proxy_addresses})")
 
 
 cdef class _DelayedArgument:

xoscar/serialization/__init__.py

@@ -13,8 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import cuda, exception, numpy, scipy
+from . import cuda, exception, mlx, numpy, scipy
 from .aio import AioDeserializer, AioSerializer
 from .core import Serializer, deserialize, serialize, serialize_with_spawn
 
-del cuda, numpy, scipy, exception
+del cuda, numpy, scipy, mlx, exception

xoscar/serialization/mlx.py

@@ -0,0 +1,63 @@
+# Copyright 2022-2025 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.
+
+from typing import Any, List
+
+import numpy as np
+
+from ..utils import lazy_import
+from .core import Serializer, buffered
+
+mx = lazy_import("mlx.core")
+
+
+dtype_map = {
+    "b": np.int8,
+    "B": np.uint8,
+    "h": np.int16,
+    "H": np.uint16,
+    "i": np.int32,
+    "I": np.uint32,
+    "q": np.int64,
+    "Q": np.uint64,
+    "e": np.float16,
+    "f": np.float32,
+    "d": np.float64,
+}
+
+
+class MLXSerislizer(Serializer):
+    @buffered
+    def serial(self, obj: "mx.array", context: dict):  # type: ignore
+        mv = memoryview(obj)
+        header = dict(shape=mv.shape, format=mv.format)
+        if not mv.c_contiguous:
+            mv = memoryview(bytes(mv))
+        return (header,), [mv], True
+
+    def deserial(self, serialized: tuple, context: dict, subs: List[Any]):
+        header = serialized[0]
+        shape, format = header["shape"], header["format"]
+        mv = memoryview(subs[0])
+        if mv.format != format:
+            dtype = dtype_map.get(format, np.uint8)
+            np_arr = np.frombuffer(mv, dtype=dtype).reshape(shape)  # parse
+            mv = memoryview(np_arr)  # recreate memoryview
+        elif mv.shape != shape:
+            mv = mv.cast(format, shape)  # cast directly
+        return mx.array(mv)
+
+
+if mx is not None:
+    MLXSerislizer.register(mx.array)

{xoscar-0.4.5.dist-info → xoscar-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xoscar
-Version: 0.4.5
+Version: 0.5.0
 Summary: Python actor framework for heterogeneous computing.
 Home-page: http://github.com/xorbitsai/xoscar
 Author: Qin Xuye

{xoscar-0.4.5.dist-info → xoscar-0.5.0.dist-info}/RECORD

@@ -1,79 +1,80 @@
-xoscar-0.4.5.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
-xoscar-0.4.5.dist-info/RECORD,,
-xoscar-0.4.5.dist-info/METADATA,sha256=R6Zr_mb9l4xkf5mOtPo6XBDzFlR_XjHbq-oOrmdc3uM,9042
-xoscar-0.4.5.dist-info/WHEEL,sha256=OyU_a3_0g4nHrDfscT3ntE6UTOgLWum2-dKsAfzpQqc,150
+xoscar-0.5.0.dist-info/WHEEL,sha256=OyU_a3_0g4nHrDfscT3ntE6UTOgLWum2-dKsAfzpQqc,150
+xoscar-0.5.0.dist-info/RECORD,,
+xoscar-0.5.0.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
+xoscar-0.5.0.dist-info/METADATA,sha256=O_aAm6bQaZF9HvTXJsquvDrePWla--QdgpuPPnlqFds,9042
+xoscar/context.cpython-39-aarch64-linux-gnu.so,sha256=qpQRWk0vMVKnoiP-MIP2hcUzYGhQnsebZSHLMK8trRE,1443792
+xoscar/core.pxd,sha256=I_C2ka7XryyGnnAVXUVm8xfS1gtIrCs6X-9rswgOcUU,1317
+xoscar/core.pyx,sha256=phN-yYV0A0QI8WFi2jCu0nc4CnShTepfDi0V7ZrLYPY,22092
+xoscar/backend.py,sha256=is436OPkZfSpQXaoqTRVta5eoye_pp45RFgCstAk2hU,1850
+xoscar/_version.py,sha256=ClSPrUjgGRGHIkVMQV9XQnkQ-n0akJMnq_rh819nqFE,23719
+xoscar/constants.py,sha256=QHHSREw6uWBBjQDCFqlNfTvBZgniJPGy42KSIsR8Fqw,787
+xoscar/api.py,sha256=3hztPoOxg8A_mlhWyWgVP7FMXG0PATA1TP4Rbaj7A-g,13327
+xoscar/driver.py,sha256=498fowtJr6b3FE8FIOA_Tc1Vwx88nfZw7p0FxrML0h4,1372
 xoscar/errors.py,sha256=wBlQOKsXf0Fc4skN39tDie0YZT-VIAuLNRgoDl2pZcA,1241
-xoscar/nvutils.py,sha256=qmW4mKLU0WB2yCs198ccQOgLL02zB7Fsa-AotO3NOmg,20412
+xoscar/_utils.cpython-39-aarch64-linux-gnu.so,sha256=v5F2FYKiXpV-tMJmjNrMkeaZBvopmSVpRIPNwXuiMdM,1181960
 xoscar/utils.py,sha256=jUw6OICZUPBbmS1b3GE4vLctJf6fCKXrYtLtBuK-Oqc,16483
 xoscar/context.pxd,sha256=qKa0OyDPZtVymftSh447m-RzFZgmz8rGqQBa7qlauvc,725
-xoscar/_utils.pyx,sha256=UR1FtYXAYKIdEWR9HulEpMbSOrkQWi6xGz63d4IQmG0,7059
-xoscar/_utils.pxd,sha256=5KYAL3jfPdejsHnrGGT2s--ZUX5SXznQWpHVSno429k,1157
-xoscar/core.pyx,sha256=Aqc2i8Fetsd5wRAPF4kL0ddnBZn3E2HRNCvup79BbQc,21730
-xoscar/context.cpython-39-aarch64-linux-gnu.so,sha256=LV5N5Jhm721j5CYlFbWRXGsrjI2a6tKZj62HQ11jvDg,1443768
-xoscar/debug.py,sha256=9Z8SgE2WaKYQcyDo-5-DxEJQ533v7kWjrvCd28pSx3E,5069
-xoscar/_utils.cpython-39-aarch64-linux-gnu.so,sha256=WLy2j01X0tgDymLsJl3M1KDgDLGsgaBVDCbAV0kmgRg,1107656
-xoscar/constants.py,sha256=QHHSREw6uWBBjQDCFqlNfTvBZgniJPGy42KSIsR8Fqw,787
-xoscar/driver.py,sha256=498fowtJr6b3FE8FIOA_Tc1Vwx88nfZw7p0FxrML0h4,1372
+xoscar/libcpp.pxd,sha256=DJqBxLFOKL4iRr9Kale5UH3rbvPRD1x5bTSOPHFpz9I,1147
+xoscar/nvutils.py,sha256=qmW4mKLU0WB2yCs198ccQOgLL02zB7Fsa-AotO3NOmg,20412
 xoscar/profiling.py,sha256=BC5OF0HzSaXv8V7w-y-B8r5gV5DgxHFoTEIF6jCMioQ,8015
 xoscar/__init__.py,sha256=0zX8kKaio3ZIrlzB79WybcravMJw1OxPWjDspTgJFyQ,1608
-xoscar/api.py,sha256=3hztPoOxg8A_mlhWyWgVP7FMXG0PATA1TP4Rbaj7A-g,13327
-xoscar/core.cpython-39-aarch64-linux-gnu.so,sha256=ntP_ZHnfDSUQgePgqQMMTCvSaTNvW441nwh2mCQGdIk,3476960
-xoscar/core.pxd,sha256=4lBq8J0kjcXcsGuvN7Kv4xcL5liHwTTFWlqyK7XAEnw,1280
-xoscar/_version.py,sha256=ClSPrUjgGRGHIkVMQV9XQnkQ-n0akJMnq_rh819nqFE,23719
-xoscar/context.pyx,sha256=8CdgPnWcE9eOp3N600WgDQ03MCi8P73eUOGcfV7Zksg,10942
-xoscar/backend.py,sha256=is436OPkZfSpQXaoqTRVta5eoye_pp45RFgCstAk2hU,1850
-xoscar/libcpp.pxd,sha256=DJqBxLFOKL4iRr9Kale5UH3rbvPRD1x5bTSOPHFpz9I,1147
+xoscar/core.cpython-39-aarch64-linux-gnu.so,sha256=FoIqGQbK82pTGFndl4uOyTOPO7EHYQndUAmQVIFR_Xs,3505232
 xoscar/batch.py,sha256=DpArS0L3WYJ_HVPG-6hSYEwoAFY1mY2-mlC4Jp5M_Dw,7872
+xoscar/_utils.pxd,sha256=5KYAL3jfPdejsHnrGGT2s--ZUX5SXznQWpHVSno429k,1157
+xoscar/context.pyx,sha256=8CdgPnWcE9eOp3N600WgDQ03MCi8P73eUOGcfV7Zksg,10942
+xoscar/debug.py,sha256=9Z8SgE2WaKYQcyDo-5-DxEJQ533v7kWjrvCd28pSx3E,5069
+xoscar/_utils.pyx,sha256=6iqO4eTwEI-n9i39n_TKz7MWqbytMRnVNubdJ5egL6o,7279
 xoscar/collective/process_group.py,sha256=zy7LcIFnEcmrcxuECI89v0bQlUbSqQMkVyBw468WBnk,22599
-xoscar/collective/utils.py,sha256=3S4qF4JEnAUD3RiWVBUj-ZptL83CBSwGYyVZyIasAsE,1178
-xoscar/collective/common.py,sha256=INAnISbfnRicbbbDHTqbSr9ITb89ZphH5BUkSpEdXXU,3561
-xoscar/collective/__init__.py,sha256=XsClIkO_3Jd8GDifYuAbZCmJLAo9ZqGvnjUn9iuogmU,774
 xoscar/collective/core.py,sha256=NVR-7Iaq3aDPCN6fgXcq9Ew6uFEszRwxYqmUG9FLcws,23502
 xoscar/collective/xoscar_pygloo.cpython-39-aarch64-linux-gnu.so,sha256=cZVQDMX6ci3d3GJxLujGNPzpmE6cF8TfqSifaTzxOaI,1583168
-xoscar/metrics/__init__.py,sha256=9Badi7rxYikGm2dQiNCrj9GgMRBxwuR3JaEKcFZmfak,705
-xoscar/metrics/api.py,sha256=BBlMIFvVAGVfrtpeJ1YlH9Tqhy9OzGavwvGyeHcQ0Tk,8856
-xoscar/metrics/backends/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4BRnvKta_7VLQAL1ms,581
-xoscar/metrics/backends/metric.py,sha256=aPhyc8JgH22L3rcHP8IjsmgrhSODjg6B5TZVnre97y8,4446
-xoscar/metrics/backends/prometheus/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4BRnvKta_7VLQAL1ms,581
-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/backends/context.py,sha256=Vr_PibRxYCDQ_gYK7r-BOlw9TXw8VQbFsVTH7K7mHPk,15470
-xoscar/backends/__init__.py,sha256=VHEBQcUWM5bj027W8EUf9PiJUAP7JoMrRw3Tsvy5ySw,643
-xoscar/backends/core.py,sha256=rXJ73IC5lgERXCWvVrDEEyGAILlwVJs7XIWBCFUEVCc,10166
+xoscar/collective/utils.py,sha256=3S4qF4JEnAUD3RiWVBUj-ZptL83CBSwGYyVZyIasAsE,1178
+xoscar/collective/__init__.py,sha256=XsClIkO_3Jd8GDifYuAbZCmJLAo9ZqGvnjUn9iuogmU,774
+xoscar/collective/common.py,sha256=INAnISbfnRicbbbDHTqbSr9ITb89ZphH5BUkSpEdXXU,3561
+xoscar/backends/context.py,sha256=XfDPG2eDhAhE6hWBEkEsHTnyyOYN9R3houlMjAL7BFw,16329
+xoscar/backends/message.pyx,sha256=krGVtZ1YDaZX8yWhaNHwZiudQooLvcGlw6x3Sq7jxjE,19685
+xoscar/backends/pool.py,sha256=omYqaPyv1WW1YrU3OSZhk3kr0JyfI7MYhBtTemVJKZA,60895
+xoscar/backends/core.py,sha256=EH-fHlV9x3bnruEHaUtGYO7osKLfLJ4AQHtuzA_mr2g,10857
 xoscar/backends/allocate_strategy.py,sha256=tC1Nbq2tJohahUwd-zoRYHEDX65wyuX8tmeY45uWj_w,4845
-xoscar/backends/pool.py,sha256=Z7Wdab9dBF3SdQpmzgZhY0d09oTvg5gpFgzYH7vuc4w,59841
-xoscar/backends/router.py,sha256=mhSvM5KVfV882jricVcpyxAqHEvhS4zL6ivczC6fOTE,7746
-xoscar/backends/message.pyx,sha256=uyzilPc_7SqNwGUL4U-Zbfqku8bfZyRW_Lt_S3I_LEU,17930
-xoscar/backends/message.cpython-39-aarch64-linux-gnu.so,sha256=MI1amaTd1CBvZoihZGBBA0O-u2ugw8iw4djHM4CoNA8,3076360
-xoscar/backends/config.py,sha256=EG26f0GwX_f4dAhwTW77RBjiK9h8R_3JrD-rBF1bAq8,4984
-xoscar/backends/test/__init__.py,sha256=j2ZfD6prD9WjUxRUDC7Eq5Z7N7TkL6fFr59oNyc_vY4,682
-xoscar/backends/test/pool.py,sha256=TW4X6J-92Pti66103poQBNDBznX6CBD3RLOc_zixjTo,7257
-xoscar/backends/test/backend.py,sha256=nv9WFhH5Bbq4Q1HB9yfpciZBaeHT4IQAtzugBWESrUY,1263
+xoscar/backends/config.py,sha256=4tZMiXAMMS8qQ4SX_LjONLtSQVfZTx3m-IK3EqbkYdk,5375
+xoscar/backends/__init__.py,sha256=VHEBQcUWM5bj027W8EUf9PiJUAP7JoMrRw3Tsvy5ySw,643
+xoscar/backends/message.cpython-39-aarch64-linux-gnu.so,sha256=EWCPWsLgHq4S8w1WzPvvmhX7tZd2mO76lJ5zxVxJ2O4,3337768
+xoscar/backends/router.py,sha256=MVl5naz-FYf-Wla7XRn3kRxOpWV0SjKDsKNluifVA8M,10532
+xoscar/backends/communication/ucx.py,sha256=_Dp9Ld2MWIa1txSGMnmfYwJDT0esxS-GOd2FQ4BdHiM,19960
+xoscar/backends/communication/base.py,sha256=0P4Tr35GSWpRp394e9jVWUUoKKa-gIk177eYPw1BnSU,7421
 xoscar/backends/communication/dummy.py,sha256=6kLkxjNk4xTQ-IlNZD6cftNCx5UsGOur2jk7ikrNUCg,8157
 xoscar/backends/communication/errors.py,sha256=V3CdBe2xX9Rwv32f2dH2Msc84yaUhlyerZ42-739o1Q,723
-xoscar/backends/communication/utils.py,sha256=AmovE-hmWLXNCPwHafYuaRjOk8m42BUyT3XBqfXQRVI,3664
-xoscar/backends/communication/__init__.py,sha256=tB05BlK63iWQnfJgRzKt4mFKRtmWUki5hUGSZQwAotc,1050
 xoscar/backends/communication/core.py,sha256=sJeE3foRIqVPXldzYpFKHDSsabfAIFBU4JuXY4OyklY,2130
-xoscar/backends/communication/base.py,sha256=0P4Tr35GSWpRp394e9jVWUUoKKa-gIk177eYPw1BnSU,7421
-xoscar/backends/communication/socket.py,sha256=_1tuBZrSmdEC6c6QIj_7JQh23ruIIQPwySDMcrndzwA,14267
-xoscar/backends/communication/ucx.py,sha256=_Dp9Ld2MWIa1txSGMnmfYwJDT0esxS-GOd2FQ4BdHiM,19960
+xoscar/backends/communication/socket.py,sha256=6Pf9RJWHuvobjZ1eAU6bUuGY7PzYga3Vyc4PAKF-k2M,14428
+xoscar/backends/communication/utils.py,sha256=AmovE-hmWLXNCPwHafYuaRjOk8m42BUyT3XBqfXQRVI,3664
+xoscar/backends/communication/__init__.py,sha256=oFIg83Ga93-AhrG52TE85Z2LgpGZu1RCgQu1RWi62zQ,1063
+xoscar/backends/test/backend.py,sha256=nv9WFhH5Bbq4Q1HB9yfpciZBaeHT4IQAtzugBWESrUY,1263
+xoscar/backends/test/pool.py,sha256=TW4X6J-92Pti66103poQBNDBznX6CBD3RLOc_zixjTo,7257
+xoscar/backends/test/__init__.py,sha256=j2ZfD6prD9WjUxRUDC7Eq5Z7N7TkL6fFr59oNyc_vY4,682
+xoscar/backends/indigen/backend.py,sha256=znl_fZzWGEtLH8hZ9j9Kkf0fva25jEem2_KO7I1RVvc,1612
 xoscar/backends/indigen/driver.py,sha256=VGzkacYKykegW5qhCuhx01gdgBZEKJjNIyfNCnA6Nm8,952
+xoscar/backends/indigen/pool.py,sha256=v0Ps79W0WyeFSt2YxCJnh7q_1dnRQmo9887gcW3pNoc,17226
 xoscar/backends/indigen/__init__.py,sha256=tKHP5ClzedBRBpZsLRVErR3EUNbbDm4CY4u0rCFJr44,685
-xoscar/backends/indigen/pool.py,sha256=mWYkOP4VVoUsXFgfpwruPuWblF6Waan5vxit8B-9_oQ,16852
-xoscar/backends/indigen/backend.py,sha256=znl_fZzWGEtLH8hZ9j9Kkf0fva25jEem2_KO7I1RVvc,1612
-xoscar/aio/file.py,sha256=PBtkLp-Q7XtYl-zk00s18TtgIrkNr60J3Itf66ctO1o,1486
+xoscar/metrics/api.py,sha256=BBlMIFvVAGVfrtpeJ1YlH9Tqhy9OzGavwvGyeHcQ0Tk,8856
+xoscar/metrics/__init__.py,sha256=9Badi7rxYikGm2dQiNCrj9GgMRBxwuR3JaEKcFZmfak,705
+xoscar/metrics/backends/metric.py,sha256=aPhyc8JgH22L3rcHP8IjsmgrhSODjg6B5TZVnre97y8,4446
+xoscar/metrics/backends/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4BRnvKta_7VLQAL1ms,581
+xoscar/metrics/backends/console/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4BRnvKta_7VLQAL1ms,581
+xoscar/metrics/backends/console/console_metric.py,sha256=y5CCtH33j3AqI5_Uhwi4mgOcAhyhb4cWv_YvR6fxcbQ,2082
+xoscar/metrics/backends/prometheus/prometheus_metric.py,sha256=MxoMvVrg0pOkKpkjJ0PcAuEaaEJR2FZljmPrLjQ1-oc,2050
+xoscar/metrics/backends/prometheus/__init__.py,sha256=h_JgzSqV5lP6vQ6XX_17kE4IY4BRnvKta_7VLQAL1ms,581
 xoscar/aio/lru.py,sha256=rpXCqSLtPV5xnWtd6uDwQQFGgIPEgvmWEQDkPNUx9cM,6311
-xoscar/aio/__init__.py,sha256=kViDKR_kJe59VQViHITKEfBcIgN4ZJblUyd8zl0E3ZI,675
+xoscar/aio/file.py,sha256=PBtkLp-Q7XtYl-zk00s18TtgIrkNr60J3Itf66ctO1o,1486
 xoscar/aio/base.py,sha256=9j0f1piwfE5R5GIvV212vSD03ixdaeSzSSsO2kxJZVE,2249
 xoscar/aio/parallelism.py,sha256=VSsjk8wP-Bw7tLeUsTyLVNgp91thjxEfE3pCrw_vF5Q,1293
-xoscar/serialization/core.pyx,sha256=bjR-zXGm9qersk7kYPzpjpMIxDl_Auur4BCubRfKmfA,29626
-xoscar/serialization/__init__.py,sha256=5Y_C3cYbQJIZ09LRjeCf-jrkLma7mfN8I5bznHrdsbg,846
-xoscar/serialization/core.cpython-39-aarch64-linux-gnu.so,sha256=TdQdUNxNy34Amc0tPv9VRVE-RNepWa64LCG9yAStiBA,3203944
-xoscar/serialization/exception.py,sha256=Jy8Lsk0z-VJyEUaWeuZIwkmxqaoB-nLKMa1D15Cl4js,1634
+xoscar/aio/__init__.py,sha256=kViDKR_kJe59VQViHITKEfBcIgN4ZJblUyd8zl0E3ZI,675
 xoscar/serialization/core.pxd,sha256=k4RoJgX5E5LGs4jdCQ7vvcn26MabXbrWoWhkO49X6YI,985
-xoscar/serialization/scipy.py,sha256=yOEi0NB8cqQ6e2UnCZ1w006RsB7T725tIL-DM_hNcsU,2482
+xoscar/serialization/core.pyx,sha256=bjR-zXGm9qersk7kYPzpjpMIxDl_Auur4BCubRfKmfA,29626
 xoscar/serialization/aio.py,sha256=5DySPgDxU43ec7_5Ct44-Oqt7YNSJBfuf8VdQgQlChA,4731
-xoscar/serialization/numpy.py,sha256=5Kem87CvpJmzUMp3QHk4WeHU30FoQWTJJP2SwIcaQG0,2919
+xoscar/serialization/mlx.py,sha256=N_cvbTUBKc14XWYsPIMz4kDstyRN1DNhb4BVRgnQm8Y,1872
 xoscar/serialization/pyfury.py,sha256=sifOnVMYoS82PzZEkzkfxesmMHei23k5UAUUKUyoOYQ,1163
+xoscar/serialization/scipy.py,sha256=yOEi0NB8cqQ6e2UnCZ1w006RsB7T725tIL-DM_hNcsU,2482
+xoscar/serialization/__init__.py,sha256=v76XC2OQLp-Yk4_U3_IVguEylMeyRw1UrkU_DPDMh0U,856
+xoscar/serialization/numpy.py,sha256=5Kem87CvpJmzUMp3QHk4WeHU30FoQWTJJP2SwIcaQG0,2919
+xoscar/serialization/exception.py,sha256=Jy8Lsk0z-VJyEUaWeuZIwkmxqaoB-nLKMa1D15Cl4js,1634
+xoscar/serialization/core.cpython-39-aarch64-linux-gnu.so,sha256=-s3jpW0EsGNGS4r8EG7LpjZUSQVXB87tBcNev-DIdqk,3203944
 xoscar/serialization/cuda.py,sha256=iFUEnN4SiquBIhyieyOrfw3TnKnW-tU_vYgqOxO_DrA,3758