mplang-nightly 0.1.dev285__py3-none-any.whl → 0.1.dev287__py3-none-any.whl

mplang/backends/simp_worker/collective_algorithms.py

@@ -0,0 +1,228 @@
+# 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.
+
+"""Collective communication algorithms (communicator-only).
+
+This module contains *pure* collective algorithms implemented only in terms of
+(a) a communicator and (b) an explicit participant set.
+
+It intentionally does NOT depend on:
+- Interpreter execution IDs / graph keys
+- SimpWorker current_parties
+- Operation objects
+
+Callers are expected to provide a collision-free key prefix for each collective
+instance.
+"""
+
+from __future__ import annotations
+
+import operator
+from collections.abc import Callable, Sequence
+from typing import Any, Protocol
+
+
+class Communicator(Protocol):
+    """Minimal communicator interface required by the algorithms."""
+
+    rank: int
+    world_size: int
+
+    def send(
+        self, to: int, key: str, data: Any, *, is_raw_bytes: bool = False
+    ) -> None: ...
+
+    def recv(self, frm: int, key: str) -> Any: ...
+
+
+def normalize_participants(
+    comm: Communicator, participants: Sequence[int]
+) -> tuple[int, ...]:
+    ps = tuple(sorted({int(r) for r in participants}))
+    if not ps:
+        raise ValueError("participants must be non-empty")
+    if any(r < 0 or r >= comm.world_size for r in ps):
+        raise ValueError(
+            f"participants out of range: {ps}, world_size={comm.world_size}"
+        )
+    if comm.rank not in ps:
+        raise ValueError(f"rank {comm.rank} is not in participants {ps}")
+    return ps
+
+
+def barrier(
+    comm: Communicator, *, participants: Sequence[int], key_prefix: str
+) -> None:
+    """Barrier using root gather + root release."""
+
+    ps = normalize_participants(comm, participants)
+    root = ps[0]
+
+    arrive_key = f"{key_prefix}_arrive"
+    release_key = f"{key_prefix}_release"
+
+    if comm.rank != root:
+        comm.send(root, arrive_key, True)
+        comm.recv(root, release_key)
+        return
+
+    for r in ps:
+        if r == root:
+            continue
+        _ = comm.recv(r, arrive_key)
+
+    for r in ps:
+        if r == root:
+            continue
+        comm.send(r, release_key, True)
+
+
+def broadcast(
+    comm: Communicator,
+    value: Any,
+    *,
+    root: int,
+    participants: Sequence[int],
+    key_prefix: str,
+) -> Any:
+    """Broadcast a value from root to all participants."""
+
+    ps = normalize_participants(comm, participants)
+    if root not in ps:
+        raise ValueError(f"root {root} must be in participants {ps}")
+
+    bcast_key = f"{key_prefix}_bcast"
+
+    if comm.rank == root:
+        for r in ps:
+            if r == root:
+                continue
+            comm.send(r, bcast_key, value)
+        return value
+
+    return comm.recv(root, bcast_key)
+
+
+def allgather(
+    comm: Communicator, value: Any, *, participants: Sequence[int], key_prefix: str
+) -> list[Any]:
+    """Allgather implemented as gather-to-root then root broadcast."""
+
+    ps = normalize_participants(comm, participants)
+    root = ps[0]
+
+    gather_key = f"{key_prefix}_gather"
+    bcast_key = f"{key_prefix}_bcast"
+
+    if comm.rank != root:
+        comm.send(root, gather_key, value)
+        gathered = comm.recv(root, bcast_key)
+        if not isinstance(gathered, list):
+            raise TypeError(f"expected list from root broadcast, got {type(gathered)}")
+        return gathered
+
+    values_by_rank: dict[int, Any] = {root: value}
+    for r in ps:
+        if r == root:
+            continue
+        values_by_rank[r] = comm.recv(r, gather_key)
+
+    gathered = [values_by_rank[r] for r in ps]
+
+    for r in ps:
+        if r == root:
+            continue
+        comm.send(r, bcast_key, gathered)
+
+    return gathered
+
+
+def allreduce_bool_and(
+    comm: Communicator,
+    value: bool,
+    *,
+    participants: Sequence[int],
+    key_prefix: str,
+) -> bool:
+    return _allreduce_bool(
+        comm,
+        value,
+        participants=participants,
+        key_prefix=key_prefix,
+        combine=operator.and_,
+    )
+
+
+def allreduce_bool_or(
+    comm: Communicator,
+    value: bool,
+    *,
+    participants: Sequence[int],
+    key_prefix: str,
+) -> bool:
+    return _allreduce_bool(
+        comm,
+        value,
+        participants=participants,
+        key_prefix=key_prefix,
+        combine=operator.or_,
+    )
+
+
+def allreduce_bool_xor(
+    comm: Communicator,
+    value: bool,
+    *,
+    participants: Sequence[int],
+    key_prefix: str,
+) -> bool:
+    return _allreduce_bool(
+        comm,
+        value,
+        participants=participants,
+        key_prefix=key_prefix,
+        combine=operator.xor,
+    )
+
+
+def _allreduce_bool(
+    comm: Communicator,
+    value: bool,
+    *,
+    participants: Sequence[int],
+    key_prefix: str,
+    combine: Callable[[bool, bool], bool],
+) -> bool:
+    ps = normalize_participants(comm, participants)
+    root = ps[0]
+
+    gather_key = f"{key_prefix}_gather"
+    bcast_key = f"{key_prefix}_bcast"
+
+    if comm.rank != root:
+        comm.send(root, gather_key, bool(value))
+        return bool(comm.recv(root, bcast_key))
+
+    acc = bool(value)
+    for r in ps:
+        if r == root:
+            continue
+        acc = combine(acc, bool(comm.recv(r, gather_key)))
+
+    for r in ps:
+        if r == root:
+            continue
+        comm.send(r, bcast_key, acc)
+
+    return acc

