mplang-nightly 0.1.dev280__tar.gz → 0.1.dev282__tar.gz

{mplang_nightly-0.1.dev280 → mplang_nightly-0.1.dev282}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mplang-nightly
-Version: 0.1.dev280
+Version: 0.1.dev282
 Summary: Multi-Party Programming Language
 Author-email: SecretFlow Team <secretflow-contact@service.alipay.com>
 License:                                  Apache License

{mplang_nightly-0.1.dev280 → mplang_nightly-0.1.dev282}/mplang/backends/channel.py

@@ -36,7 +36,9 @@ class CommunicatorProtocol(Protocol):
     Both ThreadCommunicator and HttpCommunicator implement this interface.
     """
 
-    def send(self, to: int, key: str, data: bytes) -> None: ...
+    def send(
+        self, to: int, key: str, data: bytes, *, is_raw_bytes: bool = False
+    ) -> None: ...
     def recv(self, frm: int, key: str) -> bytes: ...
 
 
@@ -111,9 +113,8 @@ class BaseChannel(libspu.link.IChannel):
             len(data),
         )
 
-        # Send raw bytes directly
-        # v2 communicators accept Any, bytes is valid
-        self._comm.send(self._peer_rank, key, data)
+        # Send raw bytes directly.
+        self._comm.send(self._peer_rank, key, data, is_raw_bytes=True)
 
     def Recv(self, tag: str) -> bytes:
         """Receive bytes from peer (blocking).

{mplang_nightly-0.1.dev280 → mplang_nightly-0.1.dev282}/mplang/backends/simp_worker/http.py

@@ -91,27 +91,37 @@ class HttpCommunicator:
         self._pending_sends: list[concurrent.futures.Future[None]] = []
         self.client = httpx.Client(timeout=None)
 
-    def send(self, to: int, key: str, data: Any) -> None:
-        """Send data to another rank asynchronously."""
-        future = self._send_executor.submit(self._do_send, to, key, data)
+    def send(self, to: int, key: str, data: Any, *, is_raw_bytes: bool = False) -> None:
+        """Send data to another rank asynchronously.
+
+        Args:
+            to: Target rank.
+            key: Message key.
+            data: Payload.
+            is_raw_bytes: If True, treat `data` as raw bytes and transmit as
+                base64-encoded bytes (no serde). If False, the transport may still
+                treat `bytes` payloads as raw bytes.
+        """
+        future = self._send_executor.submit(self._do_send, to, key, data, is_raw_bytes)
         self._pending_sends.append(future)
 
-    def _do_send(self, to: int, key: str, data: Any) -> None:
+    def _do_send(self, to: int, key: str, data: Any, is_raw_bytes: bool) -> None:
         """Perform the HTTP send."""
         url = f"{self.endpoints[to]}/comm/{key}"
         logger.debug(f"Rank {self.rank} sending to {to} key={key}, url={url}")
 
-        # Detect SPU channel (tag prefix "spu:") and handle bytes
-        if key.startswith("spu:") and isinstance(data, bytes):
-            # Send raw bytes for SPU channels
+        # Raw-bytes transport rule:
+        # - If caller explicitly marks raw bytes, always use raw path.
+        # - Otherwise, if payload is `bytes`, use raw path.
+        # This avoids coupling encoding format to key naming conventions.
+        send_raw_bytes = is_raw_bytes or isinstance(data, bytes)
+
+        if send_raw_bytes:
             import base64
 
             payload = base64.b64encode(data).decode("ascii")
-            is_raw_bytes = True
         else:
-            # Use secure JSON serialization
             payload = serde.dumps_b64(data)
-            is_raw_bytes = False
 
         size_bytes = len(payload)
 
@@ -132,7 +142,7 @@ class HttpCommunicator:
                 json={
                     "data": payload,
                     "from_rank": self.rank,
-                    "is_raw_bytes": is_raw_bytes,
+                    "is_raw_bytes": send_raw_bytes,
                 },
             )
             resp.raise_for_status()

{mplang_nightly-0.1.dev280 → mplang_nightly-0.1.dev282}/mplang/backends/simp_worker/mem.py

@@ -50,7 +50,7 @@ class ThreadCommunicator:
             self._shutdown = True
             self._cond.notify_all()
 
-    def send(self, to: int, key: str, data: Any) -> None:
+    def send(self, to: int, key: str, data: Any, *, is_raw_bytes: bool = False) -> None:
         assert 0 <= to < self.world_size
         if self.use_serde:
             from mplang.edsl import serde