mplang-nightly 0.1.dev172__py3-none-any.whl → 0.1.dev174__py3-none-any.whl

mplang/__init__.py

@@ -31,40 +31,117 @@ from mplang.core import (
     MPContext,
     MPObject,
     MPType,
+    Rank,
     TableType,
     TensorType,
+    TraceContext,
+    TracedFunction,
+    cur_ctx,
     function,
+    set_ctx,
+    trace,
+    with_ctx,
 )
 from mplang.core.cluster import ClusterSpec, Device, Node, RuntimeInfo
-from mplang.core.context_mgr import cur_ctx, set_ctx, with_ctx
+from mplang.core.mpir import IrReader, IrWriter
+from mplang.core.primitive import (
+    constant,
+    pconv,
+    peval,
+    prand,
+    prank,
+    pshfl,
+    pshfl_s,
+    uniform_cond,
+    while_loop,
+)
 from mplang.host import CompileOptions, compile, evaluate, fetch
 from mplang.runtime.driver import Driver
 from mplang.runtime.simulation import Simulator
+from mplang.simp.api import (
+    run,
+    run_at,
+    run_ibis,
+    run_ibis_at,
+    run_jax,
+    run_jax_at,
+    run_sql,
+    run_sql_at,
+)
+from mplang.simp.mpi import allgather_m, bcast_m, gather_m, p2p, scatter_m
+from mplang.simp.party import P0, P1, P2, P2P, P, Party, load_module
+from mplang.simp.random import key_split, pperm, prandint, ukey, urandint
+from mplang.simp.smpc import reveal, revealTo, seal, sealFrom, srun
 
 # Public API
 __all__ = [
+    "P0",
+    "P1",
+    "P2",
+    "P2P",
     "ClusterSpec",
     "CompileOptions",
     "DType",
     "Device",
     "Driver",
     "InterpContext",
+    "IrReader",
+    "IrWriter",
     "MPContext",
     "MPObject",
     "MPType",
     "Mask",
     "Node",
+    "P",
+    "Party",
+    "Rank",
     "RuntimeInfo",
     "Simulator",
     "TableType",
     "TensorType",
+    "TraceContext",
+    "TracedFunction",
     "__version__",
+    "allgather_m",
     "analysis",
+    "bcast_m",
     "compile",
+    "constant",
     "cur_ctx",
     "evaluate",
     "fetch",
     "function",
+    "gather_m",
+    "key_split",
+    "load_module",
+    "p2p",
+    "pconv",
+    "peval",
+    "pperm",
+    "prand",
+    "prandint",
+    "prank",
+    "pshfl",
+    "pshfl_s",
+    "reveal",
+    "revealTo",
+    "run",
+    "run_at",
+    "run_ibis",
+    "run_ibis_at",
+    "run_jax",
+    "run_jax_at",
+    "run_sql",
+    "run_sql_at",
+    "scatter_m",
+    "seal",
+    "sealFrom",
     "set_ctx",
+    "srun",
+    "trace",
+    "ukey",
+    "uniform_cond",
+    "urandint",
+    "while_loop",
     "with_ctx",
 ]

mplang/analysis/diagram.py

@@ -26,7 +26,7 @@ from typing import TypedDict
 from mplang.core import TracedFunction
 from mplang.core.cluster import ClusterSpec
 from mplang.core.mask import Mask
-from mplang.core.mpir import Writer, get_graph_statistics
+from mplang.core.mpir import IrWriter, get_graph_statistics
 from mplang.protos.v1alpha1 import mpir_pb2
 
 # ----------------------------- Core helpers (copied) -----------------------------