mplang/backends/simp_worker/collectives.py

@@ -0,0 +1,275 @@
+# 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.
+
+"""Simp worker-side collectives (wrapper layer).
+
+This module is the *context-aware wrapper* on top of
+`mplang.backends.simp_worker.collective_algorithms`.
+
+Responsibilities here:
+- Resolve "participants" from (explicit arg / op.attrs["parties"] /
+  worker.current_parties / world).
+- Build collision-free `key_prefix` using interpreter execution IDs.
+
+The underlying algorithms only depend on the communicator interface.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Protocol
+
+from mplang.backends.simp_worker import collective_algorithms as algo
+from mplang.edsl.graph import Operation
+
+
+class _ExecContext(Protocol):
+    def current_op_exec_id(self) -> int: ...
+
+    def current_graph_exec_key(self) -> str: ...
+
+
+class _Worker(Protocol):
+    rank: int
+    world_size: int
+    communicator: algo.Communicator
+    current_parties: tuple[int, ...] | None
+
+
+def resolve_participants(
+    worker: _Worker,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+) -> Sequence[int]:
+    """Resolve participant ranks.
+
+    Priority:
+    1) explicit participants argument
+    2) op.attrs["parties"] if present
+    3) worker.current_parties if set (pcall_static dynamic scope)
+    4) all ranks [0, world_size)
+
+    Note:
+        Normalization/validation (sorting, emptiness, range checks, rank
+        inclusion) is intentionally delegated to the lower-level algorithms in
+        `collective_algorithms`.
+    """
+
+    if participants is not None:
+        return participants
+
+    if op is not None:
+        parties = op.attrs.get("parties")
+        if parties is not None:
+            if not isinstance(parties, Sequence):
+                raise TypeError(
+                    "op.attrs['parties'] must be a sequence of rank integers"
+                )
+            return tuple(int(r) for r in parties)
+
+    if worker.current_parties is not None:
+        return worker.current_parties
+
+    return tuple(range(worker.world_size))
+
+
+def _collective_prefix(
+    interpreter: _ExecContext, *, op: Operation | None, name: str
+) -> str:
+    exec_id = interpreter.current_op_exec_id()
+    graph_key = interpreter.current_graph_exec_key()
+    op_name = op.name if op is not None else "_"
+    return f"coll_{graph_key}_{op_name}_{exec_id}_{name}"
+
+
+def barrier(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "barrier",
+) -> None:
+    ps = resolve_participants(worker, op=op, participants=participants)
+    prefix = _collective_prefix(interpreter, op=op, name=name)
+    algo.barrier(worker.communicator, participants=ps, key_prefix=prefix)
+
+
+def broadcast(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    value: Any,
+    *,
+    root: int,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "broadcast",
+) -> Any:
+    ps = resolve_participants(worker, op=op, participants=participants)
+    prefix = _collective_prefix(interpreter, op=op, name=name)
+    return algo.broadcast(
+        worker.communicator,
+        value,
+        root=int(root),
+        participants=ps,
+        key_prefix=prefix,
+    )
+
+
+def allgather_obj(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    value: Any,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "allgather_obj",
+) -> list[Any]:
+    ps = resolve_participants(worker, op=op, participants=participants)
+    prefix = _collective_prefix(interpreter, op=op, name=name)
+    return algo.allgather(
+        worker.communicator, value, participants=ps, key_prefix=prefix
+    )
+
+
+def allgather_bool(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    value: bool,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "allgather_bool",
+) -> list[bool]:
+    gathered = allgather_obj(
+        interpreter,
+        worker,
+        bool(value),
+        op=op,
+        participants=participants,
+        name=name,
+    )
+    return [bool(v) for v in gathered]
+
+
+def allreduce_bool_and(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    value: bool,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "allreduce_bool_and",
+) -> bool:
+    ps = resolve_participants(worker, op=op, participants=participants)
+    prefix = _collective_prefix(interpreter, op=op, name=name)
+    return algo.allreduce_bool_and(
+        worker.communicator,
+        bool(value),
+        participants=ps,
+        key_prefix=prefix,
+    )
+
+
+def allreduce_bool_or(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    value: bool,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "allreduce_bool_or",
+) -> bool:
+    ps = resolve_participants(worker, op=op, participants=participants)
+    prefix = _collective_prefix(interpreter, op=op, name=name)
+    return algo.allreduce_bool_or(
+        worker.communicator,
+        bool(value),
+        participants=ps,
+        key_prefix=prefix,
+    )
+
+
+def allreduce_bool_xor(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    value: bool,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "allreduce_bool_xor",
+) -> bool:
+    ps = resolve_participants(worker, op=op, participants=participants)
+    prefix = _collective_prefix(interpreter, op=op, name=name)
+    return algo.allreduce_bool_xor(
+        worker.communicator,
+        bool(value),
+        participants=ps,
+        key_prefix=prefix,
+    )
+
+
+def verify_uniform_predicate(
+    interpreter: _ExecContext,
+    worker: _Worker,
+    pred: bool,
+    *,
+    op: Operation | None = None,
+    participants: Sequence[int] | None = None,
+    name: str = "uniform_predicate",
+) -> bool:
+    """Verify that `pred` is uniform across participants.
+
+    Uses AND/OR all-reduce to detect mismatch. If mismatch is detected, runs an
+    allgather to provide a helpful error message. All participants execute the
+    same comm steps to avoid deadlocks.
+    """
+
+    ps = resolve_participants(worker, op=op, participants=participants)
+
+    all_and = allreduce_bool_and(
+        interpreter,
+        worker,
+        bool(pred),
+        op=op,
+        participants=ps,
+        name=f"{name}_and",
+    )
+    all_or = allreduce_bool_or(
+        interpreter,
+        worker,
+        bool(pred),
+        op=op,
+        participants=ps,
+        name=f"{name}_or",
+    )
+
+    if all_and != all_or:
+        gathered = allgather_bool(
+            interpreter,
+            worker,
+            bool(pred),
+            op=op,
+            participants=ps,
+            name=f"{name}_gather",
+        )
+        ps_norm = algo.normalize_participants(worker.communicator, ps)
+        dist = dict(zip(ps_norm, gathered, strict=True))
+        raise RuntimeError(
+            "simp.uniform_cond predicate is not uniform across participants: "
+            f"participants={ps_norm}, values={dist}"
+        )
+
+    return bool(pred)

mplang/backends/simp_worker/ops.py

@@ -22,6 +22,7 @@ from __future__ import annotations
 
 from typing import Any
 
+from mplang.backends.simp_worker.collectives import verify_uniform_predicate
 from mplang.dialects import simp
 from mplang.edsl.graph import Operation
 from mplang.runtime.interpreter import Interpreter
@@ -117,12 +118,14 @@ def _uniform_cond_worker_impl(
     """Worker implementation of simp.uniform_cond."""
     from mplang.backends.tensor_impl import TensorValue
 
-    if op.attrs.get("verify_uniform", True):
-        pass  # TODO: Implement AllReduce verification
+    worker = _ensure_worker_context(interpreter, "uniform_cond_impl")
 
     if isinstance(pred, TensorValue):
         pred = bool(pred.unwrap())
 
+    if op.attrs.get("verify_uniform", True):
+        pred = verify_uniform_predicate(interpreter, worker, bool(pred), op=op)
+
     if pred:
         result = interpreter.evaluate_graph(op.regions[0], list(args))
     else:

mplang/edsl/typing.py

@@ -82,11 +82,18 @@ underlying HE libraries.
     - **Core Type**: `Tensor[Scalar, ...]`
     - **API Standard**: Follows NumPy/JAX conventions. All layout and arithmetic operations are valid.
 
+-   **World 2: The Element-wise HE World**
     - **Core Type**: `Tensor[EncryptedScalar, ...]` (e.g., `Tensor[phe.CiphertextType, ...]`)
     - **API Standard**: Follows TenSEAL-like (Tensor-level) conventions. Layout operations
       (`transpose`, `reshape`) are valid as they merely shuffle independent ciphertext objects.
       Arithmetic operations are overloaded for element-wise HE computation.
 
+-   **World 3: The SIMD HE World**
+    - **Core Type**: `Tensor[Vector[...], ...]` where the inner `Vector` holds SIMD-encrypted slots
+    - **API Standard**: SIMD-HE specific (e.g., BFV/CKKS). Only specific operations are supported
+      due to the batched nature of SIMD encryption. Layout operations must account for slot packing,
+      and arithmetic operates on batched ciphertexts with slot-wise semantics.
+
 ===========================
 Principle 3: Contracts via Protocols
 ===========================
@@ -137,7 +144,15 @@ class BaseType:
     """Base class for all MPLang types."""
 
     def __repr__(self) -> str:
-        return str(self)
+        # Prevent infinite recursion: only call __str__ if it's overridden
+        if type(self).__str__ is not BaseType.__str__:
+            return str(self)
+        # Fallback to default object repr if __str__ not implemented
+        return object.__repr__(self)
+
+    def __str__(self) -> str:
+        # Default implementation for subclasses that don't override
+        return f"{self.__class__.__name__}()"
 
 
 # ==============================================================================
@@ -175,11 +190,11 @@ class ScalarType(BaseType):
 
 @serde.register_class
 class IntegerType(ScalarType):
-    """Represents a variable-length integer type.
+    """Represents a fixed-width integer type with configurable bitwidth.
 
-    This is a standard integer type with configurable bit width, used for
-    arbitrary-precision arithmetic. It can represent integers that exceed
-    the range of fixed-width types like i64.
+    This is a standard integer type with parameterized bit width, used for
+    arbitrary-precision arithmetic. By configuring larger bitwidths (e.g., 128, 256),
+    this type can represent integers that exceed the range of standard types like i64.
 
     Examples:
         >>> i128 = IntegerType(bitwidth=128, signed=True)  # i128
@@ -229,15 +244,16 @@ class IntegerType(ScalarType):
 
 @serde.register_class
 class FloatType(ScalarType):
-    """Represents a floating-point type.
+    """Represents a fixed-width floating-point type with configurable bitwidth.
 
-    This supports standard IEEE 754 floating-point types with configurable
-    precision (bitwidth).
+    This supports standard IEEE 754 floating-point types with parameterized
+    bit width for different precision requirements.
 
     Examples:
         >>> f16 = FloatType(bitwidth=16)  # half precision
         >>> f32 = FloatType(bitwidth=32)  # single precision
         >>> f64 = FloatType(bitwidth=64)  # double precision
+        >>> f128 = FloatType(bitwidth=128)  # quadruple precision
     """
 
     def __init__(self, *, bitwidth: int = 32):
