mplang-nightly 0.1.dev142__py3-none-any.whl → 0.1.dev144__py3-none-any.whl

mplang/backend/spu.py

@@ -186,16 +186,18 @@ def _spu_reconstruct(pfunc: PFunction, *args: Any) -> Any:
     return reconstructed
 
 
-@kernel_def("mlir.pphlo")
+@kernel_def("spu.run_pphlo")
 def _spu_run_mlir(pfunc: PFunction, *args: Any) -> Any:
-    """Execute compiled SPU function (mlir.pphlo) and return SpuValue outputs.
+    """Execute compiled SPU function (spu.run_pphlo) and return SpuValue outputs.
 
     Participation rule: a rank participates iff its entry in the stored
     link_ctx list is non-None. This allows us to allocate a world-sized list
     (indexed by global rank) and simply assign None for non-SPU parties.
     """
-    if pfunc.fn_type != "mlir.pphlo":
-        raise ValueError(f"Unsupported format: {pfunc.fn_type}. Expected 'mlir.pphlo'")
+    if pfunc.fn_type != "spu.run_pphlo":
+        raise ValueError(
+            f"Unsupported format: {pfunc.fn_type}. Expected 'spu.run_pphlo'"
+        )
 
     cfg, _ = _get_spu_config_and_world()
     pocket = _get_spu_pocket()

mplang/backend/sql_duckdb.py

@@ -20,7 +20,7 @@ from mplang.backend.base import kernel_def
 from mplang.core.pfunc import PFunction
 
 
-@kernel_def("sql[duckdb]")
+@kernel_def("duckdb.run_sql")
 def _duckdb_sql(pfunc: PFunction, *args: Any) -> Any:
     import duckdb
     import pandas as pd

mplang/core/expr/evaluator.py

@@ -27,7 +27,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Protocol
 
-from mplang.backend.base import BackendRuntime
+from mplang.backend.context import RuntimeContext
 from mplang.core.comm import ICommunicator
 from mplang.core.expr.ast import (
     AccessExpr,
@@ -56,7 +56,7 @@ class IEvaluator(Protocol):
     backend state via evaluator.runtime.run_kernel(...).
     """
 
-    runtime: BackendRuntime
+    runtime: RuntimeContext
 
     def evaluate(self, root: Expr, env: dict[str, Any] | None = None) -> list[Any]: ...
 
@@ -72,7 +72,7 @@ class EvalSemantic:
     rank: int
     env: dict[str, Any]
     comm: ICommunicator
-    runtime: BackendRuntime
+    runtime: RuntimeContext
 
     # ------------------------------ Shared helpers (semantics) ------------------------------
     def _should_run(self, rmask: Mask | None, args: list[Any]) -> bool:
@@ -205,7 +205,7 @@ class RecursiveEvaluator(EvalSemantic, ExprVisitor):
         rank: int,
         env: dict[str, Any],
         comm: ICommunicator,
-        runtime: BackendRuntime,
+        runtime: RuntimeContext,
     ) -> None:
         super().__init__(rank, env, comm, runtime)
         self._cache: dict[int, Any] = {}  # Cache based on expr id
@@ -380,7 +380,7 @@ class IterativeEvaluator(EvalSemantic):
         rank: int,
         env: dict[str, Any],
         comm: ICommunicator,
-        runtime: BackendRuntime,
+        runtime: RuntimeContext,
     ) -> None:
         super().__init__(rank, env, comm, runtime)
 
@@ -501,7 +501,7 @@ def create_evaluator(
     rank: int,
     env: dict[str, Any],
     comm: ICommunicator,
-    runtime: BackendRuntime,
+    runtime: RuntimeContext,
     kind: str | None = "iterative",
 ) -> IEvaluator:
     """Factory to create an evaluator engine.

mplang/frontend/base.py

@@ -129,7 +129,7 @@ class FeModule(ABC):
         - You need compilation/stateful behavior/dynamic routing, multiple PFunctions, or complex capture flows.
 
     Tips:
-    - Keep routing information in PFunction.fn_type (e.g., "builtin.read", "sql[duckdb]", "mlir.stablehlo").
+    - Keep routing information in PFunction.fn_type (e.g., "builtin.read", "sql.run", "mlir.stablehlo").
     - Avoid backend-specific logic in kernels; only validate and shape types.
     - Prefer keyword-only attributes in typed_op kernels for clarity (def op(x: MPObject, *, attr: int)).
     """