@@ -450,7 +450,7 @@ def dump(
 
     # Build graph once
     expr = traced.make_expr()
-    graph_proto = Writer().dumps(expr)
+    graph_proto = IrWriter().dumps(expr)
 
     # Derive world_size from cluster_spec if provided
     derived_world_size: int | None = None

mplang/core/__init__.py

@@ -27,6 +27,7 @@ from mplang.core.comm import (
     ICollective,
     ICommunicator,
 )
+from mplang.core.context_mgr import cur_ctx, set_ctx, with_ctx
 from mplang.core.dtype import DType
 from mplang.core.interp import InterpContext, InterpVar
 from mplang.core.mask import Mask
@@ -76,6 +77,7 @@ __all__ = [
     "TracedFunction",
     "VarNamer",
     "constant",
+    "cur_ctx",
     "debug_print",
     "function",
     "pconv",
@@ -85,8 +87,10 @@ __all__ = [
     "pshfl",
     "pshfl_s",
     "psize",
+    "set_ctx",
     "set_mask",
     "trace",
     "uniform_cond",
     "while_loop",
+    "with_ctx",
 ]

mplang/core/mpir.py

@@ -204,7 +204,7 @@ def attr_to_proto(py_value: Any) -> mpir_pb2.AttrProto:
             raise TypeError(f"Unsupported tuple/list type: {type(py_value)}")
     elif isinstance(py_value, FuncDefExpr):
         # Convert FuncDefExpr to GraphProto
-        graph = Writer().dumps(py_value)
+        graph = IrWriter().dumps(py_value)
         attr_proto.type = mpir_pb2.AttrProto.GRAPH
         attr_proto.graph.CopyFrom(graph)
     elif isinstance(py_value, PFunction):
@@ -234,7 +234,7 @@ def attr_to_proto(py_value: Any) -> mpir_pb2.AttrProto:
     return attr_proto
 
 
-class Writer:
+class IrWriter:
     """Writer for serializing Expr-based expressions to GraphProto.
 
     This class traverses an expression tree and converts it into a serialized
@@ -525,7 +525,7 @@ class Writer:
             raise TypeError(f"Unsupported expr type for serialization: {type(expr)}")
 
 
-class Reader:
+class IrReader:
     """Reader for deserializing GraphProto back to Expr-based expressions.
 
     This class is responsible for converting serialized GraphProto representations
@@ -902,7 +902,7 @@ class Reader:
             )
         elif attr_proto.type == mpir_pb2.AttrProto.GRAPH:
             # Handle nested expressions (for control flow)
-            reader = Reader()
+            reader = IrReader()
             return reader.loads(attr_proto.graph)
         else:
             raise TypeError(f"Unsupported attribute type: {attr_proto.type}")

mplang/core/primitive.py

@@ -49,6 +49,9 @@ from mplang.core.table import TableLike
 from mplang.core.tensor import ScalarType, Shape, TensorLike
 from mplang.core.tracer import TraceContext, TraceVar, trace
 from mplang.ops import basic
+from mplang.ops.base import (
+    FeOperation,  # TODO(jint), is this a backward dependency?
+)
 from mplang.utils.func_utils import var_demorph, var_morph
 
 
@@ -243,9 +246,7 @@ def prank() -> MPObject:
     Note:
         Each party in the current party mask independently produces its own rank value.
     """
-    pfunc, eval_args, out_tree = basic.rank()
-    results = peval(pfunc, eval_args)
-    return out_tree.unflatten(results)  # type: ignore[no-any-return]
+    return cast(MPObject, run(None, basic.rank))
 
 
 @bltin_function
@@ -271,9 +272,7 @@ def prand(shape: Shape = ()) -> MPObject:
         private random values. The randomness is local to each party and is
         not shared or revealed to other parties.
     """
-    pfunc, eval_args, out_tree = basic.prand(shape)
-    results = peval(pfunc, eval_args)
-    return out_tree.unflatten(results)  # type: ignore[no-any-return]
+    return cast(MPObject, run(None, basic.prand, shape))
 
 
 def constant(data: TensorLike | ScalarType | TableLike) -> MPObject:
@@ -305,9 +304,7 @@ def constant(data: TensorLike | ScalarType | TableLike) -> MPObject:
         Note that the constant primitive is not designed to carry large tables efficiently -
         consider using dedicated table loading mechanisms for substantial datasets.
     """
-    pfunc, eval_args, out_tree = basic.constant(data)
-    results = peval(pfunc, eval_args)
-    return out_tree.unflatten(results)  # type: ignore[no-any-return]
+    return cast(MPObject, run(None, basic.constant, data))
 
 
 @bltin_function
@@ -319,7 +316,7 @@ def debug_print(obj: MPObject, prefix: str = "") -> MPObject:
     """
     pfunc, eval_args, out_tree = basic.debug_print(obj, prefix=prefix)
     results = peval(pfunc, eval_args)
-    return out_tree.unflatten(results)  # type: ignore[no-any-return]
+    return cast(MPObject, out_tree.unflatten(results))
 
 
 @function
@@ -386,6 +383,23 @@ def peval(
     return [TraceVar(ctx, res) for res in ret_exprs]
 
 
+def run(
+    pmask: Mask | None,
+    fe_op: FeOperation,
+    *args: Any,
+    **kwargs: Any,
+) -> Any:
+    """Run an operation in the current context."""
+    pfunc, eval_args, out_tree = fe_op(*args, **kwargs)
+    results = peval(pfunc, eval_args, pmask)
+    return out_tree.unflatten(results)
+
+
+def run_at(rank: Rank, op: Any, *args: Any, **kwargs: Any) -> Any:
+    """Run an operation at a specific rank."""
+    return run(Mask.from_ranks(rank), op, *args, **kwargs)
+
+
 def set_mask(arg: MPObject, mask: Mask) -> MPObject:
     """Set the mask of an MPObject to a new value.
 
@@ -447,7 +461,7 @@ def set_mask(arg: MPObject, mask: Mask) -> MPObject:
     """
     pfunc, eval_args, out_tree = basic.identity(arg)
     results = peval(pfunc, eval_args, mask)
-    return out_tree.unflatten(results)  # type: ignore[no-any-return]
+    return cast(MPObject, out_tree.unflatten(results))
 
 
 @function

mplang/device.py

@@ -29,8 +29,7 @@ from typing import Any
 
 from jax.tree_util import tree_map
 
-import mplang.host as mapi
-from mplang import simp
+import mplang.host as mphost
 from mplang.core import InterpContext, MPObject, primitive
 from mplang.core.cluster import ClusterSpec, Device
 from mplang.core.context_mgr import cur_ctx
@@ -40,6 +39,7 @@ from mplang.ops.base import FeOperation
 from mplang.ops.ibis_cc import IbisRunner
 from mplang.ops.jax_cc import JaxRunner
 from mplang.simp import mpi, smpc
+from mplang.simp.api import run_at
 
 # Automatic transfer between devices when parameter is not on the target device.
 g_auto_trans: bool = True
@@ -96,7 +96,7 @@ def _device_run_tee(
         raise ValueError("TEE device only supports JAX and Ibis frontend.")
     assert len(dev_info.members) == 1
     rank = dev_info.members[0].rank
-    var = simp.runAt(rank, op)(*args, **kwargs)
+    var = run_at(rank, op, *args, **kwargs)
     return tree_map(partial(_set_devid, dev_id=dev_info.name), var)
 
 
@@ -105,13 +105,13 @@ def _device_run_ppu(
 ) -> Any:
     assert len(dev_info.members) == 1
     rank = dev_info.members[0].rank
-    var = simp.runAt(rank, op)(*args, **kwargs)
+    var = run_at(rank, op, *args, **kwargs)
     return tree_map(partial(_set_devid, dev_id=dev_info.name), var)
 
 
 def _device_run(dev_id: str, op: FeOperation, *args: Any, **kwargs: Any) -> Any:
     assert isinstance(op, FeOperation)
-    cluster_spec = mapi.cur_ctx().cluster_spec
+    cluster_spec = mphost.cur_ctx().cluster_spec
     if dev_id not in cluster_spec.devices:
         raise ValueError(f"Device {dev_id} not found in cluster spec.")
 
@@ -177,7 +177,7 @@ def _d2d(to_dev_id: str, obj: MPObject) -> MPObject:
     if frm_dev_id == to_dev_id:
         return obj
 
-    cluster_spec: ClusterSpec = mapi.cur_ctx().cluster_spec
+    cluster_spec: ClusterSpec = mphost.cur_ctx().cluster_spec
     frm_dev = cluster_spec.devices[frm_dev_id]
     to_dev = cluster_spec.devices[to_dev_id]
     frm_to_pair = (frm_dev.kind.upper(), to_dev.kind.upper())
@@ -209,11 +209,11 @@ def _d2d(to_dev_id: str, obj: MPObject) -> MPObject:
         sess_p, sess_t = _ensure_tee_session(frm_dev_id, to_dev_id, frm_rank, tee_rank)
         # Bytes-only path: pack -> enc -> p2p -> dec -> unpack (with static out type)
         obj_ty = TensorType.from_obj(obj)
-        b = simp.runAt(frm_rank, basic.pack)(obj)
-        ct = simp.runAt(frm_rank, crypto.enc)(b, sess_p)
+        b = run_at(frm_rank, basic.pack, obj)
+        ct = run_at(frm_rank, crypto.enc, b, sess_p)
         ct_at_tee = mpi.p2p(frm_rank, tee_rank, ct)
-        b_at_tee = simp.runAt(tee_rank, crypto.dec)(ct_at_tee, sess_t)
-        pt_at_tee = simp.runAt(tee_rank, basic.unpack)(b_at_tee, out_ty=obj_ty)
+        b_at_tee = run_at(tee_rank, crypto.dec, ct_at_tee, sess_t)
+        pt_at_tee = run_at(tee_rank, basic.unpack, b_at_tee, out_ty=obj_ty)
         return tree_map(partial(_set_devid, dev_id=to_dev_id), pt_at_tee)  # type: ignore[no-any-return]
     elif frm_to_pair == ("TEE", "PPU"):
         # Transparent encryption from TEE to a specific PPU using the reverse-direction session key
@@ -223,11 +223,11 @@ def _d2d(to_dev_id: str, obj: MPObject) -> MPObject:
         # Ensure bidirectional session established for this pair
         sess_p, sess_t = _ensure_tee_session(to_dev_id, frm_dev_id, ppu_rank, tee_rank)
         obj_ty = TensorType.from_obj(obj)
-        b = simp.runAt(tee_rank, basic.pack)(obj)
-        ct = simp.runAt(tee_rank, crypto.enc)(b, sess_t)
+        b = run_at(tee_rank, basic.pack, obj)
+        ct = run_at(tee_rank, crypto.enc, b, sess_t)
         ct_at_ppu = mpi.p2p(tee_rank, ppu_rank, ct)
-        b_at_ppu = simp.runAt(ppu_rank, crypto.dec)(ct_at_ppu, sess_p)
-        pt_at_ppu = simp.runAt(ppu_rank, basic.unpack)(b_at_ppu, out_ty=obj_ty)
+        b_at_ppu = run_at(ppu_rank, crypto.dec, ct_at_ppu, sess_p)
+        pt_at_ppu = run_at(ppu_rank, basic.unpack, b_at_ppu, out_ty=obj_ty)
         return tree_map(partial(_set_devid, dev_id=to_dev_id), pt_at_ppu)  # type: ignore[no-any-return]
     else:
         supported = [
@@ -260,27 +260,25 @@ def _ensure_tee_session(
 
     # 1) TEE generates (sk, pk) and quote(pk)
     # KEM suite currently constant; future: read from tee device config (e.g. cluster_spec.devices[dev_id].config)
-    tee_sk, tee_pk = simp.runAt(tee_rank, crypto.kem_keygen)(_TEE_KEM_SUITE)
-    quote = simp.runAt(tee_rank, tee.quote_gen)(tee_pk)
+    tee_sk, tee_pk = run_at(tee_rank, crypto.kem_keygen, _TEE_KEM_SUITE)
+    quote = run_at(tee_rank, tee.quote_gen, tee_pk)
 
     # 2) Send quote to sender and attest to obtain TEE pk
     quote_at_sender = mpi.p2p(tee_rank, frm_rank, quote)
-    tee_pk_at_sender = simp.runAt(frm_rank, tee.attest)(quote_at_sender)
+    tee_pk_at_sender = run_at(frm_rank, tee.attest, quote_at_sender)
 
     # 3) Sender generates its ephemeral keypair and sends its pk to TEE
-    v_sk, v_pk = simp.runAt(frm_rank, crypto.kem_keygen)(_TEE_KEM_SUITE)
+    v_sk, v_pk = run_at(frm_rank, crypto.kem_keygen, _TEE_KEM_SUITE)
     v_pk_at_tee = mpi.p2p(frm_rank, tee_rank, v_pk)
 
     # 4) Both sides derive the shared secret and session key
-    shared_p = simp.runAt(frm_rank, crypto.kem_derive)(
-        v_sk, tee_pk_at_sender, _TEE_KEM_SUITE
-    )
-    shared_t = simp.runAt(tee_rank, crypto.kem_derive)(
-        tee_sk, v_pk_at_tee, _TEE_KEM_SUITE
+    shared_p = run_at(
+        frm_rank, crypto.kem_derive, v_sk, tee_pk_at_sender, _TEE_KEM_SUITE
     )
+    shared_t = run_at(tee_rank, crypto.kem_derive, tee_sk, v_pk_at_tee, _TEE_KEM_SUITE)
     # Use a fixed ASCII string literal for HKDF info on both sides
-    sess_p = simp.runAt(frm_rank, crypto.hkdf)(shared_p, _HKDF_INFO_LITERAL)
-    sess_t = simp.runAt(tee_rank, crypto.hkdf)(shared_t, _HKDF_INFO_LITERAL)
+    sess_p = run_at(frm_rank, crypto.hkdf, shared_p, _HKDF_INFO_LITERAL)
+    sess_t = run_at(tee_rank, crypto.hkdf, shared_t, _HKDF_INFO_LITERAL)
 
     cache[key] = (sess_p, sess_t)
     return sess_p, sess_t
@@ -300,25 +298,25 @@ def _fetch(interp: InterpContext, obj: MPObject) -> Any:
 
     dev_info = cluster_spec.devices[dev_id]
     if dev_kind == "SPU":
-        revealed = mapi.evaluate(interp, smpc.reveal, obj)
-        result = mapi.fetch(interp, revealed)
+        revealed = mphost.evaluate(interp, smpc.reveal, obj)
+        result = mphost.fetch(interp, revealed)
         # now all members have the same value, return the one at rank 0
         return result[dev_info.members[0].rank]
     elif dev_kind == "PPU":
         assert len(dev_info.members) == 1
         rank = dev_info.members[0].rank
-        result = mapi.fetch(interp, obj)
+        result = mphost.fetch(interp, obj)
         return result[rank]
     elif dev_kind == "TEE":
         assert len(dev_info.members) == 1
         rank = dev_info.members[0].rank
-        result = mapi.fetch(interp, obj)
+        result = mphost.fetch(interp, obj)
         return result[rank]
     else:
         raise ValueError(f"Unknown device id: {dev_id}")
 
 
 def fetch(interp: InterpContext, objs: Any) -> Any:
-    ctx = interp or mapi.cur_ctx()
+    ctx = interp or mphost.cur_ctx()
     assert isinstance(ctx, InterpContext), f"Expect InterpContext, got {ctx}"
     return tree_map(partial(_fetch, ctx), objs)

mplang/runtime/driver.py

@@ -15,8 +15,8 @@
 """
 HTTP-based driver implementation for distributed execution.
 
-This module provides an HTTP-based alternative to the gRPC Driver,
-using REST APIs for distributed multi-party computation coordination.
+This module provides an HTTP-based driver, using REST APIs
+for distributed multi-party computation coordination.
 """
 
 from __future__ import annotations
@@ -33,7 +33,7 @@ from mplang.core.cluster import ClusterSpec
 from mplang.core.expr.ast import Expr
 from mplang.core.interp import InterpContext, InterpVar
 from mplang.core.mask import Mask
-from mplang.core.mpir import Writer
+from mplang.core.mpir import IrWriter
 from mplang.core.mpobject import MPObject
 from mplang.core.mptype import MPType
 from mplang.kernels.value import TableValue, TensorValue
@@ -198,7 +198,7 @@ class Driver(InterpContext):
 
         var_name_mapping = dict(zip(var_names, party_symbol_names, strict=True))
 
-        writer = Writer(var_name_mapping)
+        writer = IrWriter(var_name_mapping)
         program_proto = writer.dumps(expr)
 
         output_symbols = [self.new_name() for _ in range(expr.num_outputs)]

mplang/runtime/server.py

@@ -30,7 +30,7 @@ from fastapi import (
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
-from mplang.core.mpir import Reader
+from mplang.core.mpir import IrReader
 from mplang.core.table import TableType
 from mplang.core.tensor import TensorType
 from mplang.kernels.base import KernelContext
@@ -310,7 +310,7 @@ def create_and_execute_computation(
             f"Invalid base64 or protobuf for mpprogram: {e!s}"
         ) from e
 
-    reader = Reader()
+    reader = IrReader()
     expr = reader.loads(graph_proto)
 
     if expr is None:

mplang/runtime/simulation.py

@@ -30,7 +30,7 @@ from mplang.core.expr.ast import Expr
 from mplang.core.expr.evaluator import IEvaluator, create_evaluator
 from mplang.core.interp import InterpContext, InterpVar
 from mplang.core.mask import Mask
-from mplang.core.mpir import Reader, Writer
+from mplang.core.mpir import IrReader, IrWriter
 from mplang.core.mpobject import MPObject
 from mplang.core.mptype import MPType, TensorLike
 from mplang.core.pfunc import PFunction  # for spu.seed_env kernel seeding
@@ -187,10 +187,10 @@ class Simulator(InterpContext):
         This exposes potential MPIR serialization bugs by forcing expressions
         to go through the full serialize->deserialize cycle.
         """
-        writer = Writer()
+        writer = IrWriter()
         graph_proto = writer.dumps(expr)
 
-        reader = Reader()
+        reader = IrReader()
         deserialized_expr = reader.loads(graph_proto)
 
         if deserialized_expr is None:

mplang/simp/__init__.py

@@ -11,341 +11,3 @@
 # 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
-
-import importlib
-import pathlib
-import pkgutil
-from collections.abc import Callable
-from functools import partial, wraps
-from types import ModuleType
-from typing import Any
-
-from mplang.core.mask import Mask
-from mplang.core.mpobject import MPObject
-from mplang.core.mptype import Rank
-from mplang.core.primitive import (
-    constant,
-    pconv,
-    peval,
-    prand,
-    prank,
-    pshfl,
-    pshfl_s,
-    uniform_cond,
-    while_loop,
-)
-from mplang.ops import ibis_cc, jax_cc
-from mplang.ops.base import FeOperation
-from mplang.simp.mpi import allgather_m, bcast_m, gather_m, p2p, scatter_m
-from mplang.simp.random import key_split, pperm, prandint, ukey, urandint
-from mplang.simp.smpc import reveal, revealTo, seal, sealFrom, srun
-
-# Public exports of the simplified party execution API.
-# NOTE: Replaces previous internal __reexport__ (not a Python convention)
-# to make star-imports explicit and tooling-friendly.
-__all__ = [  # noqa: RUF022
-    "MPObject",
-    "P",
-    "P0",
-    "P1",
-    "P2",
-    "P2P",
-    "Party",
-    "allgather_m",
-    "bcast_m",
-    "constant",
-    "gather_m",
-    "key_split",
-    "load_module",
-    "p2p",
-    "pconv",
-    "peval",
-    "pperm",
-    "prand",
-    "prandint",
-    "prank",
-    "pshfl",
-    "pshfl_s",
-    "reveal",
-    "revealTo",
-    "run",
-    "runAt",
-    "scatter_m",
-    "seal",
-    "sealFrom",
-    "srun",
-    "ukey",
-    "uniform_cond",
-    "urandint",
-    "while_loop",
-]
-
-
-def run_impl(
-    pmask: Mask | None,
-    func: Callable,
-    *args: Any,
-    **kwargs: Any,
-) -> Any:
-    """
-    Run a function that can be evaluated by the mplang system.
-
-    This function provides a dispatch mechanism based on the first argument
-    to route different function types to appropriate handlers.
-
-    Args:
-        pmask: The party mask of this function, None indicates auto deduce parties from args.
-        func: The function to be dispatched and executed
-        *args: Positional arguments to pass to the function
-        **kwargs: Keyword arguments to pass to the function
-
-    Returns:
-        The result of evaluating the function through the appropriate handler
-
-    Raises:
-        ValueError: If basic.write is called without required arguments
-        TypeError: If the function compilation or evaluation fails
-        RuntimeError: If the underlying peval execution encounters errors
-
-    Examples:
-        Reading data from a file:
-
-        >>> tensor_info = TensorType(shape=(10, 10), dtype=np.float32)
-        >>> attrs = {"format": "binary"}
-        >>> result = run_impl(basic.read, "data/input.bin", tensor_info, attrs)
-
-        Writing data to a file:
-
-        >>> run_impl(basic.write, data, "data/output.bin")
-
-        Running a JAX function:
-
-        >>> def matrix_multiply(a, b):
-        ...     return jnp.dot(a, b)
-        >>> result = run_impl(matrix_multiply, mat_a, mat_b)
-
-        Running a custom computation function:
-
-        >>> def compute_statistics(data):
-        ...     mean = jnp.mean(data)
-        ...     std = jnp.std(data)
-        ...     return {"mean": mean, "std": std}
-        >>> stats = run_impl(compute_statistics, dataset)
-    """
-
-    if isinstance(func, FeOperation):
-        pfunc, eval_args, out_tree = func(*args, **kwargs)
-    else:
-        if ibis_cc.is_ibis_function(func):
-            pfunc, eval_args, out_tree = ibis_cc.run_ibis(func, *args, **kwargs)
-        else:
-            # unknown python callable, treat it as jax function
-            pfunc, eval_args, out_tree = jax_cc.run_jax(func, *args, **kwargs)
-    results = peval(pfunc, eval_args, pmask)
-    return out_tree.unflatten(results)
-
-
-# run :: (a -> a) -> m a -> m a
-def run(pyfn: Callable) -> Callable:
-    return partial(run_impl, None, pyfn)
-
-
-# runAt :: Rank -> (a -> a) -> m a -> m a
-def runAt(rank: Rank, pyfn: Callable) -> Callable:
-    pmask = Mask.from_ranks(rank)
-    return partial(run_impl, pmask, pyfn)
-
-
-def P2P(src: Party, dst: Party, value: Any) -> Any:
-    """Point-to-point transfer using Party objects instead of raw ranks.
-
-    Equivalent to ``p2p(src.rank, dst.rank, value)`` but improves readability
-    and reduces magic numbers in user code / tutorials.
-
-    Parameters
-    ----------
-    src : Party
-        Source party object.
-    dst : Party
-        Destination party object.
-    value : Any
-        Value to transfer.
-
-    Returns
-    -------
-    Any
-        The same value representation at destination context (as defined by
-        underlying ``p2p`` primitive semantics).
-    """
-    if not isinstance(src, Party) or not isinstance(dst, Party):  # defensive
-        raise TypeError("P2P expects Party objects, e.g. P2P(P0, P2, value)")
-    return p2p(src.rank, dst.rank, value)
-
-
-"""Party-scoped module registration & dispatch.
-
-This module provides a light-weight mechanism to expose *module-like* groups
-of callable operations bound to a specific party (rank) via attribute access:
-
-    load_module("mplang.ops.crypto", alias="crypto")
-    P0.crypto.encrypt(x)  # executes encrypt() with pmask = {rank 0}
-
-Core concepts:
-* Registry (``_NAMESPACE_REGISTRY``): maps alias -> importable module path.
-* Lazy import: underlying module is imported on first attribute access.
-* Wrapping: fetched callables are wrapped so that invocation automatically
-    routes through ``run_impl`` with that party's mask.
-
-Only *callable* attributes are exposed; non-callable attributes raise
-``AttributeError`` to avoid surprising divergent local vs. distributed
-semantics.
-
-The public API surface intentionally stays small (`Party`, `P`, `run`,
-`runAt`, and `load_module`). Internal details (proxy class / registry) are
-not part of the stability guarantee.
-"""
-
-_NAMESPACE_REGISTRY: dict[str, str] = {}
-
-
-class _PartyModuleProxy:
-    """Lazy module proxy bound to a specific party.
-
-    Attribute access resolves a callable inside the registered module and
-    returns a wrapped function that executes with the party's mask.
-    Non-callable attributes are rejected explicitly to keep semantics clear.
-    """
-
-    def __init__(self, party: Party, name: str):
-        self._party: Party = party
-        self._name: str = name
-        self._module: ModuleType | None = None  # loaded lazily
-
-    def _ensure(self) -> None:
-        if self._module is None:
-            self._module = importlib.import_module(_NAMESPACE_REGISTRY[self._name])
-
-    def __getattr__(self, item: str) -> Callable[..., Any]:
-        self._ensure()
-        target = getattr(self._module, item)
-        if not callable(target):
-            raise AttributeError(
-                f"Attribute '{item}' of party module '{self._name}' is not callable (got {type(target).__name__})"
-            )
-
-        @wraps(target)
-        def _wrapped(*args: Any, **kw: Any) -> Any:
-            # Inline runAt to reduce an extra partial layer while preserving semantics.
-            return run_impl(Mask.from_ranks(self._party.rank), target, *args, **kw)
-
-        # Provide a party-qualified name for debugging / logs without losing original metadata.
-        base_name = getattr(target, "__name__", None)
-        if base_name is None:
-            # Frontend FeOperation or object without __name__; try .name attribute (FeOperation contract) or fallback to repr
-            base_name = getattr(target, "name", None) or type(target).__name__
-        try:
-            _wrapped.__name__ = f"{base_name}@P{self._party.rank}"
-        except Exception:  # pragma: no cover - assignment may fail for exotic wrappers
-            pass
-        return _wrapped
-
-
-class Party:
-    def __init__(self, rank: int) -> None:
-        self.rank: int = int(rank)
-
-    def __repr__(self) -> str:  # pragma: no cover
-        return f"Party(rank={self.rank})"
-
-    def __call__(self, fn: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
-        if not callable(fn):
-            raise TypeError(
-                f"First argument to Party({self.rank}) must be callable, got {fn!r}"
-            )
-        return runAt(self.rank, fn)(*args, **kwargs)
-
-    def __getattr__(self, name: str) -> _PartyModuleProxy:
-        if name in _NAMESPACE_REGISTRY:
-            return _PartyModuleProxy(self, name)
-        raise AttributeError(
-            f"Party has no attribute '{name}'. Registered: {list(_NAMESPACE_REGISTRY)}"
-        )
-
-
-class _PartyIndex:
-    def __getitem__(self, rank: int) -> Party:
-        return Party(rank)
-
-
-def _load_prelude_modules() -> None:
-    """Auto-register public frontend submodules for party namespace access.
-
-    Implementation detail: we treat every non-underscore immediate child of
-    ``mplang.ops`` as public and make it available as ``P0.<name>``.
-    This keeps user ergonomics high (no manual load_module calls for core
-    frontends) but slightly increases implicit surface area. If this grows
-    unwieldy we can switch to an allowlist.
-    """
-    try:
-        import mplang.ops as _fe  # type: ignore
-    except (ImportError, ModuleNotFoundError):  # pragma: no cover
-        # Frontend package not present (minimal install); safe to skip.
-        return
-
-    pkg_path = pathlib.Path(_fe.__file__).parent
-    for m in pkgutil.iter_modules([str(pkg_path)]):
-        if m.name.startswith("_"):
-            continue
-        if m.name not in _NAMESPACE_REGISTRY:
-            _NAMESPACE_REGISTRY[m.name] = f"mplang.ops.{m.name}"
-
-
-def load_module(module: str, alias: str | None = None) -> None:
-    """Register a module for party-scoped (per-rank) callable access.
-
-    After registration, each party object (e.g. ``P0``) can access callable
-    attributes of the target module through the chosen alias and have them
-    executed under that party's mask automatically. Non-callable attributes
-    are intentionally not exposed to avoid ambiguity between local data and
-    distributed execution semantics.
-
-    Parameters
-    ----------
-    module : str
-        The fully-qualified import path of the module to expose. It must be
-        importable via ``importlib.import_module``.
-    alias : str | None, optional
-        The short name used as an attribute on ``Party``/``P0``/``P1``/... .
-        If omitted, the last path segment of ``module`` is used.
-
-    Raises
-    ------
-    ValueError
-        If the alias is already registered to a *different* module path.
-
-    Notes
-    -----
-    Registration is idempotent when the alias maps to the same module. The
-    actual module object is imported lazily on first attribute access, so
-    calling ``load_module`` has negligible upfront cost.
-
-    Examples
-    --------
-    >>> load_module("mplang.ops.crypto", alias="crypto")
-    >>> # Now call an op on party 0
-    >>> P0.crypto.encrypt(data)
-    """
-    if alias is None:
-        alias = module.rsplit(".", 1)[-1]
-    prev = _NAMESPACE_REGISTRY.get(alias)
-    if prev and prev != module:
-        raise ValueError(f"Alias '{alias}' already registered for '{prev}'")
-    _NAMESPACE_REGISTRY[alias] = module
-
-
-P = _PartyIndex()
-P0, P1, P2 = Party(0), Party(1), Party(2)
-
-_load_prelude_modules()

mplang/simp/api.py

@@ -0,0 +1,96 @@
+# Copyright 2025 Ant Group Co., 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 collections.abc import Callable
+from typing import Any
+
+from mplang.core.mpobject import MPObject
+from mplang.core.mptype import Rank
+from mplang.core.primitive import run, run_at
+from mplang.ops import ibis_cc, jax_cc, sql_cc
+
+
+def run_jax(jax_fn: Callable, *args: Any, **kwargs: Any) -> Any:
+    """Run a JAX function.
+
+    Args:
+        jax_fn: The JAX function to be executed.
+        *args: Positional arguments to pass to the JAX function.
+        **kwargs: Keyword arguments to pass to the JAX function.
+
+    Returns:
+        The result of evaluating the JAX function through the mplang system.
+
+    Raises:
+        TypeError: If the function compilation or evaluation fails.
+        RuntimeError: If the underlying peval execution encounters errors.
+
+    Notes:
+        Argument binding semantics with respect to JAX static arguments:
+
+        - If an argument (or any leaf within a PyTree argument) is an
+          :class:`~mplang.core.mpobject.MPObject`, it is captured as a runtime
+          variable (dynamic value) in the traced program and is not treated as a
+          JAX static argument.
+        - If an argument contains no :class:`MPObject` leaves, it is treated as a
+          constant configuration with respect to JAX; effectively it behaves
+          like a static argument and may contribute to JAX compilation cache
+          keys (similar to ``static_argnums`` semantics). Changing such constant
+          arguments can lead to different compiled variants/cached entries.
+
+    Examples:
+        Defining and running a simple JAX function:
+
+        >>> import jax.numpy as jnp
+        >>> def add_matrices(a, b):
+        ...     return jnp.add(a, b)
+        >>> result = run_jax(add_matrices, matrix_a, matrix_b)
+
+        Running a more complex JAX function:
+
+        >>> def compute_statistics(data):
+        ...     mean = jnp.mean(data)
+        ...     std = jnp.std(data)
+        ...     return {"mean": mean, "std": std}
+        >>> stats = run_jax(compute_statistics, dataset)
+    """
+    return run(None, jax_cc.run_jax, jax_fn, *args, **kwargs)
+
+
+def run_jax_at(rank: Rank, jax_fn: Callable, *args: Any, **kwargs: Any) -> Any:
+    return run_at(rank, jax_cc.run_jax, jax_fn, *args, **kwargs)
+
+
+def run_ibis(ibis_expr: Any, *args: Any, **kwargs: Any) -> Any:
+    # TODO(jint): add docstring, add type hints, describe args and kwargs constraints.
+    return run(None, ibis_cc.run_ibis, ibis_expr, *args, **kwargs)
+
+
+def run_ibis_at(rank: Rank, ibis_fn: Any, *args: Any, **kwargs: Any) -> Any:
+    return run_at(rank, ibis_cc.run_ibis, ibis_fn, *args, **kwargs)
+
+
+def run_sql(
+    query: str, out_type: Any, in_tables: dict[str, MPObject] | None = None
+) -> Any:
+    # TODO(jint): add docstring, drop out_type.
+    return run(None, sql_cc.run_sql, query, out_type, in_tables)
+
+
+def run_sql_at(
+    rank: Rank, query: str, out_type: Any, in_tables: dict[str, MPObject] | None = None
+) -> Any:
+    return run_at(rank, sql_cc.run_sql, query, out_type, in_tables)

mplang/simp/party.py

@@ -0,0 +1,225 @@
+# Copyright 2025 Ant Group Co., 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
+
+import importlib
+import pathlib
+import pkgutil
+from collections.abc import Callable
+from functools import wraps
+from types import ModuleType
+from typing import Any
+
+from mplang.ops.base import FeOperation
+from mplang.simp.api import run_at, run_jax_at
+from mplang.simp.mpi import p2p
+
+
+def P2P(src: Party, dst: Party, value: Any) -> Any:
+    """Point-to-point transfer using Party objects instead of raw ranks.
+
+    Equivalent to ``p2p(src.rank, dst.rank, value)`` but improves readability
+    and reduces magic numbers in user code / tutorials.
+
+    Parameters
+    ----------
+    src : Party
+        Source party object.
+    dst : Party
+        Destination party object.
+    value : Any
+        Value to transfer.
+
+    Returns
+    -------
+    Any
+        The same value representation at destination context (as defined by
+        underlying ``p2p`` primitive semantics).
+    """
+    if not isinstance(src, Party) or not isinstance(dst, Party):  # defensive
+        raise TypeError("P2P expects Party objects, e.g. P2P(P0, P2, value)")
+    return p2p(src.rank, dst.rank, value)
+
+
+"""Party-scoped module registration & dispatch.
+
+This module provides a light-weight mechanism to expose *module-like* groups
+of callable operations bound to a specific party (rank) via attribute access:
+
+    load_module("mplang.ops.crypto", alias="crypto")
+    P0.crypto.encrypt(x)  # executes encrypt() with pmask = {rank 0}
+
+Core concepts:
+* Registry (``_NAMESPACE_REGISTRY``): maps alias -> importable module path.
+* Lazy import: underlying module is imported on first attribute access.
+* Wrapping: fetched callables are wrapped so that invocation automatically
+    routes through ``run_impl`` with that party's mask.
+
+Only *callable* attributes are exposed; non-callable attributes raise
+``AttributeError`` to avoid surprising divergent local vs. distributed
+semantics.
+
+The public API surface intentionally stays small (`Party`, `P`, `run`,
+`runAt`, and `load_module`). Internal details (proxy class / registry) are
+not part of the stability guarantee.
+"""
+
+_NAMESPACE_REGISTRY: dict[str, str] = {}
+
+
+class _PartyModuleProxy:
+    """Lazy module proxy bound to a specific party.
+
+    Attribute access resolves a callable inside the registered module and
+    returns a wrapped function that executes with the party's mask.
+    Non-callable attributes are rejected explicitly to keep semantics clear.
+    """
+
+    def __init__(self, party: Party, name: str):
+        self._party: Party = party
+        self._name: str = name
+        self._module: ModuleType | None = None  # loaded lazily
+
+    def _ensure(self) -> None:
+        if self._module is None:
+            self._module = importlib.import_module(_NAMESPACE_REGISTRY[self._name])
+
+    def __getattr__(self, item: str) -> Callable[..., Any]:
+        self._ensure()
+        op = getattr(self._module, item)
+        if not callable(op):
+            raise AttributeError(
+                f"Attribute '{item}' of party module '{self._name}' is not callable (got {type(op).__name__})"
+            )
+
+        @wraps(op)
+        def _wrapped(*args: Any, **kw: Any) -> Any:
+            # Inline runAt to reduce an extra partial layer while preserving semantics.
+            return run_at(self._party.rank, op, *args, **kw)
+
+        # Provide a party-qualified name for debugging / logs without losing original metadata.
+        base_name = getattr(op, "__name__", None)
+        if base_name is None:
+            # Frontend FeOperation or object without __name__; try .name attribute (FeOperation contract) or fallback to repr
+            base_name = getattr(op, "name", None) or type(op).__name__
+        try:
+            _wrapped.__name__ = f"{base_name}@P{self._party.rank}"
+        except Exception:  # pragma: no cover - assignment may fail for exotic wrappers
+            pass
+        return _wrapped
+
+
+class Party:
+    def __init__(self, rank: int) -> None:
+        self.rank: int = int(rank)
+
+    def __repr__(self) -> str:  # pragma: no cover
+        return f"Party(rank={self.rank})"
+
+    def __call__(self, fn: Callable[..., Any], *args: Any, **kwargs: Any) -> Any:
+        if not callable(fn):
+            raise TypeError(
+                f"First argument to Party({self.rank}) must be callable, got {fn!r}"
+            )
+        # Use run_op_at for FeOperation, run_jax_at for plain callables
+        if isinstance(fn, FeOperation):
+            return run_at(self.rank, fn, *args, **kwargs)
+        else:
+            # TODO(jint): implicitly assume non-FeOperation as JAX function is a bit too magical?
+            return run_jax_at(self.rank, fn, *args, **kwargs)
+
+    def __getattr__(self, name: str) -> _PartyModuleProxy:
+        if name in _NAMESPACE_REGISTRY:
+            return _PartyModuleProxy(self, name)
+        raise AttributeError(
+            f"Party has no attribute '{name}'. Registered: {list(_NAMESPACE_REGISTRY)}"
+        )
+
+
+class _PartyIndex:
+    def __getitem__(self, rank: int) -> Party:
+        return Party(rank)
+
+
+def _load_prelude_modules() -> None:
+    """Auto-register public frontend submodules for party namespace access.
+
+    Implementation detail: we treat every non-underscore immediate child of
+    ``mplang.ops`` as public and make it available as ``P0.<name>``.
+    This keeps user ergonomics high (no manual load_module calls for core
+    frontends) but slightly increases implicit surface area. If this grows
+    unwieldy we can switch to an allowlist.
+    """
+    try:
+        import mplang.ops as _fe  # type: ignore
+    except (ImportError, ModuleNotFoundError):  # pragma: no cover
+        # Frontend package not present (minimal install); safe to skip.
+        return
+
+    pkg_path = pathlib.Path(_fe.__file__).parent
+    for m in pkgutil.iter_modules([str(pkg_path)]):
+        if m.name.startswith("_"):
+            continue
+        if m.name not in _NAMESPACE_REGISTRY:
+            _NAMESPACE_REGISTRY[m.name] = f"mplang.ops.{m.name}"
+
+
+def load_module(module: str, alias: str | None = None) -> None:
+    """Register a module for party-scoped (per-rank) callable access.
+
+    After registration, each party object (e.g. ``P0``) can access callable
+    attributes of the target module through the chosen alias and have them
+    executed under that party's mask automatically. Non-callable attributes
+    are intentionally not exposed to avoid ambiguity between local data and
+    distributed execution semantics.
+
+    Parameters
+    ----------
+    module : str
+        The fully-qualified import path of the module to expose. It must be
+        importable via ``importlib.import_module``.
+    alias : str | None, optional
+        The short name used as an attribute on ``Party``/``P0``/``P1``/... .
+        If omitted, the last path segment of ``module`` is used.
+
+    Raises
+    ------
+    ValueError
+        If the alias is already registered to a *different* module path.
+
+    Notes
+    -----
+    Registration is idempotent when the alias maps to the same module. The
+    actual module object is imported lazily on first attribute access, so
+    calling ``load_module`` has negligible upfront cost.
+
+    Examples
+    --------
+    >>> load_module("mplang.ops.crypto", alias="crypto")
+    >>> # Now call an op on party 0
+    >>> P0.crypto.encrypt(data)
+    """
+    if alias is None:
+        alias = module.rsplit(".", 1)[-1]
+    prev = _NAMESPACE_REGISTRY.get(alias)
+    if prev and prev != module:
+        raise ValueError(f"Alias '{alias}' already registered for '{prev}'")
+    _NAMESPACE_REGISTRY[alias] = module
+
+
+P = _PartyIndex()
+P0, P1, P2 = Party(0), Party(1), Party(2)
+
+_load_prelude_modules()

mplang/simp/random.py

@@ -22,8 +22,8 @@ import jax.random as jr
 from jax.typing import ArrayLike
 
 import mplang.core.primitive as prim
-from mplang import simp
 from mplang.core import MPObject, Shape
+from mplang.simp.api import run_jax
 
 
 @prim.function
@@ -32,12 +32,12 @@ def key_split(key: MPObject) -> tuple[MPObject, MPObject]:
 
     def kernel(key: jax.Array) -> tuple[jax.Array, jax.Array]:
         # TODO: since MPObject tensor does not implement slicing yet.
-        # subkey, key = simp.run(jr.split)(key) does not work.
+        # subkey, key = run_jax(jr.split, key) does not work.
         # we workaround it by splitting inside tracer.
         subkey, key = jr.split(key)
         return subkey, key
 
-    return simp.run(kernel)(key)  # type: ignore[no-any-return]
+    return run_jax(kernel, key)  # type: ignore[no-any-return]
 
 
 @prim.function
@@ -49,7 +49,7 @@ def ukey(seed: int | ArrayLike) -> MPObject:
         # Note: key.dtype is jax._src.prng.KeyTy, which could not be handled by MPObject.
         return jax.random.key_data(key)
 
-    return simp.run(kernel)()  # type: ignore[no-any-return]
+    return run_jax(kernel)  # type: ignore[no-any-return]
 
 
 @prim.function
@@ -61,7 +61,7 @@ def urandint(
 ) -> MPObject:
     """Party uniformly generate a random integer in the range [low, high) with the given shape."""
 
-    return simp.run(partial(jr.randint, minval=low, maxval=high, shape=shape))(key)  # type: ignore[no-any-return]
+    return run_jax(partial(jr.randint, minval=low, maxval=high, shape=shape), key)  # type: ignore[no-any-return]
 
 
 # Private(different per-party) related functions begin.
@@ -81,7 +81,7 @@ def prandint(low: int, high: int, shape: Shape = ()) -> MPObject:
         return result
 
     rand_u64 = prim.prand(shape)
-    return simp.run(kernel)(rand_u64)  # type: ignore[no-any-return]
+    return run_jax(kernel, rand_u64)  # type: ignore[no-any-return]
 
 
 @prim.function
@@ -116,6 +116,6 @@ def pperm(key: MPObject) -> MPObject:
     def kernel(key: jax.Array) -> jax.Array:
         return jr.permutation(key, size)
 
-    perm = simp.run(kernel)(key)
+    perm = run_jax(kernel, key)
     rank = prim.prank()
-    return simp.run(lambda perm, rank: perm[rank])(perm, rank)  # type: ignore[no-any-return]
+    return run_jax(lambda perm, rank: perm[rank], perm, rank)  # type: ignore[no-any-return]

{mplang_nightly-0.1.dev172.dist-info → mplang_nightly-0.1.dev174.dist-info}/METADATA

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

{mplang_nightly-0.1.dev172.dist-info → mplang_nightly-0.1.dev174.dist-info}/RECORD

@@ -1,20 +1,20 @@
-mplang/__init__.py,sha256=tZmMm5LXY5QXKDvyYw1ysSStRky8CHelPQ9T0qgmfGs,1853
-mplang/device.py,sha256=b9H1I-MFtL7hvJ38xoq65QdH1vGgPl9fNLQ-IwZWRvE,12479
+mplang/__init__.py,sha256=K5N0yTkRr4uJDCUSD2IXfMSCE81a-Pm-mx07hJ_6QrA,3182
+mplang/device.py,sha256=BWCFgWbhgnuzyt1thopgsBUy75sJDe9s-WgM29gxZqY,12420
 mplang/host.py,sha256=ssmv0_CyZPFORhOUJ84Jo6NwRJSK7_Ono3n7ZjEg4sA,3058
 mplang/analysis/__init__.py,sha256=CTHFvRsi-nFngojqjn08UaR3RY9i7CJ7T2UdR95kCrk,1056
-mplang/analysis/diagram.py,sha256=ffwgD12gL1_KH1uJ_EYkjmIlDrfxYJJkWj-wHl09_Xk,19520
-mplang/core/__init__.py,sha256=lWxlEKfRwX7FNDzgyKZ1fiDMaCiqkyg0j5mKlZD_v7g,2244
+mplang/analysis/diagram.py,sha256=JUJEe6HnR-V8yVrV49VSy2Hbpyvy-i8EbggVlmpJTNw,19524
+mplang/core/__init__.py,sha256=fXTmdyeAeWNmAVWeKmRXWnoz2n3ucoNpSQh_OylXBRA,2353
 mplang/core/cluster.py,sha256=uARPlcWL0ddrWyOZ7vcX6JYN7a72mqbz2XGI1rSfkjE,11625
 mplang/core/comm.py,sha256=MByyu3etlQh_TkP1vKCFLIAPPuJOpl9Kjs6hOj6m4Yc,8843
 mplang/core/context_mgr.py,sha256=R0QJAod-1nYduVoOknLfAsxZiy-RtmuQcp-07HABYZU,1541
 mplang/core/dtype.py,sha256=0rZqFaFikFu9RxtdO36JLEgFL-E-lo3hH10whwkTVVY,10213
 mplang/core/interp.py,sha256=JKjKJGWURU5rlHQ2yG5XNKWzN6hLZsmo--hZuveQgxI,5915
 mplang/core/mask.py,sha256=14DFxaA446lGjN4dzTuQgm9Shcn34rYI87YJHg0YGNQ,10693
-mplang/core/mpir.py,sha256=3NyHa1cDnUaw3XWIUgyOMXfZ9JS-30COb29AoXYcRtM,38251
+mplang/core/mpir.py,sha256=01AOZgu8fcoEA9TDKCDnFW03AmSIhsFJGHPMmf-gZt0,38259
 mplang/core/mpobject.py,sha256=0pHSd7SrAFTScCFcB9ziDztElYQn-oIZOKBx47B3QX0,3732
 mplang/core/mptype.py,sha256=7Cp2e58uUX-uqTp6QxuioOMJ8BzLBPXlWG5rRakv2uo,13773
 mplang/core/pfunc.py,sha256=WOGmMr4HCUELED5QxYbhhyQJRDXrA5Bk3tPbZWpwmw8,5102
-mplang/core/primitive.py,sha256=vu60-k0fSAWWidcWDC0_FGvrRZww12oGXjB8CR9F6Yo,43889
+mplang/core/primitive.py,sha256=cuQYNK80pNcWuwGOt-djX_p93RKk9tztWexxndpTzuA,44113
 mplang/core/table.py,sha256=BqTBZn7Tfwce4vzl3XYhaX5hVmKagVq9-YoERDta6d8,5892
 mplang/core/tensor.py,sha256=86u6DogSZMoL0w5XjtTmQm2PhA_VjwybN1b6U4Zzphg,2361
 mplang/core/tracer.py,sha256=dVMfUeCMmPz4o6tLXewGMW1Kpy5gpZORvr9w4MhwDtM,14288
@@ -49,7 +49,6 @@ mplang/ops/sql_cc.py,sha256=-9uf75gOxLQlFiKjDm75qIx8Gbun7unvkOxezdSLGlE,2112
 mplang/ops/tee.py,sha256=bOpS_BXG12D6bONikzdF2yt0oVZj9Jyd0g_3IXP8VgE,1281
 mplang/protos/v1alpha1/mpir_pb2.py,sha256=Bros37t-4LMJbuUYVSM65rImUYTtZDhNTIADGbZCKp0,7522
 mplang/protos/v1alpha1/mpir_pb2.pyi,sha256=dLxAtFW7mgFR-HYxC4ExI4jbtEWUGTKBvcKhI3BJ8m0,20972
-mplang/protos/v1alpha1/mpir_pb2_grpc.py,sha256=xYOs94SXiNYAlFodACnsXW5QovLsHY5tCk3p76RH5Zc,158
 mplang/protos/v1alpha1/value_pb2.py,sha256=V9fqQTqXNo2efYmlP9xOhC7EpjBUp5jL-05yrJsAvWU,2785
 mplang/protos/v1alpha1/value_pb2.pyi,sha256=47GVvuZfiV5oaVemwh0xTfns8OYTVBT8YnluIQeQPbs,7108
 mplang/runtime/__init__.py,sha256=IRPP3TtpFC4iSt7_uaq-S4dL7CwrXL0XBMeaBoEYLlg,948
@@ -57,24 +56,26 @@ mplang/runtime/cli.py,sha256=WehDodeVB4AukSWx1LJxxtKUqGmLPY4qjayrPlOg3bE,14438
 mplang/runtime/client.py,sha256=v73cFnwN7ePaGJmPi20waizeIq6dlJTjEs6OkybSR2M,15858
 mplang/runtime/communicator.py,sha256=P5nl3wxRomUafoAj-1FSgD7phelof399deitVB1JMos,3508
 mplang/runtime/data_providers.py,sha256=GX10_nch8PmEyok32mSC4p5rDowvmXrJ-4J5-LvY6ig,8206
-mplang/runtime/driver.py,sha256=Elo6zx66kvpNW7OwYr-gcb-RJDhcnCbPFQWyBcYM0Uk,11745
+mplang/runtime/driver.py,sha256=c7c4ULmMln5GwkK17cPyc-45XrQbprwSt7HnEaIQfcc,11725
 mplang/runtime/exceptions.py,sha256=c18U0xK20dRmgZo0ogTf5vXlkix9y3VAFuzkHxaXPEk,981
 mplang/runtime/http_api.md,sha256=-re1DhEqMplAkv_wnqEU-PSs8tTzf4-Ml0Gq0f3Go6s,4883
 mplang/runtime/link_comm.py,sha256=ZHNcis8QDu2rcyyF3rhpxMiJDkczoMA_c0iZ2GDW_bA,2793
-mplang/runtime/server.py,sha256=CdmBmpbylEl7XeZj26i0rUmTrPTvl2CVdRgbtR02gcg,16543
+mplang/runtime/server.py,sha256=N2R_8KIi_eC5H0gEWEmGOrBW0MWMVFurJKeCxsADcSg,16547
 mplang/runtime/session.py,sha256=I2711V-pPRCYibNgBhjboUURdubnL6ltCoh5RvFVabs,10641
-mplang/runtime/simulation.py,sha256=1I_8dIqxivxtYnQK0ofz0oXk3lXXh3-zN0lmNFnWucA,11615
-mplang/simp/__init__.py,sha256=_X1kpq9qhoPUL2gQRVNkSjS5jNSxYRu7-_1GSwJ9PK8,11575
+mplang/runtime/simulation.py,sha256=wz47a1sskgBlt_xVPvZn7vO9-XGJ94CK5muxPZoZaRk,11623
+mplang/simp/__init__.py,sha256=2WE4cmW96Xkzyq2yRRYNww4kZ5o6u6NbPV0BxqZG698,581
+mplang/simp/api.py,sha256=apxrfPbAqtUGUT-C6GMwJDg32KHSkMb9aaxjeUqVksw,3613
 mplang/simp/mpi.py,sha256=Wv_Q16TQ3rdLam6OzqXiefIGSMmagGkso09ycyOkHEs,4774
-mplang/simp/random.py,sha256=7PVgWNL1j7Sf3MqT5PRiWplUu-0dyhF3Ub566iqX86M,3898
+mplang/simp/party.py,sha256=jl-_K4CNj9lA9ZW5hgmoxvqtliXcL3PLWRdu3C7i4fo,8211
+mplang/simp/random.py,sha256=2pCYYZKRbpTLaMWJMj6UxtOR6EsI2Et4trSgiFD4At0,3901
 mplang/simp/smpc.py,sha256=tdH54aU4T-GIDPhpmf9NCeJC0G67PdOYc04cyUkOnwE,7119
 mplang/utils/__init__.py,sha256=2WE4cmW96Xkzyq2yRRYNww4kZ5o6u6NbPV0BxqZG698,581
 mplang/utils/crypto.py,sha256=rvPomBFtznRHc3RPi6Aip9lsU8zW2oxBqGv1K3vn7Rs,1052
 mplang/utils/func_utils.py,sha256=vCJcZmu0bEbqhOQKdpttV2_MBllIcPSN0b8U4WjNGGo,5164
 mplang/utils/spu_utils.py,sha256=S3L9RBkBe2AvSuMSQQ12cBY5Y1NPthubvErSX_7nj1A,4158
 mplang/utils/table_utils.py,sha256=aC-IZOKkSmFkpr3NZchLM0Wt0GOn-rg_xHBHREWBwAU,2202
-mplang_nightly-0.1.dev172.dist-info/METADATA,sha256=hjAMloWrHmrUgIZhcHEO268e1Nn2r4Kg52MXkhl927s,16547
-mplang_nightly-0.1.dev172.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mplang_nightly-0.1.dev172.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev172.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev172.dist-info/RECORD,,
+mplang_nightly-0.1.dev174.dist-info/METADATA,sha256=l5YgCuDdKf-x_geEWMkuTSKVmBclYfN2UD5atDj7EM4,16547
+mplang_nightly-0.1.dev174.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mplang_nightly-0.1.dev174.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev174.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev174.dist-info/RECORD,,

mplang/protos/v1alpha1/mpir_pb2_grpc.py

@@ -1,3 +0,0 @@
-# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
-"""Client and server classes corresponding to protobuf-defined services."""
-import grpc