@@ -245,7 +261,7 @@ class FloatType(ScalarType):
 
         Args:
             bitwidth: Number of bits for the float representation.
-                     Standard values: 16 (half), 32 (single), 64 (double).
+                     Standard values: 16 (half), 32 (single), 64 (double), 128 (quadruple).
         """
         if bitwidth not in (16, 32, 64, 128):
             raise ValueError(f"bitwidth must be 16, 32, 64, or 128, got {bitwidth}")

{mplang_nightly-0.1.dev285.dist-info → mplang_nightly-0.1.dev287.dist-info}/METADATA

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

{mplang_nightly-0.1.dev285.dist-info → mplang_nightly-0.1.dev287.dist-info}/RECORD

@@ -23,9 +23,11 @@ mplang/backends/simp_driver/ops.py,sha256=WYObWDRCsiXH0UBWZX5vD5W98ZPkd88U_qBV8S
 mplang/backends/simp_driver/state.py,sha256=dNmYMFN2D2BBdgs6C0YLaHrfaBRMgs05UNxMWw6tZIs,1713
 mplang/backends/simp_driver/values.py,sha256=Lz1utNSIzH-dCzZAEjU6JRcxPsfKGfUJrYl6gIuMOGw,1509
 mplang/backends/simp_worker/__init__.py,sha256=gdrSY1-MDkupCoJ8xwwH7em7fgVWv3J4gBJ45uHdzgg,961
+mplang/backends/simp_worker/collective_algorithms.py,sha256=tjqQrXRpV71g7uKBGlITLM29VjsnYfBr7MBfx1uKzvM,5707
+mplang/backends/simp_worker/collectives.py,sha256=Jzo-eU4QXM8zXfbUdb0xvghh6LWDSfUsxglSYi3oGY8,7688
 mplang/backends/simp_worker/http.py,sha256=UiqXKcH5DZG_eTXcW7qDSjIsBWtA37tkqBEowJJ0hQE,13186
 mplang/backends/simp_worker/mem.py,sha256=hLJftzSMQIw64vjBdrSrFReFzWS6rlzf-0Q7SWkfhak,3605
-mplang/backends/simp_worker/ops.py,sha256=ntxfkD4e6Il4w7FshK1ODcUCUPMlipt33pDY_x5iC0U,5661
+mplang/backends/simp_worker/ops.py,sha256=qMfXH9lUc9nq9paWa-53XgDZQcL29nDF6Qt9XwKouQ0,5834
 mplang/backends/simp_worker/state.py,sha256=nIu0ybvdYqRqp0TkoSneUF2u31evDHucCRduVBaDals,1445
 mplang/dialects/__init__.py,sha256=CYMmkeQVU0Znr9n3_5clZKb16u7acJ5jl5Zjbx4Tn1U,1478
 mplang/dialects/bfv.py,sha256=m5YfobFCBqn0lg2zBM9RNs2AC7i4PUQH2qXjHLHwSy4,22332
@@ -52,7 +54,7 @@ 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=WQFNL2ZgXSLjxD4JA7cXIDUKIQXe3aZ94qer57IKPXc,23128
-mplang/edsl/typing.py,sha256=Hmn_w04XWepmvurN1ZEb6rVNW1kW9bOBYe3AkD8CAJc,29283
+mplang/edsl/typing.py,sha256=23DjgISpJO7ofG1qZeWFJ8hl6Au_OLw4qlgWSOuujh4,30352
 mplang/kernels/Makefile,sha256=5PoPpajcb_8ByPGNHzVytmovXUwkjJs_K8MbXX9qDYs,1033
 mplang/kernels/__init__.py,sha256=J_rDl9lAXd7QL3Nt_P3YX6j9yge7ssguSaHuafPZNKE,876
 mplang/kernels/gf128.cpp,sha256=WIvCr3MijzwJxMi1Wnfhm8aWT8oL0fia6FeyTmFJtPQ,5975
@@ -99,8 +101,8 @@ mplang/tool/program.py,sha256=W3H8bpPirnoJ4ZrmyPYuMCPadJis20o__n_1MKqCsWU,11058
 mplang/utils/__init__.py,sha256=Hwrwti2nfPxWUXV8DN6T1QaqXH_Jsd27k8UMSdBGUns,1073
 mplang/utils/func_utils.py,sha256=aZ-X43w8JKJgiF-IUMS0G7QqrNeoTM5ZPzRNd-tKxpw,5180
 mplang/utils/logging.py,sha256=9dMhwprVbx1WMGJrgoQbWmV50vyYuLU4NSPnetcl1Go,7237
-mplang_nightly-0.1.dev285.dist-info/METADATA,sha256=cXD5_vMkz7YYbixonHu4GN49cnfgzuGgaofeV2VJ9z4,16783
-mplang_nightly-0.1.dev285.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-mplang_nightly-0.1.dev285.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev285.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev285.dist-info/RECORD,,
+mplang_nightly-0.1.dev287.dist-info/METADATA,sha256=pWxy2dwWffgYSrLRrMGLLkScZjVroOEgBI8YDa0YfGQ,16783
+mplang_nightly-0.1.dev287.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+mplang_nightly-0.1.dev287.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev287.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev287.dist-info/RECORD,,