mplang-nightly 0.1.dev278__py3-none-any.whl → 0.1.dev279__py3-none-any.whl

mplang/__init__.py

@@ -34,6 +34,7 @@ except Exception:
     # Fallback for development/editable installs when package is not installed
     __version__ = "0.0.0-dev"
 
+import mplang.tool as tool
 from mplang import dialects
 from mplang.backends.simp_driver.ops import DRIVER_HANDLERS
 from mplang.backends.simp_worker import SimpWorker
@@ -41,6 +42,8 @@ from mplang.backends.simp_worker.mem import LocalMesh
 from mplang.backends.simp_worker.ops import WORKER_HANDLERS
 from mplang.dialects.simp import make_driver, make_simulator
 from mplang.edsl import (
+    CompiledProgram,
+    FlatIOSignature,
     Graph,
     GraphPrinter,
     Object,
@@ -125,7 +128,7 @@ def _get_context(context: Interpreter | None) -> Interpreter:
 
 
 def evaluate(
-    fn: Callable[..., Any] | TracedFunction,
+    fn: Callable[..., Any] | TracedFunction | CompiledProgram,
     *args: Any,
     context: Interpreter | None = None,
     **kwargs: Any,
@@ -158,15 +161,33 @@ def evaluate(
             return val.runtime_obj
         return val
 
+    def eval_graph(graph: Graph, inputs: list[Any]) -> list[InterpObject]:
+        runtime_inputs = [unwrap_if_interp(v) for v in inputs]
+        raw_result = interp.evaluate_graph(graph, runtime_inputs)
+        return [
+            InterpObject(v, graph.outputs[i].type, interp)
+            for i, v in enumerate(raw_result)
+        ]
+
     with interp:
+        if isinstance(fn, CompiledProgram):
+            if kwargs:
+                raise TypeError(
+                    "mp.evaluate(CompiledProgram, ...) does not accept keyword arguments; "
+                    "pass flat positional inputs only."
+                )
+            if len(args) != fn.signature.input_arity:
+                raise ValueError(
+                    "CompiledProgram requires flat positional inputs matching its signature; "
+                    f"expected {fn.signature.input_arity}, got {len(args)}."
+                )
+
+            return eval_graph(fn.graph, list(args))
+
         if isinstance(fn, TracedFunction):
             inputs = fn.prepare_inputs(*args, **kwargs)
             inputs = [unwrap_if_interp(v) for v in inputs]
-            raw_result = interp.evaluate_graph(fn.graph, inputs)
-            wrapped = [
-                InterpObject(v, fn.graph.outputs[i].type, interp)
-                for i, v in enumerate(raw_result)
-            ]
+            wrapped = eval_graph(fn.graph, inputs)
             return fn.reconstruct_outputs(wrapped)
 
         return fn(*args, **kwargs)
@@ -417,6 +438,9 @@ __all__ = [  # noqa: RUF022
     "WORKER_HANDLERS",
     "make_driver",
     "make_simulator",
+    "tool",
+    "CompiledProgram",
+    "FlatIOSignature",
     # Dialects
     "dialects",
     "register_default_context_factory",

mplang/edsl/__init__.py

@@ -53,6 +53,7 @@ from .jit import jit
 from .object import Object
 from .primitive import Primitive, primitive
 from .printer import GraphPrinter, format_graph
+from .program import CompiledProgram, FlatIOSignature
 from .tracer import TracedFunction, TraceObject, Tracer, trace
 from .typing import MPType, ScalarType, SSType, TableType, TensorType, VectorType
 
@@ -65,7 +66,9 @@ TensorObject = Object[TensorType]
 VectorObject = Object[VectorType]
 
 __all__ = [
+    "CompiledProgram",
     "Context",
+    "FlatIOSignature",
     "Graph",
     "GraphPrinter",
     "MPObject",

mplang/edsl/program.py

@@ -0,0 +1,134 @@
+# Copyright 2026 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 hashlib
+import json
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from mplang.edsl import serde
+from mplang.edsl.graph import Graph
+
+
+@dataclass(frozen=True)
+class FlatIOSignature:
+    """Portable I/O signature for source-free execution.
+
+    Only supports flat positional inputs/outputs corresponding to
+    `graph.inputs` / `graph.outputs`.
+    """
+
+    kind: ClassVar[str] = "flat_list_v0"
+    input_arity: int
+    output_arity: int
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "input_arity": self.input_arity,
+            "output_arity": self.output_arity,
+        }
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> FlatIOSignature:
+        if data.get("kind") != cls.kind:
+            raise ValueError(f"Unsupported signature kind: {data.get('kind')}")
+        return cls(
+            input_arity=int(data["input_arity"]),
+            output_arity=int(data["output_arity"]),
+        )
+
+
+@serde.register_class
+@dataclass
+class CompiledProgram:
+    """Executable program decoupled from user source.
+
+    This is a *logical model*; packaging (file/zip/etc.) is handled by tool layer.
+
+    Current constraints:
+    - signature is flat positional list I/O.
+    - no closure captures.
+    - no constant outputs (out_imms) unless future signature captures them.
+    """
+
+    _serde_kind: ClassVar[str] = "mplang.CompiledProgram"
+
+    graph: Graph
+    signature: FlatIOSignature
+    required_opcodes: list[str]
+    graph_digest: str
+    required_world_size: int | None = None
+    created_at: str | None = None
+    mplang_version: str | None = None
+    schema_version: int = 1
+    name: str | None = None
+
+    def to_json(self) -> dict[str, Any]:
+        return {
+            "schema_version": self.schema_version,
+            "name": self.name,
+            "graph": serde.to_json(self.graph),
+            "signature": self.signature.to_json(),
+            "required_opcodes": list(self.required_opcodes),
+            "graph_digest": self.graph_digest,
+            "required_world_size": self.required_world_size,
+            "created_at": self.created_at,
+            "mplang_version": self.mplang_version,
+        }
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> CompiledProgram:
+        if "schema_version" not in data:
+            raise KeyError("Missing required field: schema_version")
+        schema_version = int(data["schema_version"])
+        if schema_version != 1:
+            raise ValueError(
+                f"Unsupported CompiledProgram schema_version: {schema_version}"
+            )
+
+        graph = serde.from_json(data["graph"])
+        if not isinstance(graph, Graph):
+            raise TypeError(
+                f"Expected graph to deserialize to Graph, got {type(graph).__name__}"
+            )
+
+        signature = FlatIOSignature.from_json(data["signature"])
+
+        required_world_size = data.get("required_world_size")
+        if required_world_size is not None:
+            required_world_size = int(required_world_size)
+        return cls(
+            graph=graph,
+            signature=signature,
+            required_opcodes=list(data.get("required_opcodes", [])),
+            graph_digest=str(data["graph_digest"]),
+            required_world_size=required_world_size,
+            created_at=data.get("created_at"),
+            mplang_version=data.get("mplang_version"),
+            schema_version=schema_version,
+            name=data.get("name"),
+        )
+
+
+def compute_graph_digest(graph: Graph) -> str:
+    """Compute a deterministic digest for a Graph.
+
+    We intentionally avoid `serde.dumps()` because it doesn't sort keys.
+    """
+
+    canonical = json.dumps(serde.to_json(graph), sort_keys=True, separators=(",", ":"))
+    return hashlib.sha256(canonical.encode("utf-8")).hexdigest()

mplang/tool/__init__.py

@@ -0,0 +1,46 @@
+# Copyright 2026 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.
+
+"""Tool-layer APIs for MPLang.
+
+This package contains utilities that are intentionally *not* part of the core
+EDSL execution surface. In particular, compile/execute decoupling lives here:
+- build a portable `CompiledProgram`
+- pack/unpack to a container format
+
+These helpers must not depend on user source code being available at execution.
+"""
+
+from __future__ import annotations
+
+from mplang.edsl.program import CompiledProgram, FlatIOSignature
+from mplang.tool.program import (
+    compile_program,
+    inspect_artifact,
+    pack,
+    pack_to_path,
+    unpack,
+    unpack_path,
+)
+
+__all__ = [
+    "CompiledProgram",
+    "FlatIOSignature",
+    "compile_program",
+    "inspect_artifact",
+    "pack",
+    "pack_to_path",
+    "unpack",
+    "unpack_path",
+]

mplang/tool/program.py

@@ -0,0 +1,335 @@
+# Copyright 2026 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 io
+import json
+import tarfile
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any, Literal
+
+import mplang
+from mplang.edsl import serde
+from mplang.edsl.graph import Graph
+from mplang.edsl.program import (
+    CompiledProgram,
+    FlatIOSignature,
+    compute_graph_digest,
+)
+from mplang.edsl.tracer import TracedFunction, trace
+
+DEFAULT_MAX_ARTIFACT_JSON_BYTES = 512 * 1024 * 1024  # 512 MiB
+
+
+def _utc_now_iso() -> str:
+    return datetime.now(UTC).isoformat()
+
+
+def _iter_graphs(root: Graph) -> list[Graph]:
+    # Use an explicit stack to avoid Python recursion limits.
+    # Also guard against potential region graph cycles.
+    out: list[Graph] = []
+    stack: list[Graph] = [root]
+    visited: set[int] = set()
+    while stack:
+        graph = stack.pop()
+        graph_id = id(graph)
+        if graph_id in visited:
+            continue
+        visited.add(graph_id)
+        out.append(graph)
+
+        for op in graph.operations:
+            if op.regions:
+                stack.extend(op.regions)
+
+    return out
+
+
+def _collect_opcodes(graph: Graph) -> set[str]:
+    opcodes: set[str] = set()
+    for g in _iter_graphs(graph):
+        for op in g.operations:
+            opcodes.add(op.opcode)
+    return opcodes
+
+
+def _collect_parties(graph: Graph) -> set[int]:
+    parties: set[int] = set()
+    for g in _iter_graphs(graph):
+        for op in g.operations:
+            raw = op.attrs.get("parties")
+            if raw is None:
+                continue
+
+            if not isinstance(raw, (list, tuple, set)):
+                raise TypeError(
+                    "Invalid 'parties' attribute: expected list/tuple/set of ints, "
+                    f"got {type(raw).__name__}"
+                )
+            for p in raw:
+                p_int = int(p)
+                if p_int < 0:
+                    raise ValueError("Invalid 'parties' attribute: negative party id")
+                parties.add(p_int)
+    return parties
+
+
+def _compute_required_world_size(graph: Graph) -> int:
+    parties = _collect_parties(graph)
+    if not parties:
+        return 0
+    return max(parties) + 1
+
+
+def _validate_traced_for_artifact(traced: TracedFunction) -> None:
+    # Restriction: no closure captures
+    if traced.captured:
+        raise ValueError(
+            "CompiledProgram does not support closure captures; "
+            "please refactor to pass all values explicitly."
+        )
+
+    # Restriction: no constant outputs (out_imms)
+    if traced.out_imms:
+        raise ValueError(
+            "CompiledProgram does not support constant outputs (out_imms); "
+            "return only traced values (graph outputs)."
+        )
+
+    # Restriction: signature is flat positional list I/O.
+    # We do not preserve (args, kwargs) pytree metadata.
+    # We therefore require all runtime-provided inputs correspond exactly to graph.inputs.
+    if len(traced.graph.inputs) != len(traced.in_var_pos):
+        raise ValueError(
+            "CompiledProgram requires flat positional inputs that map 1:1 to graph.inputs; "
+            f"got graph.inputs={len(traced.graph.inputs)} but in_var_pos={len(traced.in_var_pos)}."
+        )
+
+
+def _validate_program(program: CompiledProgram) -> None:
+    if program.signature.kind != FlatIOSignature.kind:
+        raise ValueError(f"Unsupported signature kind: {program.signature.kind}")
+
+    if program.signature.input_arity != len(program.graph.inputs):
+        raise ValueError(
+            "Signature input_arity does not match graph.inputs: "
+            f"input_arity={program.signature.input_arity}, inputs={len(program.graph.inputs)}"
+        )
+    if program.signature.output_arity != len(program.graph.outputs):
+        raise ValueError(
+            "Signature output_arity does not match graph.outputs: "
+            f"output_arity={program.signature.output_arity}, outputs={len(program.graph.outputs)}"
+        )
+
+    expected_opcodes = sorted(_collect_opcodes(program.graph))
+    if sorted(program.required_opcodes) != expected_opcodes:
+        raise ValueError(
+            "required_opcodes mismatch with graph content; "
+            "artifact may be corrupted or constructed inconsistently."
+        )
+
+    actual_digest = compute_graph_digest(program.graph)
+    if program.graph_digest and program.graph_digest != actual_digest:
+        raise ValueError(
+            "Graph digest mismatch: "
+            f"expected={program.graph_digest}, actual={actual_digest}"
+        )
+
+    expected_world_size = _compute_required_world_size(program.graph)
+    if (
+        program.required_world_size is not None
+        and program.required_world_size != expected_world_size
+    ):
+        raise ValueError(
+            "required_world_size mismatch with graph content; "
+            f"expected={expected_world_size}, got={program.required_world_size}."
+        )
+
+    # Ensure JSON serialization works (fail fast for non-serde attrs).
+    serde.to_json(program)
+
+
+def compile_program(
+    fn_or_traced: Any,
+    *args: Any,
+    context: Any | None = None,
+    name: str | None = None,
+    **kwargs: Any,
+) -> CompiledProgram:
+    """Compile (trace) into a source-free executable `CompiledProgram`.
+
+    Restrictions (enforced):
+    - no closure captures
+    - no constant outputs (`out_imms` must be empty)
+    - signature is flat list (positional) I/O
+
+    Note: `in_imms` (compile-time constants) are allowed: they are baked into the graph.
+    """
+
+    traced: TracedFunction
+    if isinstance(fn_or_traced, TracedFunction):
+        traced = fn_or_traced
+    else:
+        if context is not None:
+            with context:
+                traced = trace(fn_or_traced, *args, **kwargs)
+        else:
+            traced = trace(fn_or_traced, *args, **kwargs)
+
+    _validate_traced_for_artifact(traced)
+
+    signature = FlatIOSignature(
+        input_arity=len(traced.graph.inputs),
+        output_arity=len(traced.graph.outputs),
+    )
+
+    required_opcodes = sorted(_collect_opcodes(traced.graph))
+    graph_digest = compute_graph_digest(traced.graph)
+    required_world_size = _compute_required_world_size(traced.graph)
+
+    program = CompiledProgram(
+        graph=traced.graph,
+        signature=signature,
+        required_opcodes=required_opcodes,
+        graph_digest=graph_digest,
+        required_world_size=required_world_size,
+        created_at=_utc_now_iso(),
+        mplang_version=getattr(mplang, "__version__", None),
+        name=name or traced.name,
+    )
+    return program
+
+
+def pack(program: CompiledProgram, *, compress: bool = True) -> bytes:
+    """Pack a `CompiledProgram` into portable bytes.
+
+    Container format (recommended): a `tar.gz` archive containing a single
+    human-readable JSON file `artifact.json`.
+
+    This allows users to inspect artifacts via:
+        `tar -xzf program.tar.gz && cat artifact.json`
+
+    If `compress=False`, returns an uncompressed tar archive (still extractable
+    via `tar -xf`).
+    """
+
+    artifact_json = json.dumps(
+        serde.to_json(program),
+        ensure_ascii=False,
+        indent=2,
+        sort_keys=True,
+    ).encode("utf-8")
+
+    buf = io.BytesIO()
+    mode: Literal["w:gz", "w"] = "w:gz" if compress else "w"
+    with tarfile.open(fileobj=buf, mode=mode) as tf:
+        info = tarfile.TarInfo(name="artifact.json")
+        info.size = len(artifact_json)
+        tf.addfile(info, io.BytesIO(artifact_json))
+
+    return buf.getvalue()
+
+
+def pack_to_path(
+    program: CompiledProgram, path: str | Path, *, compress: bool = True
+) -> Path:
+    """Pack and write artifact to disk.
+
+    Args:
+        program: Program to pack.
+        path: Output path (typically ends with `.tar.gz`).
+        compress: Whether to gzip the tar archive.
+
+    Returns:
+        The resolved output path.
+    """
+
+    out_path = Path(path).expanduser().resolve()
+    out_path.write_bytes(pack(program, compress=compress))
+    return out_path
+
+
+def unpack(
+    data: bytes, *, max_artifact_json_bytes: int = DEFAULT_MAX_ARTIFACT_JSON_BYTES
+) -> CompiledProgram:
+    """Unpack bytes into a `CompiledProgram`.
+
+    Supported container format: tar(.gz) containing `artifact.json`.
+    """
+
+    try:
+        with tarfile.open(fileobj=io.BytesIO(data), mode="r:*") as tf:
+            member = tf.getmember("artifact.json")
+
+            if not member.isfile():
+                raise ValueError("artifact.json is not a regular file")
+
+            if member.size < 0:
+                raise ValueError("Invalid artifact.json size in tar header")
+
+            if member.size > max_artifact_json_bytes:
+                raise ValueError(
+                    "artifact.json is too large to unpack safely: "
+                    f"size={member.size} bytes, limit={max_artifact_json_bytes} bytes"
+                )
+
+            f = tf.extractfile(member)
+            if f is None:
+                raise ValueError("artifact.json not found in tar archive")
+            payload = json.loads(f.read().decode("utf-8"))
+    except (tarfile.ReadError, KeyError, OSError, json.JSONDecodeError) as exc:
+        raise ValueError(
+            "Invalid artifact container: expected tar(.gz) with artifact.json"
+        ) from exc
+
+    program = serde.from_json(payload)
+    if not isinstance(program, CompiledProgram):
+        raise TypeError(
+            f"Expected artifact.json to deserialize to CompiledProgram, got {type(program).__name__}"
+        )
+
+    _validate_program(program)
+    return program
+
+
+def unpack_path(path: str | Path) -> CompiledProgram:
+    """Read an artifact from disk and unpack it."""
+
+    in_path = Path(path).expanduser().resolve()
+    return unpack(in_path.read_bytes())
+
+
+def inspect_artifact(data: bytes) -> dict[str, Any]:
+    """Return a JSON-friendly inspection report without executing."""
+
+    program = unpack(data)
+    return {
+        "schema_version": program.schema_version,
+        "name": program.name,
+        "mplang_version": program.mplang_version,
+        "created_at": program.created_at,
+        "graph_digest": program.graph_digest,
+        "required_world_size": program.required_world_size,
+        "signature": program.signature.to_json(),
+        "required_opcodes": program.required_opcodes,
+        "graph": {
+            "inputs": len(program.graph.inputs),
+            "ops": len(program.graph.operations),
+            "outputs": len(program.graph.outputs),
+            "region_count": sum(len(op.regions) for op in program.graph.operations),
+        },
+    }

{mplang_nightly-0.1.dev278.dist-info → mplang_nightly-0.1.dev279.dist-info}/METADATA

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

{mplang_nightly-0.1.dev278.dist-info → mplang_nightly-0.1.dev279.dist-info}/RECORD

@@ -1,4 +1,4 @@
-mplang/__init__.py,sha256=QzbdmzTomqQwTZmLKayovb2cl2qcFVzvM_qxlfFfRQ0,13607
+mplang/__init__.py,sha256=PsUcGqKGQym3N_CU1Rav304YQwGVj8CLVx9S_6UTD9c,14519
 mplang/cli.py,sha256=NW0GmxZeRC4rrYg8RVBlZiDjkihBXGcHmrll-JFOqWM,20317
 mplang/cli_guide.md,sha256=hKC6AKgJn-lM_wZ0CzZIP2QUBxGPnT0Op_1YyeUhCfI,3581
 mplang/logging_config.py,sha256=6Zm1Z_EBnzxAfeKr94xiLpWYDD8fa4ZEs2g_kMoH8eI,7579
@@ -42,13 +42,14 @@ mplang/dialects/table.py,sha256=i9ruyh91_tSWu9rsLomrBUfqRdbHiZMMMJzNKfMrAUc,1353
 mplang/dialects/tee.py,sha256=BMFSbeK-Ck2jQP4qY9bZeNYTxEa7uEtUWLZLC4BPQxk,10111
 mplang/dialects/tensor.py,sha256=7aAYKaMaFjJ8N25yPFnmVhUuUdKJYy-M-a4NsZGE7kY,39893
 mplang/edsl/README.md,sha256=viflvdRojOa6Xk_UMRPqpuPGXcPGmdlv2-XR6LO7B58,7592
-mplang/edsl/__init__.py,sha256=ARYS7FkkSXwjWCsPLtWc9kL5OaR4wd5zCQhFTkzZUp0,2598
+mplang/edsl/__init__.py,sha256=WL4efo6uY1br781_8IaCkSi7yCUldcfJfbtFsn6Fdj4,2698
 mplang/edsl/context.py,sha256=Ln8n3bDe8_ISe42TAGzUuz8fw57-tu1APuihMfAtW1Y,10075
 mplang/edsl/graph.py,sha256=nCeCN7-bxfzyv40fmxcEXOaVUx14cOCaHfFb7A9OBnE,14968
 mplang/edsl/jit.py,sha256=7eLZHoIuL5FZo9G5eF9nI4EeayLK-OvJ0NoH3VG5vLI,2393
 mplang/edsl/object.py,sha256=dBl58q-ondjpjPNBh8zZvIEj6pJw2yEoz6TCaM_oleA,1906
 mplang/edsl/primitive.py,sha256=gDrn4FH682DUOgTqcQ2-9aqDYJau9L8E1ElswyOmmdw,10859
 mplang/edsl/printer.py,sha256=drmfRkdCNqbkRfSDmejxtO-rEAaM13QyHB3AbAmKVFk,4393
+mplang/edsl/program.py,sha256=_JdEU2-nb79VlFLcgMJf4JS30TARBeUIzno0y0SFVsg,4467
 mplang/edsl/registry.py,sha256=hudXZPUrUUueEwgksDKN0cnE3iiXucuTaDdDK8uSPmk,6822
 mplang/edsl/serde.py,sha256=8K94laE8ObeGuBoF6m7g3A-xEe98EvqQ_6ZPPspddAY,11641
 mplang/edsl/tracer.py,sha256=EWN3eMVRG-CZsamTyINOnhhEUKhgd4CYwFMWeRpjycU,23129
@@ -94,10 +95,12 @@ mplang/runtime/dialect_state.py,sha256=HxO1i4kSOujS2tQzAF9-WmI3nChSaGgupf2_07dHe
 mplang/runtime/interpreter.py,sha256=wcCWXpAGylqdw_HecR4suJtwmozHLrK5x6Q8xM-Pn24,43593
 mplang/runtime/object_store.py,sha256=yT6jtKG2GUEJVmpq3gnQ8mCMvUFYzgBciC5A-J5KRdk,5998
 mplang/runtime/value.py,sha256=EqlhSgxLTJi_FF3ppyKjMe4eHS6-ROx-zK1YesG1U4o,4311
+mplang/tool/__init__.py,sha256=9K-T50W_vClUlyERcVx5xGZaeyv0Ts63SaQX6AZtjIs,1341
+mplang/tool/program.py,sha256=W3H8bpPirnoJ4ZrmyPYuMCPadJis20o__n_1MKqCsWU,11058
 mplang/utils/__init__.py,sha256=toubeyISiT6WDdITdfAvdY2iXVZU3PKVNWVeC9sYxuA,947
 mplang/utils/func_utils.py,sha256=aZ-X43w8JKJgiF-IUMS0G7QqrNeoTM5ZPzRNd-tKxpw,5180
-mplang_nightly-0.1.dev278.dist-info/METADATA,sha256=_Oqywn7lgVIsrzHL__BPIIq8WUu-W1a2YWiweqrTDOE,16783
-mplang_nightly-0.1.dev278.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mplang_nightly-0.1.dev278.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev278.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev278.dist-info/RECORD,,
+mplang_nightly-0.1.dev279.dist-info/METADATA,sha256=Q4l1RV5WC5NfRV0heHxzHH8qVf3CkjOi6Ag1kbvsX38,16783
+mplang_nightly-0.1.dev279.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mplang_nightly-0.1.dev279.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev279.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev279.dist-info/RECORD,,