mplang/frontend/ibis_cc.py

@@ -57,8 +57,9 @@ def ibis2sql(
     outs_info = [_convert(expr.schema())]
 
     sql = ibis.to_sql(expr, dialect="duckdb")
+    # Emit generic sql.run op; runtime maps to backend-specific kernel.
     pfn = PFunction(
-        fn_type="sql[duckdb]",
+        fn_type="sql.run",
         fn_name=fn_name,
         fn_text=sql,
         ins_info=tuple(ins_info),

mplang/frontend/phe.py

@@ -52,10 +52,9 @@ def add(operand1: TensorType, operand2: TensorType) -> TensorType:
 @_PHE_MOD.simple_op()
 def mul(ciphertext: TensorType, plaintext: TensorType) -> TensorType:
     """Multiply a PHE ciphertext with a plaintext value (ciphertext dtype preserved)."""
-    if ciphertext.dtype.is_floating and plaintext.dtype.is_floating:
+    if plaintext.dtype.is_floating:
         raise ValueError(
-            "PHE multiplication does not support float x float operations due to truncation requirements. "
-            "Consider using mixed types (float x int) or integer types instead."
+            "PHE multiplication does not support floating-point plaintext."
         )
     return ciphertext
 
@@ -65,3 +64,141 @@ def decrypt(ciphertext: TensorType, private_key: TensorType) -> TensorType:
     """Decrypt ciphertext using PHE private key: returns plaintext with same semantic type as ciphertext."""
     _ = private_key
     return ciphertext
+
+
+@_PHE_MOD.simple_op()
+def dot(ciphertext: TensorType, plaintext: TensorType) -> TensorType:
+    """Compute dot product of ciphertext with plaintext.
+
+    Args:
+        ciphertext: The ciphertext operand (first argument)
+        plaintext: The plaintext operand (second argument)
+
+    Returns:
+        TensorType: Result tensor type with computed shape following numpy dot product rules
+    """
+    # For dot product, we need to calculate the result shape
+    # This follows numpy dot product rules
+    import numpy as np
+
+    # Create dummy arrays to determine result shape
+    dummy_ct = np.zeros(ciphertext.shape)
+    dummy_pt = np.zeros(plaintext.shape)
+    dummy_result = np.dot(dummy_ct, dummy_pt)
+
+    return TensorType(ciphertext.dtype, dummy_result.shape)
+
+
+@_PHE_MOD.simple_op()
+def gather(ciphertext: TensorType, indices: TensorType, *, axis: int = 0) -> TensorType:
+    """Gather elements from ciphertext using indices.
+
+    Args:
+        ciphertext: The ciphertext to gather from
+        indices: The indices to gather
+        axis: The axis along which to gather (default: 0)
+    """
+    # Calculate result shape based on axis parameter
+    ct_shape = list(ciphertext.shape)
+    indices_shape = list(indices.shape)
+
+    # Normalize negative axis
+    normalized_axis = axis if axis >= 0 else len(ct_shape) + axis
+
+    # Result shape: replace the axis dimension with indices shape
+    result_shape = (
+        ct_shape[:normalized_axis] + indices_shape + ct_shape[normalized_axis + 1 :]
+    )
+    return TensorType(ciphertext.dtype, tuple(result_shape))
+
+
+@_PHE_MOD.simple_op()
+def scatter(
+    ciphertext: TensorType,
+    indices: TensorType,
+    updates: TensorType,
+    *,
+    axis: int = 0,
+) -> TensorType:
+    """Scatter updates into ciphertext at specified indices.
+
+    Args:
+        ciphertext: The ciphertext to scatter into
+        indices: The indices to scatter at
+        updates: The ciphertext updates to scatter
+        axis: The axis along which to scatter (default: 0)
+
+    Returns:
+        TensorType: Result tensor type with same shape and dtype as original ciphertext
+    """
+    return ciphertext
+
+
+@_PHE_MOD.simple_op()
+def concat(operand0: TensorType, operand1: TensorType, *, axis: int = 0) -> TensorType:
+    """Concatenate ciphertext tensors along specified axis.
+
+    Args:
+        operand0: The first ciphertext operand to concatenate
+        operand1: The second ciphertext operand to concatenate
+        axis: Axis along which to concatenate
+
+    Returns:
+        TensorType: Result tensor type with computed shape following numpy concatenation rules
+    """
+    # All operands should have same dtype
+    first_dtype = operand0.dtype
+    if operand1.dtype != first_dtype:
+        raise ValueError("All operands must have the same dtype for concatenation")
+
+    # Calculate result shape using numpy concatenation logic
+    import numpy as np
+
+    dummy_arrays = [np.zeros(operand0.shape), np.zeros(operand1.shape)]
+    dummy_result = np.concatenate(dummy_arrays, axis=axis)
+
+    return TensorType(first_dtype, dummy_result.shape)
+
+
+@_PHE_MOD.simple_op()
+def reshape(ciphertext: TensorType, *, new_shape: tuple[int, ...]) -> TensorType:
+    """Reshape ciphertext to new shape.
+
+    Args:
+        ciphertext: The ciphertext to reshape
+        new_shape: The target shape (can contain -1 for inferred dimension)
+
+    Returns:
+        TensorType: Result tensor type with computed shape following numpy reshape rules
+    """
+    # Calculate the actual result shape (handling -1 inference)
+    import numpy as np
+
+    dummy_array = np.zeros(ciphertext.shape)
+    # use this to check the correctness of new_shape
+    dummy_result = dummy_array.reshape(new_shape)
+    actual_shape = dummy_result.shape
+
+    return TensorType(ciphertext.dtype, actual_shape)
+
+
+@_PHE_MOD.simple_op()
+def transpose(
+    ciphertext: TensorType, *, axes: tuple[int, ...] | None = None
+) -> TensorType:
+    """Transpose ciphertext by permuting axes.
+
+    Args:
+        ciphertext: The ciphertext to transpose
+        axes: Permutation of axes (None for default reverse order)
+
+    Returns:
+        TensorType: Result tensor type with computed shape following numpy transpose rules
+    """
+    # Calculate result shape using numpy transpose logic
+    import numpy as np
+
+    dummy_array = np.zeros(ciphertext.shape)
+    dummy_result = np.transpose(dummy_array, axes)
+
+    return TensorType(ciphertext.dtype, dummy_result.shape)

mplang/frontend/spu.py

@@ -94,9 +94,10 @@ def _compile_jax(
     *args: Any,
     **kwargs: Any,
 ) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    """Compile a JAX function into SPU pphlo MLIR representation."""
+    """Compile a JAX function into SPU pphlo MLIR and wrap as PFunction.
 
-    """Compile a JAX function into SPU pphlo MLIR representation."""
+    Resulting PFunction uses fn_type 'spu.run_pphlo'.
+    """
 
     def is_variable(arg: Any) -> bool:
         return isinstance(arg, MPObject)
@@ -132,7 +133,7 @@ def _compile_jax(
     executable_code = executable_code.decode("utf-8")
 
     pfunc = PFunction(
-        fn_type="mlir.pphlo",
+        fn_type="spu.run_pphlo",
         ins_info=tuple(TensorType.from_obj(x) for x in in_vars),
         outs_info=tuple(output_tensor_infos),
         fn_name=get_fn_name(fn),

mplang/runtime/resource.py

@@ -26,17 +26,7 @@ from urllib.parse import urlparse
 import cloudpickle as pickle
 import spu.libspu as libspu
 
-# Import backends (side-effect: kernel registration)
-from mplang.backend import (  # noqa: F401
-    builtin,
-    crypto,
-    phe,
-    spu,  # registers flat SPU kernels
-    sql_duckdb,
-    stablehlo,
-    tee,
-)
-from mplang.backend.base import BackendRuntime, create_runtime
+from mplang.backend.context import RuntimeContext
 from mplang.backend.spu import PFunction  # type: ignore
 from mplang.core.expr.ast import Expr
 from mplang.core.expr.evaluator import IEvaluator, create_evaluator
@@ -98,9 +88,6 @@ class Session:
 # Global session storage
 _sessions: dict[str, Session] = {}
 
-# Service-level global symbol table (process-local for this server)
-_global_symbols: dict[str, Symbol] = {}
-
 
 # Session Management
 def create_session(
@@ -147,6 +134,43 @@ def delete_session(name: str) -> bool:
     return False
 
 
+# Global symbol management (process-wide, not per-session)
+_global_symbols: dict[str, Symbol] = {}
+
+
+def create_global_symbol(name: str, mptype: dict[str, Any], data_b64: str) -> Symbol:
+    """Create or replace a global symbol.
+
+    Args:
+        name: Symbol identifier
+        mptype: Metadata dict (shape/dtype, etc.)
+        data_b64: Base64-encoded pickled data
+    """
+    try:
+        raw = base64.b64decode(data_b64)
+        data = pickle.loads(raw)
+    except Exception as e:  # pragma: no cover - defensive
+        raise InvalidRequestError(f"Failed to decode symbol payload: {e}") from e
+    sym = Symbol(name=name, mptype=mptype, data=data)
+    _global_symbols[name] = sym
+    return sym
+
+
+def get_global_symbol(name: str) -> Symbol:
+    sym = _global_symbols.get(name)
+    if sym is None:
+        raise ResourceNotFound(f"Global symbol '{name}' not found")
+    return sym
+
+
+def delete_global_symbol(name: str) -> bool:
+    return _global_symbols.pop(name, None) is not None
+
+
+def list_global_symbols() -> list[str]:  # pragma: no cover - trivial
+    return sorted(_global_symbols.keys())
+
+
 # Computation Management
 def create_computation(
     session_name: str, computation_name: str, expr: Expr
@@ -225,15 +249,7 @@ def execute_computation(
 
     # Build evaluator
     # Explicit per-rank backend runtime (deglobalized)
-    runtime = create_runtime(rank, session.communicator.world_size)
-    # Inject global symbol storage into backend runtime state so that
-    # symbols:// provider can access it during builtin.read/write.
-    if isinstance(runtime, BackendRuntime):
-        pocket = runtime.state.setdefault("resource.providers", {})
-        if "symbols" not in pocket:
-            pocket["symbols"] = _global_symbols
-        else:
-            raise RuntimeError("resource.providers.symbols already exists")
+    runtime = RuntimeContext(rank=rank, world_size=session.communicator.world_size)
     evaluator: IEvaluator = create_evaluator(
         rank=rank, env=bindings, comm=session.communicator, runtime=runtime
     )
@@ -285,45 +301,6 @@ def execute_computation(
             session.symbols[name] = Symbol(name=name, mptype={}, data=val)
 
 
-# Global symbol CRUD (service-level)
-def create_global_symbol(name: str, mptype: Any, data: str) -> Symbol:
-    """Create or update a global symbol in the service-level table.
-
-    WARNING: Uses Python pickle for arbitrary object deserialization. Deploy
-    only in trusted environments. Future work may replace this with a
-    restricted / structured serialization.
-
-    The `data` argument is a base64-encoded pickled Python object. Minimal
-    validation of `mptype` is performed for tensor metadata (shape/dtype)
-    when present to catch obvious mismatches.
-    """
-    try:
-        data_bytes = base64.b64decode(data)
-        obj = pickle.loads(data_bytes)
-    except Exception as e:
-        raise InvalidRequestError(f"Invalid global symbol data encoding: {e!s}") from e
-
-    sym = Symbol(name, mptype, obj)
-    _global_symbols[name] = sym
-    return sym
-
-
-def get_global_symbol(name: str) -> Symbol | None:
-    return _global_symbols.get(name)
-
-
-def list_global_symbols() -> list[str]:
-    return list(_global_symbols.keys())
-
-
-def delete_global_symbol(name: str) -> bool:
-    if name in _global_symbols:
-        del _global_symbols[name]
-        logging.info(f"Global symbol {name} deleted")
-        return True
-    return False
-
-
 # Symbol Management
 def create_symbol(session_name: str, name: str, mptype: Any, data: Any) -> Symbol:
     """Create a symbol in a session's symbol table.

mplang/runtime/simulation.py

@@ -24,17 +24,10 @@ from typing import Any, cast
 
 import spu.libspu as libspu
 
-# Import flat backends for kernel registration side-effects
-from mplang.backend import (
-    builtin,  # noqa: F401
-    crypto,  # noqa: F401
-    phe,  # noqa: F401
-    spu,  # noqa: F401  # ensure SPU kernels (spu.seed_env etc.) registered
-    sql_duckdb,  # noqa: F401
-    stablehlo,  # noqa: F401
-    tee,  # noqa: F401
-)
-from mplang.backend.base import create_runtime  # explicit per-rank backend runtime
+# New explicit binding model: we only need RuntimeContext which ensures
+# bindings via bind_all_ops() on creation; per-module side-effect imports
+# are no longer required here.
+from mplang.backend.context import RuntimeContext
 from mplang.core.cluster import ClusterSpec
 from mplang.core.comm import CollectiveMixin, CommunicatorBase
 from mplang.core.expr.ast import Expr
@@ -152,7 +145,7 @@ class Simulator(InterpContext):
 
         self._evaluators: list[IEvaluator] = []
         for rank in range(self.world_size()):
-            runtime = create_runtime(rank, self.world_size())
+            runtime = RuntimeContext(rank=rank, world_size=self.world_size())
             ev = create_evaluator(
                 rank,
                 {},  # the global environment for this rank
@@ -224,7 +217,7 @@ class Simulator(InterpContext):
         # Build per-rank evaluators with the per-party environment
         pts_evaluators: list[IEvaluator] = []
         for rank in range(self.world_size()):
-            runtime = create_runtime(rank, self.world_size())
+            runtime = RuntimeContext(rank=rank, world_size=self.world_size())
             ev = create_evaluator(
                 rank,
                 pts_env[rank],

{mplang_nightly-0.1.dev142.dist-info → mplang_nightly-0.1.dev144.dist-info}/METADATA

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

{mplang_nightly-0.1.dev142.dist-info → mplang_nightly-0.1.dev144.dist-info}/RECORD

@@ -3,13 +3,14 @@ mplang/api.py,sha256=ssmv0_CyZPFORhOUJ84Jo6NwRJSK7_Ono3n7ZjEg4sA,3058
 mplang/device.py,sha256=Iz_YFKkrbTFKtTQdGqkQZfc0NQH9dIxXP7-fUkIQOa4,12568
 mplang/analysis/__init__.py,sha256=CTHFvRsi-nFngojqjn08UaR3RY9i7CJ7T2UdR95kCrk,1056
 mplang/analysis/diagram.py,sha256=ffwgD12gL1_KH1uJ_EYkjmIlDrfxYJJkWj-wHl09_Xk,19520
-mplang/backend/__init__.py,sha256=Pn1MGW7FZ8ZQWcx_r2Io4Q1JbrMINCpefQt7yCNq_dc,741
-mplang/backend/base.py,sha256=zaofB1MPC9Af8FS-rx7q6utFxiu9Mppr2gWaKFZ70Os,9863
+mplang/backend/__init__.py,sha256=2WE4cmW96Xkzyq2yRRYNww4kZ5o6u6NbPV0BxqZG698,581
+mplang/backend/base.py,sha256=Rp4Ze1aF5dypdMOskXnQWE-rM5nc4vkdDogEoxQp7FU,5712
 mplang/backend/builtin.py,sha256=Mk1uUO2Vpw3meqZ0B7B0hG-wndea6cmFv2Uk1vM_uTg,7052
+mplang/backend/context.py,sha256=e22JzsHydi1DLkjzOEYwGBaAoVHyf8aEFYH_SuN7oR4,9351
 mplang/backend/crypto.py,sha256=H_s5HI7lUP7g0xz-a9qMbSn6dhJStUilKbn3-7SIh0I,3812
-mplang/backend/phe.py,sha256=Y07fkTHTSKHgpMQ1soA3d2eBMlqr25uHCAtZOd5D5_I,10555
-mplang/backend/spu.py,sha256=i6Qqgeg-Anwpb5xX5Uz8GdmTWNkRy_pjp-xptIvlxl4,9273
-mplang/backend/sql_duckdb.py,sha256=WFEiJk3t68DMpjV9xZz5bJj3v8UMx4X5QWleLIE4Aq0,1499
+mplang/backend/phe.py,sha256=uNqmrbDAbd97TWS_O6D5sopastHy6J20R7knFE4M4uc,65247
+mplang/backend/spu.py,sha256=QT1q5uv-5P_nBGtTvtA_yI2h3h3zIqNSnvzGT7Shua4,9307
+mplang/backend/sql_duckdb.py,sha256=U_KzEUinxrBRDoUz2Vh597-N4I3hPOBT0RT3tX-ZqKE,1502
 mplang/backend/stablehlo.py,sha256=GOxy-qgOxyEdtBkt6LASKzaZnPewZhvHYSPOgFFXgIM,2612
 mplang/backend/tee.py,sha256=6kc7qTe8nWc3pr6iYtozEGLO8Umg-UBQLDiz6p3pdVg,1918
 mplang/core/__init__.py,sha256=lWxlEKfRwX7FNDzgyKZ1fiDMaCiqkyg0j5mKlZD_v7g,2244
@@ -29,20 +30,20 @@ mplang/core/tensor.py,sha256=86u6DogSZMoL0w5XjtTmQm2PhA_VjwybN1b6U4Zzphg,2361
 mplang/core/tracer.py,sha256=dVMfUeCMmPz4o6tLXewGMW1Kpy5gpZORvr9w4MhwDtM,14288
 mplang/core/expr/__init__.py,sha256=qwiSTUOcanFJLyK8HZ13_L1ZDrybqpPXIlTHAyeumE8,1988
 mplang/core/expr/ast.py,sha256=KE46KTtlH9RA2V_EzWVKCKolsycgTmt7SotUrOc8Qxs,20923
-mplang/core/expr/evaluator.py,sha256=0ZwDgRyzHh1zxmb-9XW85toVKpk2mk0_t-hY_10U_Q8,20786
+mplang/core/expr/evaluator.py,sha256=3rtfHVajmCUtkanzgiCWkepRRiTKehPcDF2i5EbcitI,20789
 mplang/core/expr/printer.py,sha256=VblKGnO0OUfzH7EBkszwRNxQUB8QyyC7BlJWJEUv9so,9546
 mplang/core/expr/transformer.py,sha256=TyL-8FjrVvDq_C9X7kAuKkiqt2XdZM-okjzVQj0A33s,4893
 mplang/core/expr/utils.py,sha256=VDTJ_-CsdHtVy9wDaGa7XdFxQ7o5lYYaeqcgsAhkbNI,2625
 mplang/core/expr/visitor.py,sha256=2Ge-I5N-wH8VVXy8d2WyNaEv8x6seiRx9peyH9S2BYU,2044
 mplang/core/expr/walk.py,sha256=lXkGJEEuvKGDqQihbxXPxfz2RfR1Q1zYUlt11iooQW0,11889
 mplang/frontend/__init__.py,sha256=3ZBFX_acM96tZ2mtJaxJm150n1cf0LnnCRmkrAc4uBw,1463
-mplang/frontend/base.py,sha256=I-Hhh5o6GVqBA1YySl9Nk3zkbMoVrQqLMRyX2JypsPI,18268
+mplang/frontend/base.py,sha256=rGtfBejcDh9mTRxOdJK5VUlG5vYiVJSir8X72X0Huvc,18264
 mplang/frontend/builtin.py,sha256=8qrlbe_SSy6QTXTnMG6_ADB8jSklVZGFBrkoR-p02FE,9368
 mplang/frontend/crypto.py,sha256=Nf8zT4Eko7MIs4R2tgZecKVd7d6Hvd_CGGmANhs3Ghs,3651
-mplang/frontend/ibis_cc.py,sha256=01joUdFS_Ja9--PkezBhEcW_a9mkDrLgOhu5320s_bQ,4167
+mplang/frontend/ibis_cc.py,sha256=CTTbPPZ9hFnHuFDDIfgJHie1EdNnHmi5Ha1KsX0iYh8,4235
 mplang/frontend/jax_cc.py,sha256=ssP6rCvyWQ5VAr80-7z9QZUE2mWXyozJCGpq1dYQYY8,6374
-mplang/frontend/phe.py,sha256=zsL4rbukoZ4SvCkPdfgGQRzCwXk4_opn693RTgwp7gQ,2501
-mplang/frontend/spu.py,sha256=yvnXH8HU55t7j_jaTpxa3Nbh0SqXufVDyZBTYCsRTK4,4994
+mplang/frontend/phe.py,sha256=tDsCvStjVJ1Fs07yF3idkFnugUCA1zdFApPx7Uuulik,6795
+mplang/frontend/spu.py,sha256=7G6DaEfC5APSDhfeWSISTG_8tEcVbWth3XmjL8QUrVA,4994
 mplang/frontend/sql.py,sha256=DFdvjEPQX28VCRgUMeHYR0rwwOaoCH15bpvvlclLtHA,1999
 mplang/frontend/tee.py,sha256=EigmlbYDGvXkZCMHSYRAiOboSl9TG0ewoudbgl3_V6M,1393
 mplang/protos/v1alpha1/mpir_pb2.py,sha256=Bros37t-4LMJbuUYVSM65rImUYTtZDhNTIADGbZCKp0,7522
@@ -57,9 +58,9 @@ mplang/runtime/driver.py,sha256=Ok1jY301ctN1_KTb4jwSxOdB0lI_xhx9AwhtEGJ-VLQ,1130
 mplang/runtime/exceptions.py,sha256=c18U0xK20dRmgZo0ogTf5vXlkix9y3VAFuzkHxaXPEk,981
 mplang/runtime/http_api.md,sha256=-re1DhEqMplAkv_wnqEU-PSs8tTzf4-Ml0Gq0f3Go6s,4883
 mplang/runtime/link_comm.py,sha256=uNqTCGZVwWeuHAb7yXXQf0DUsMXLa8leHCkrcZdzYMU,4559
-mplang/runtime/resource.py,sha256=BkzpAjRrkjS-5FPawHHcVzxEE_htpMtS4JJCvcLrnU0,12564
+mplang/runtime/resource.py,sha256=-B9kSM7xhocc6mpXHmV9xTdpVR2duiUCepJKS7QuLqA,11688
 mplang/runtime/server.py,sha256=gTPqAux1EdefaBFnserYIXamoi7pbEsQrFX6cXbOjik,14716
-mplang/runtime/simulation.py,sha256=kj-RtvvypISO2xyYQGtm-N8yavnkVpD33KSLpvL-Vms,11107
+mplang/runtime/simulation.py,sha256=kuFXWuJLGcmy4OvLCBby4K5QbXaQZmKSb4qrCJ2stBY,10957
 mplang/simp/__init__.py,sha256=DmSMcKvHVXWS2pYsuHazEmwOWWpZeKOJQsNU6VxC10U,11614
 mplang/simp/mpi.py,sha256=Wv_Q16TQ3rdLam6OzqXiefIGSMmagGkso09ycyOkHEs,4774
 mplang/simp/random.py,sha256=7PVgWNL1j7Sf3MqT5PRiWplUu-0dyhF3Ub566iqX86M,3898
@@ -69,8 +70,8 @@ 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.dev142.dist-info/METADATA,sha256=U2gYpnBcdaqDYhHfzvLnxBrgKB9HWSydYbymvVZEsQY,16547
-mplang_nightly-0.1.dev142.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mplang_nightly-0.1.dev142.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev142.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev142.dist-info/RECORD,,
+mplang_nightly-0.1.dev144.dist-info/METADATA,sha256=i6ef5f8u6W_vm_UfZcAPsekVJ0j4a9wNYCdVDKJRBgw,16547
+mplang_nightly-0.1.dev144.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mplang_nightly-0.1.dev144.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev144.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev144.dist-info/RECORD,,