mplang-nightly 0.1.dev251__py3-none-any.whl → 0.1.dev253__py3-none-any.whl

mplang/v2/__init__.py

@@ -52,15 +52,19 @@ from mplang.v2.edsl import (
     TracedFunction,
     Tracer,
     Value,
+    find_context,
+    find_context_with_state,
+    find_interpreter,
     format_graph,
     get_current_context,
     get_default_context,
-    get_root_context,
+    is_tracing,
     jit,
     pop_context,
     primitive,
     push_context,
     register_default_context_factory,
+    set_root_context,
     trace,
 )
 from mplang.v2.edsl.registry import get_profiler
@@ -97,34 +101,6 @@ from mplang.v2.runtime.interpreter import Interpreter
 # =============================================================================
 
 
-def set_root_context(context: Interpreter, force: bool = False) -> None:
-    """Set the global/root execution context.
-
-    This explicitly sets the provided interpreter as the Root Context.
-    All subsequent operations (compile, evaluate, device resolution) will
-    use this context as the default environment.
-
-    Args:
-        context: Interpreter to use as the root context.
-        force: If True, clears the existing context stack before setting.
-               If False (default), pushes onto the stack.
-    """
-    from mplang.v2.edsl.context import _context_stack, get_current_context
-
-    if force:
-        _context_stack.clear()
-        _context_stack.append(context)
-        return
-
-    if get_current_context() is not None:
-        raise RuntimeError(
-            "Cannot set root context: Context stack is not empty. "
-            "Use force=True to overwrite the existing root context."
-        )
-
-    push_context(context)
-
-
 def _get_context(context: Interpreter | None) -> Interpreter:
     """Get context from parameter or context stack."""
     if context is not None:
@@ -204,6 +180,30 @@ def fetch(
 ) -> Any:
     """Fetch results from interpreter context to Python.
 
+    This is a meta-function that operates at execution boundaries, not a traced
+    dialect operation. It brings data from the distributed/MPC runtime back to
+    the Python host.
+
+    Behavior in different contexts:
+    - **Tracing (compile)**: Returns the input unchanged (identity). The graph
+      outputs are determined by the function's return statement, not fetch calls.
+    - **Execution (evaluate)**: Actually fetches data from workers/parties.
+
+    Design Note (A vs B tradeoff):
+        Two designs were considered for fetch behavior during tracing:
+
+        - **Design A (chosen)**: fetch = identity during tracing. Graph outputs
+          are determined solely by the return statement. This is simpler and
+          avoids ambiguity when fetch and return reference different values.
+
+        - **Design B (alternative)**: fetch marks output points in the graph.
+          This would allow fetch(a), fetch(b), return b to output both a and b.
+          However, it complicates the semantics and requires tracking fetch
+          points separately from return values.
+
+        Design A was chosen for simplicity. If a value needs to be an output,
+        it should be returned. fetch's role is purely for execution-time I/O.
+
     Args:
         result: Object(s) to fetch. Can be a single InterpObject, DriverVar,
             or nested structure containing them.
@@ -216,14 +216,22 @@ def fetch(
         Fetched Python values. For device objects with follow_device=True,
         returns single value from the device's rank(s). Otherwise returns
         list of values (one per party) or single value for world_size=1.
+        During tracing, returns the input unchanged.
     """
-
     from jax.tree_util import tree_map
 
     from mplang.v2.backends.simp_driver.values import DriverVar
+    from mplang.v2.edsl.context import is_tracing
     from mplang.v2.runtime.interpreter import InterpObject
     from mplang.v2.runtime.value import WrapValue
 
+    # Check if we are in tracing context - if so, return identity
+    if is_tracing():
+        # Design A: fetch = identity during tracing
+        # Graph outputs are determined by return statement, not fetch calls
+        return result
+
+    # Execution context - actually fetch data
     interp = _get_context(context)
 
     def _fetch_single(var: Any) -> Any:
@@ -375,10 +383,14 @@ __all__ = [  # noqa: RUF022
     "compile",
     "evaluate",
     "fetch",
+    "find_context",
+    "find_context_with_state",
+    "find_interpreter",
     "format_graph",
     "function",
     "get_current_context",
     "get_default_context",
+    "is_tracing",
     "jit",
     "mplang",
     "pop_context",
@@ -404,7 +416,6 @@ __all__ = [  # noqa: RUF022
     # Dialects
     "dialects",
     "register_default_context_factory",
-    "get_root_context",
     "get_profiler",
 ]
 

mplang/v2/edsl/__init__.py

@@ -33,12 +33,16 @@ from . import typing as typing
 # Context management
 from .context import (
     Context,
+    find_context,
+    find_context_with_state,
+    find_interpreter,
     get_current_context,
     get_default_context,
-    get_root_context,
+    is_tracing,
     pop_context,
     push_context,
     register_default_context_factory,
+    set_root_context,
 )
 
 # Graph IR
@@ -77,15 +81,19 @@ __all__ = [
     "Tracer",
     "Value",
     "VectorObject",
+    "find_context",
+    "find_context_with_state",
+    "find_interpreter",
     "format_graph",
     "get_current_context",
     "get_default_context",
-    "get_root_context",
+    "is_tracing",
     "jit",
     "pop_context",
     "primitive",
     "push_context",
     "register_default_context_factory",
+    "set_root_context",
     "trace",
     "typing",
 ]

mplang/v2/edsl/context.py

@@ -27,6 +27,16 @@ Contexts can be used directly with Python's 'with' statement:
     with tracer:
         # Operations run under tracer context
         result = primitive.bind(x, y)
+
+State Management:
+    Contexts can carry arbitrary named state via set_state/get_state.
+    This allows different layers (device, ml, analytics) to attach their
+    own state without the EDSL layer knowing about specific state types.
+
+    State key conventions:
+    - "dialect.{name}": Dialect runtime state (e.g., "dialect.simp")
+    - "device.cluster": Device/cluster configuration
+    - "ml.{component}": ML pipeline components
 """
 
 from __future__ import annotations
@@ -42,14 +52,65 @@ if TYPE_CHECKING:
 
 
 class Context(ABC):
-    """Base class for EDSL execution contexts.
+    """Base class for EDSL execution contexts with extensible state slots.
 
     A Context represents an environment where primitives are executed.
     There are two types of contexts:
     - Tracer: Records operations to Graph IR (compile-time)
     - Interpreter: Execution context (executes operations immediately)
+
+    State Management:
+        Contexts can carry arbitrary named state. Different layers can attach
+        their own state without the EDSL layer knowing specifics:
+
+        >>> ctx.set_state("device.cluster", cluster_spec)
+        >>> ctx.set_state("dialect.simp", simp_driver)
+        >>> cluster = ctx.get_state("device.cluster")
     """
 
+    def __init__(self) -> None:
+        self._state: dict[str, Any] = {}
+
+    # =========================================================================
+    # State Management
+    # =========================================================================
+
+    def set_state(self, key: str, value: Any) -> None:
+        """Attach state to this context.
+
+        Args:
+            key: State key (e.g., "dialect.simp", "device.cluster")
+            value: State value
+        """
+        self._state[key] = value
+
+    def get_state(self, key: str, default: Any = None) -> Any:
+        """Get attached state by key.
+
+        Args:
+            key: State key
+            default: Default value if key not found
+
+        Returns:
+            State value or default
+        """
+        return self._state.get(key, default)
+
+    def has_state(self, key: str) -> bool:
+        """Check if state exists.
+
+        Args:
+            key: State key
+
+        Returns:
+            True if state exists
+        """
+        return key in self._state
+
+    # =========================================================================
+    # Abstract Methods
+    # =========================================================================
+
     @abstractmethod
     def bind_primitive(
         self, primitive: Primitive, args: tuple[Any, ...], kwargs: dict[str, Any]
@@ -80,6 +141,10 @@ class Context(ABC):
             Object in the context's native type (TraceObject or InterpObject)
         """
 
+    # =========================================================================
+    # Context Manager
+    # =========================================================================
+
     def __enter__(self) -> Self:
         """Enter context manager (push context onto stack)."""
         push_context(self)
@@ -90,9 +155,31 @@ class Context(ABC):
         pop_context()
 
 
-# ============================================================================
+# =============================================================================
+# Abstract Interpreter Interface
+# =============================================================================
+
+
+class AbstractInterpreter(Context):
+    """Abstract interface for Interpreters.
+
+    This allows EDSL components (like JIT) to depend on the Interpreter interface
+    without depending on the concrete Runtime implementation (which may depend on
+    ObjectStore, Backends, etc.).
+    """
+
+    @abstractmethod
+    def evaluate_graph(self, graph: Graph, inputs: list[Any]) -> Any:
+        """Execute a Graph IR with given inputs."""
+
+    @abstractmethod
+    def lift(self, obj: Any) -> Any:
+        """Lift a python object to an interpreter object."""
+
+
+# =============================================================================
 # Global Context Stack Management
-# ============================================================================
+# =============================================================================
 
 _context_stack: list[Context] = []
 _default_context: Context | None = None
@@ -100,20 +187,25 @@ _default_context_factory: Callable[[], Context] | None = None
 
 
 def get_current_context() -> Context | None:
-    """Get the current active context.
+    """Get the current active context (top of stack).
 
-    Returns None if no context is active (will use default context).
+    Returns None if no context is active.
     """
-
     return _context_stack[-1] if _context_stack else None
 
 
-def get_root_context() -> Context | None:
-    """Get the root context (bottom of the stack).
+def push_context(context: Context) -> None:
+    """Push a context onto the stack (enter context)."""
+    _context_stack.append(context)
+
+
+def pop_context() -> Context | None:
+    """Pop a context from the stack (exit context).
 
-    This context typically holds the global environment state (e.g. ClusterSpec).
+    Returns:
+        The popped context, or None if stack was empty.
     """
-    return _context_stack[0] if _context_stack else None
+    return _context_stack.pop() if _context_stack else None
 
 
 def find_context(predicate: Callable[[Context], bool]) -> Context | None:
@@ -122,9 +214,6 @@ def find_context(predicate: Callable[[Context], bool]) -> Context | None:
     Traverses from top (most recent) to bottom of the context stack,
     returning the first context for which predicate(ctx) returns True.
 
-    This is a general-purpose utility for finding contexts with specific
-    attributes or capabilities without hardcoding business logic here.
-
     Args:
         predicate: A callable that takes a Context and returns True if it matches.
 
@@ -133,13 +222,7 @@ def find_context(predicate: Callable[[Context], bool]) -> Context | None:
 
     Example:
         >>> # Find context with simp dialect state
-        >>> ctx = find_context(
-        ...     lambda c: hasattr(c, "get_dialect_state")
-        ...     and c.get_dialect_state("simp") is not None
-        ... )
-        >>>
-        >>> # Find context with cluster spec
-        >>> ctx = find_context(lambda c: getattr(c, "_cluster_spec", None) is not None)
+        >>> ctx = find_context(lambda c: c.has_state("dialect.simp"))
     """
     for ctx in reversed(_context_stack):
         if predicate(ctx):
@@ -147,15 +230,41 @@ def find_context(predicate: Callable[[Context], bool]) -> Context | None:
     return None
 
 
-def push_context(context: Context) -> None:
-    """Push a context onto the stack (enter context)."""
-    _context_stack.append(context)
+def find_context_with_state(key: str) -> Context | None:
+    """Find first context that has the specified state.
+
+    Args:
+        key: State key to look for
+
+    Returns:
+        First context with the state, or None
+    """
+    return find_context(lambda c: c.has_state(key))
+
+
+def find_interpreter() -> Context | None:
+    """Find first Interpreter in the context stack.
+
+    Returns:
+        First Interpreter context, or None if not found.
+    """
+    return find_context(lambda c: isinstance(c, AbstractInterpreter))
 
 
-def pop_context() -> None:
-    """Pop a context from the stack (exit context)."""
-    if _context_stack:
-        _context_stack.pop()
+def is_tracing() -> bool:
+    """Check if current context is a Tracer.
+
+    Returns:
+        True if the top of the context stack is a Tracer.
+    """
+    from mplang.v2.edsl.tracer import Tracer
+
+    return isinstance(get_current_context(), Tracer)
+
+
+# =============================================================================
+# Default Context Management
+# =============================================================================
 
 
 def register_default_context_factory(factory: Callable[[], Context]) -> None:
@@ -177,18 +286,26 @@ def get_default_context() -> Context:
     return _default_context
 
 
-class AbstractInterpreter(Context):
-    """Abstract interface for Interpreters.
+def set_root_context(context: Context, force: bool = False) -> None:
+    """Set the root/default execution context.
 
-    This allows EDSL components (like JIT) to depend on the Interpreter interface
-    without depending on the concrete Runtime implementation (which may depend on
-    ObjectStore, Backends, etc.).
-    """
-
-    @abstractmethod
-    def evaluate_graph(self, graph: Graph, inputs: list[Any]) -> Any:
-        """Execute a Graph IR with given inputs."""
+    This sets the provided context as the base of the context stack.
+    All subsequent operations will use this context as the default environment.
 
-    @abstractmethod
-    def lift(self, obj: Any) -> Any:
-        """Lift a python object to an interpreter object."""
+    Args:
+        context: Context to set as root.
+        force: If True, clears the existing context stack before setting.
+               If False (default), raises error if stack is not empty.
+    """
+    if force:
+        _context_stack.clear()
+        _context_stack.append(context)
+        return
+
+    if get_current_context() is not None:
+        raise RuntimeError(
+            "Cannot set root context: Context stack is not empty. "
+            "Use force=True to overwrite the existing context."
+        )
+
+    push_context(context)

mplang/v2/libs/device/api.py

@@ -732,25 +732,23 @@ def fetch(obj: Object) -> Any:
     """
     from mplang.v2.backends.simp_driver.state import SimpDriver
     from mplang.v2.backends.simp_driver.values import DriverVar
-    from mplang.v2.backends.table_impl import TableValue
-    from mplang.v2.backends.tensor_impl import TensorValue
     from mplang.v2.edsl.context import get_current_context
     from mplang.v2.runtime.interpreter import InterpObject, Interpreter
+    from mplang.v2.runtime.value import WrapValue
 
     def _unwrap_value(val: Any) -> Any:
-        """Unwrap Value types to get the underlying data."""
-        if isinstance(val, TensorValue):
-            return val.data
-        elif isinstance(val, TableValue):
+        """Unwrap WrapValue to get the underlying data."""
+        if isinstance(val, WrapValue):
             return val.data
         return val
 
-    # Get device info
+    # 1. Ensure is object and is device obj
     if not is_device_obj(obj):
         raise DeviceError(
             "Object does not have device attribute. Use mp.fetch() directly."
         )
 
+    # 2. Get device information according to device id
     dev_id = get_dev_attr(obj)
     cluster = _resolve_cluster()
     dev_info = cluster.devices[dev_id]
@@ -760,9 +758,10 @@ def fetch(obj: Object) -> Any:
     if not isinstance(ctx, Interpreter):
         raise RuntimeError("No interpreter context available for fetch")
 
-    simp_state = cast(SimpDriver | None, ctx.get_dialect_state("simp"))
+    simp_state = ctx.get_dialect_state("simp")
+    assert isinstance(simp_state, SimpDriver), "DriverVar requires simp state"
 
-    # Unwrap InterpObject
+    # Unwrap InterpObject to get runtime value
     assert isinstance(obj, InterpObject), f"Expected InterpObject, got {type(obj)}"
     runtime_obj = obj.runtime_obj
 
@@ -770,19 +769,26 @@ def fetch(obj: Object) -> Any:
         """Fetch value from a rank (DriverVar values are always URIs)."""
         uri = runtime_obj.values[rank]
         assert isinstance(uri, str) and "://" in uri, f"Expected URI, got {uri}"
-        assert simp_state is not None, "No simp state for fetch"
-        return _unwrap_value(simp_state.fetch(rank, uri).result())
+        return simp_state.fetch(rank, uri).result()
 
-    # Handle DriverVar
+    # 3. Match device type and do corresponding fetch action
     if isinstance(runtime_obj, DriverVar):
-        # For PPU/TEE: single member
+        # 3.1 PPU/TEE: single member, fetch directly
         if dev_info.kind.upper() in ("PPU", "TEE"):
             assert len(dev_info.members) == 1
-            return _fetch_from_rank(dev_info.members[0].rank)
+            result = _fetch_from_rank(dev_info.members[0].rank)
+            # 4. Unwrap if WrapValue
+            return _unwrap_value(result)
 
-        # For SPU: fetch from first member (should be revealed first)
+        # 3.2 SPU: fetch from all ranks and reconstruct
         elif dev_info.kind.upper() == "SPU":
-            return _fetch_from_rank(dev_info.members[0].rank)
-
-    # Direct value
+            # Fetch shares from all SPU members
+            shares = [_fetch_from_rank(m.rank) for m in dev_info.members]
+            # For now, just return the first share (TODO: implement spu.reconstruct)
+            # In practice, SPU values should be revealed to a PPU first
+            result = shares[0] if shares else None
+            # 4. Unwrap if WrapValue
+            return _unwrap_value(result)
+
+    # Direct value (not DriverVar)
     return _unwrap_value(runtime_obj)

mplang/v2/runtime/interpreter.py

@@ -31,7 +31,7 @@ import queue
 import threading
 import time
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
 from mplang.v2.edsl.context import AbstractInterpreter
 from mplang.v2.edsl.graph import Graph
@@ -340,13 +340,13 @@ class Interpreter(AbstractInterpreter):
             else pathlib.Path(os.environ.get("MPLANG_DATA_ROOT", ".mpl"))
         )
 
+        # Initialize Context base class (for state management)
+        super().__init__()
+
         # Instance-level handler registry (overrides global registry)
         self.handlers: dict[str, Callable] = handlers or {}
         self.tracer = tracer
 
-        # Dialect states (typed runtime state for stateful dialects)
-        self._dialect_states: dict[str, DialectState] = {}
-
         # GraphValue -> InterpObject cache
         # Maps a GraphValue (IR node) to its computed InterpObject (Runtime result).
         # This serves two purposes:
@@ -366,6 +366,8 @@ class Interpreter(AbstractInterpreter):
     def get_dialect_state(self, dialect: str) -> DialectState | None:
         """Get the state object for a specific dialect.
 
+        This is a convenience wrapper around get_state("dialect.{dialect}").
+
         Args:
             dialect: Name of the dialect (e.g., "simp", "bfv", "spu")
 
@@ -377,11 +379,15 @@ class Interpreter(AbstractInterpreter):
             if simp_state is not None:
                 simp_state.submit(rank, graph, inputs)
         """
-        return self._dialect_states.get(dialect)
+        state = self.get_state(f"dialect.{dialect}")
+        # Type assertion: dialect states are always DialectState or None
+        return cast(DialectState | None, state)
 
     def set_dialect_state(self, dialect: str, state: DialectState) -> None:
         """Set the state object for a specific dialect.
 
+        This is a convenience wrapper around set_state("dialect.{dialect}", state).
+
         Args:
             dialect: Name of the dialect (e.g., "simp", "bfv", "spu")
             state: The dialect state object (should implement DialectState protocol)
@@ -389,7 +395,7 @@ class Interpreter(AbstractInterpreter):
         Example:
             interpreter.set_dialect_state("simp", cluster.connect())
         """
-        self._dialect_states[dialect] = state
+        self.set_state(f"dialect.{dialect}", state)
 
     def bind_primitive(
         self, primitive: Primitive, args: tuple[Any, ...], kwargs: dict[str, Any]

{mplang_nightly-0.1.dev251.dist-info → mplang_nightly-0.1.dev253.dist-info}/METADATA

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

{mplang_nightly-0.1.dev251.dist-info → mplang_nightly-0.1.dev253.dist-info}/RECORD

@@ -77,7 +77,7 @@ mplang/v1/utils/crypto.py,sha256=rvPomBFtznRHc3RPi6Aip9lsU8zW2oxBqGv1K3vn7Rs,105
 mplang/v1/utils/func_utils.py,sha256=vCJcZmu0bEbqhOQKdpttV2_MBllIcPSN0b8U4WjNGGo,5164
 mplang/v1/utils/spu_utils.py,sha256=S3L9RBkBe2AvSuMSQQ12cBY5Y1NPthubvErSX_7nj1A,4158
 mplang/v1/utils/table_utils.py,sha256=1fDgZLrRf2bvKvA45egT6RtMPgwE1cI2BokMHUU_xv4,5945
-mplang/v2/__init__.py,sha256=L3QUvsbCQGlHjwvEytkLB4mwCWRDg-WFwM-UO0u-t8s,12983
+mplang/v2/__init__.py,sha256=SqVxDiRvA9W49NaXaT70spf6-xSbat1ZfIdI4j8KgFk,13816
 mplang/v2/cli.py,sha256=KBKJbgqsxAdrDYXjj3KMWO1zdhHQdQeJF94tOuKbLio,19665
 mplang/v2/cli_guide.md,sha256=kyoCaqkvIJJ1vsvCyBu3qgOuRSb0txu9BDZoy9GU5S0,3617
 mplang/v2/backends/__init__.py,sha256=H-4-jBEPWBZl6XT7AxBShRINnruF_f_2lB4iaiQoXME,1988
@@ -117,8 +117,8 @@ mplang/v2/dialects/table.py,sha256=ax9Yjvcb8jJ8fqNJodMQ_mrS8tf-xECHQFvUKUWPp70,1
 mplang/v2/dialects/tee.py,sha256=R_XySt-JNhZJNdjRiUw-nU4BjwBNMtV4sYFMOtvJZzc,11506
 mplang/v2/dialects/tensor.py,sha256=FxPKsiNi2vFb-R2hqRgR7zYYO5LdRu_rdDHfjE3_2Lw,40003
 mplang/v2/edsl/README.md,sha256=viflvdRojOa6Xk_UMRPqpuPGXcPGmdlv2-XR6LO7B58,7592
-mplang/v2/edsl/__init__.py,sha256=xpZzkqJ9fiBmFguELjf6HAWpfjv0gyMPxMXIAeXwP4Y,2429
-mplang/v2/edsl/context.py,sha256=Hf5QubGwGIrwbsyYjT-_IP1-SUKmMcEO2DvoTALaJY4,6459
+mplang/v2/edsl/__init__.py,sha256=YqmtrJXD1NLKS-_Ofnxtiv77muokTZnrAiV7dXUZVyo,2607
+mplang/v2/edsl/context.py,sha256=jkz0Fs6dMGQ9V68-h5ki-7hdBXJ6s5WqoYVJSctPRds,10089
 mplang/v2/edsl/graph.py,sha256=VXeE_9Oc9E0qfnwFDYBvFyDL79qvABLs1aFC-lheJ8M,14983
 mplang/v2/edsl/jit.py,sha256=tofGAqNSUPuEmqy0flaZpNaR1Y425Pk2FdmCKxRPCM8,2069
 mplang/v2/edsl/object.py,sha256=rijDu4yuG_Sitgfz5gk8-mJ1-3Bgor0QrQU04q9mkgo,1909
@@ -137,7 +137,7 @@ mplang/v2/kernels/okvs_opt.cpp,sha256=d_HhvMdcebYsG2x7kYzjuFgmEsh9WKLH6SHee3375B
 mplang/v2/kernels/py_kernels.py,sha256=FDsD86IHV-UBzxZLolhSOkrp24PuboHXeb1gBHLOfMo,12073
 mplang/v2/libs/collective.py,sha256=pfXq9tmFUNKjeHhWMTjtzOi-m2Fn1lLru1G6txZVyic,10683
 mplang/v2/libs/device/__init__.py,sha256=mXsSvXrWmlHu6Ch87Vcd85m4L_qdDkbSvJyHyuai2fc,1251
-mplang/v2/libs/device/api.py,sha256=FylUTIzHp662H79h1oCQIf-lAyqwsERdLFg1Wu30igE,27424
+mplang/v2/libs/device/api.py,sha256=8i0KP3q_XbOfPYB9fzs7pA6vVY4Ib6lxdoiwAi_RlmU,27838
 mplang/v2/libs/device/cluster.py,sha256=YUqYZ_IBS6rpV5ejUFP3kTxcTQHSyeDeuaJcsiFY_Js,12508
 mplang/v2/libs/mpc/__init__.py,sha256=znADXBv0cATTvNN9pVOH8V47O5vmYZnR1Y7tfh1QVjw,1405
 mplang/v2/libs/mpc/_utils.py,sha256=Xzt5jIQSm2e8_xFC6zrdKL93IqbTDb40apk2JBbEgBI,3215
@@ -164,11 +164,11 @@ mplang/v2/libs/mpc/vole/ldpc.py,sha256=FMmK8SNifFr8qTXBSWjFEXvsZvWPyyG5L5OglXJhm
 mplang/v2/libs/mpc/vole/silver.py,sha256=Qnk3EiA18i6RJl-iDCMHOwNdf0Zvkmxq_57O3Y0HPFw,12236
 mplang/v2/runtime/__init__.py,sha256=VdUwJ3kDaI46FvGw7iMGwcsjt0HTGmmRmaBwj99xKIw,620
 mplang/v2/runtime/dialect_state.py,sha256=HxO1i4kSOujS2tQzAF9-WmI3nChSaGgupf2_07dHetY,1277
-mplang/v2/runtime/interpreter.py,sha256=iXooV8GXo-Mc1MyT58DvTICRZRVPg7RHvuD3v7lZlBM,31039
+mplang/v2/runtime/interpreter.py,sha256=vQRcK6RHJVHVjqOOA6QgySFEaEWvlvq0qpXvgk-HiW0,31301
 mplang/v2/runtime/object_store.py,sha256=yT6jtKG2GUEJVmpq3gnQ8mCMvUFYzgBciC5A-J5KRdk,5998
 mplang/v2/runtime/value.py,sha256=CMOxElJP78v7pjasPhEpbxWbSgB2KsLbpPmzz0mQX0E,4317
-mplang_nightly-0.1.dev251.dist-info/METADATA,sha256=msAV6RU4syeeJ_Ozcxl4OG4J_jvrUckRbHf4CpEue6M,16768
-mplang_nightly-0.1.dev251.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mplang_nightly-0.1.dev251.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev251.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev251.dist-info/RECORD,,
+mplang_nightly-0.1.dev253.dist-info/METADATA,sha256=6kbK79_gaRWSwlyJhIVZxD-ToGqhWe60IOyt2aKSe2U,16768
+mplang_nightly-0.1.dev253.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mplang_nightly-0.1.dev253.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev253.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev253.dist-info/RECORD,,