mplang-nightly 0.1.dev170__tar.gz → 0.1.dev171__tar.gz

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/PKG-INFO

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

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/core/expr/printer.py

@@ -164,13 +164,9 @@ class Printer(ExprVisitor):
         arg_names = [self._var_name(arg) for arg in expr.args]
         fn_type = expr.pfunc.fn_type
 
-        # for well known builtin functions
-        if fn_type == "builtin.constant":
+        # for well known basic functions
+        if fn_type == "basic.constant":
             return self._print_const(expr.pfunc, expr.mptypes)
-        elif fn_type == "builtin.rank":
-            return self._do_print("prank", [], mptypes=expr.mptypes)
-        elif fn_type == "builtin.prand":
-            return self._do_print("prand", [], mptypes=expr.mptypes)
 
         attrs = {"fn_type": fn_type}
         if expr.pfunc.fn_name:

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/core/pfunc.py

@@ -33,7 +33,7 @@ class PFunction:
 
     PFunction serves as a unified interface for describing single-party computations
     in multi-party computing scenarios. It can represent both:
-    1. Built-in operations (e.g., "spu.makeshares", "builtin.read")
+    1. Built-in operations (e.g., "spu.makeshares", "basic.read")
     2. User-defined programmable functions with custom code
 
     The PFunction accepts a list of typed inputs (TensorType/TableType). For
@@ -47,7 +47,7 @@ class PFunction:
 
     Args:
         fn_type: The type/category identifier of this PFunction, indicating which
-            backend or handler should process it (e.g., "spu.makeshares", "builtin.read",
+            backend or handler should process it (e.g., "spu.makeshares", "basic.read",
             "mlir.stablehlo"). This serves as a routing mechanism for execution.
         ins_info: Type information for input parameters (TensorType or TableType)
         outs_info: Type information for output values (TensorType or TableType)

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/core/primitive.py

@@ -48,7 +48,7 @@ from mplang.core.pfunc import PFunction
 from mplang.core.table import TableLike
 from mplang.core.tensor import ScalarType, Shape, TensorLike
 from mplang.core.tracer import TraceContext, TraceVar, trace
-from mplang.ops import builtin
+from mplang.ops import basic
 from mplang.utils.func_utils import var_demorph, var_morph
 
 
@@ -133,10 +133,10 @@ def trace_before_apply(fn: Callable[P, R], make_call: bool) -> Callable[P, R]:
     return wrapped
 
 
-def primitive(fn: Callable[P, R]) -> Callable[P, R]:
+def bltin_function(fn: Callable[P, R]) -> Callable[P, R]:
     """Decorator to trace a Python function as an opaque primitive call (`CallExpr`).
 
-    When a function decorated with `@primitive` is called within a `TraceContext`, it is
+    When a function decorated with `@bltin_function` is called within a `TraceContext`, it is
     not inlined. Instead, it is traced separately in a forked context, and a `CallExpr`
     node is inserted into the main graph. This is useful for encapsulating complex
     operations or third-party library calls as single, opaque nodes.
@@ -156,7 +156,7 @@ def primitive(fn: Callable[P, R]) -> Callable[P, R]:
 
     Example:
         ```python
-        @primitive
+        @bltin_function
         def my_op(x: MPObject) -> MPObject:
             # Complex logic traced as a single CallExpr node
             return x + 1
@@ -222,7 +222,7 @@ def pmask() -> Mask:
     return _tracer().mask
 
 
-@primitive
+@bltin_function
 def prank() -> MPObject:
     """Multi-party get the rank (party identifier) of each party.
 
@@ -243,12 +243,12 @@ def prank() -> MPObject:
     Note:
         Each party in the current party mask independently produces its own rank value.
     """
-    pfunc, eval_args, out_tree = builtin.rank()
+    pfunc, eval_args, out_tree = basic.rank()
     results = peval(pfunc, eval_args)
     return out_tree.unflatten(results)  # type: ignore[no-any-return]
 
 
-@primitive
+@bltin_function
 def prand(shape: Shape = ()) -> MPObject:
     """Multi-party generate a private random (uint64) tensor with the given shape.
 
@@ -271,7 +271,7 @@ def prand(shape: Shape = ()) -> MPObject:
         private random values. The randomness is local to each party and is
         not shared or revealed to other parties.
     """
-    pfunc, eval_args, out_tree = builtin.prand(shape)
+    pfunc, eval_args, out_tree = basic.prand(shape)
     results = peval(pfunc, eval_args)
     return out_tree.unflatten(results)  # type: ignore[no-any-return]
 
@@ -305,19 +305,19 @@ def constant(data: TensorLike | ScalarType | TableLike) -> MPObject:
         Note that the constant primitive is not designed to carry large tables efficiently -
         consider using dedicated table loading mechanisms for substantial datasets.
     """
-    pfunc, eval_args, out_tree = builtin.constant(data)
+    pfunc, eval_args, out_tree = basic.constant(data)
     results = peval(pfunc, eval_args)
     return out_tree.unflatten(results)  # type: ignore[no-any-return]
 
 
-@primitive
+@bltin_function
 def debug_print(obj: MPObject, prefix: str = "") -> MPObject:
     """Print local value of obj on owning parties and pass it through.
 
     Returns the same MPObject value to keep it alive against DCE and to
     support usage like: x = debug_print(x, prefix="x=").
     """
-    pfunc, eval_args, out_tree = builtin.debug_print(obj, prefix=prefix)
+    pfunc, eval_args, out_tree = basic.debug_print(obj, prefix=prefix)
     results = peval(pfunc, eval_args)
     return out_tree.unflatten(results)  # type: ignore[no-any-return]
 
@@ -445,7 +445,7 @@ def set_mask(arg: MPObject, mask: Mask) -> MPObject:
         The underlying implementation uses JAX identity function with the
         specified execution mask.
     """
-    pfunc, eval_args, out_tree = builtin.identity(arg)
+    pfunc, eval_args, out_tree = basic.identity(arg)
     results = peval(pfunc, eval_args, mask)
     return out_tree.unflatten(results)  # type: ignore[no-any-return]
 

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/device.py

@@ -35,7 +35,7 @@ from mplang.core import InterpContext, MPObject, primitive
 from mplang.core.cluster import ClusterSpec, Device
 from mplang.core.context_mgr import cur_ctx
 from mplang.core.tensor import TensorType
-from mplang.ops import builtin, crypto, ibis_cc, jax_cc, tee
+from mplang.ops import basic, crypto, ibis_cc, jax_cc, tee
 from mplang.ops.base import FeOperation
 from mplang.ops.ibis_cc import IbisRunner
 from mplang.ops.jax_cc import JaxRunner
@@ -209,11 +209,11 @@ def _d2d(to_dev_id: str, obj: MPObject) -> MPObject:
         sess_p, sess_t = _ensure_tee_session(frm_dev_id, to_dev_id, frm_rank, tee_rank)
         # Bytes-only path: pack -> enc -> p2p -> dec -> unpack (with static out type)
         obj_ty = TensorType.from_obj(obj)
-        b = simp.runAt(frm_rank, builtin.pack)(obj)
+        b = simp.runAt(frm_rank, basic.pack)(obj)
         ct = simp.runAt(frm_rank, crypto.enc)(b, sess_p)
         ct_at_tee = mpi.p2p(frm_rank, tee_rank, ct)
         b_at_tee = simp.runAt(tee_rank, crypto.dec)(ct_at_tee, sess_t)
-        pt_at_tee = simp.runAt(tee_rank, builtin.unpack)(b_at_tee, out_ty=obj_ty)
+        pt_at_tee = simp.runAt(tee_rank, basic.unpack)(b_at_tee, out_ty=obj_ty)
         return tree_map(partial(_set_devid, dev_id=to_dev_id), pt_at_tee)  # type: ignore[no-any-return]
     elif frm_to_pair == ("TEE", "PPU"):
         # Transparent encryption from TEE to a specific PPU using the reverse-direction session key
@@ -223,11 +223,11 @@ def _d2d(to_dev_id: str, obj: MPObject) -> MPObject:
         # Ensure bidirectional session established for this pair
         sess_p, sess_t = _ensure_tee_session(to_dev_id, frm_dev_id, ppu_rank, tee_rank)
         obj_ty = TensorType.from_obj(obj)
-        b = simp.runAt(tee_rank, builtin.pack)(obj)
+        b = simp.runAt(tee_rank, basic.pack)(obj)
         ct = simp.runAt(tee_rank, crypto.enc)(b, sess_t)
         ct_at_ppu = mpi.p2p(tee_rank, ppu_rank, ct)
         b_at_ppu = simp.runAt(ppu_rank, crypto.dec)(ct_at_ppu, sess_p)
-        pt_at_ppu = simp.runAt(ppu_rank, builtin.unpack)(b_at_ppu, out_ty=obj_ty)
+        pt_at_ppu = simp.runAt(ppu_rank, basic.unpack)(b_at_ppu, out_ty=obj_ty)
         return tree_map(partial(_set_devid, dev_id=to_dev_id), pt_at_ppu)  # type: ignore[no-any-return]
     else:
         supported = [

mplang_nightly-0.1.dev170/mplang/kernels/builtin.py → mplang_nightly-0.1.dev171/mplang/kernels/basic.py

@@ -25,17 +25,17 @@ from mplang.runtime.data_providers import get_provider, resolve_uri
 from mplang.utils import table_utils
 
 
-@kernel_def("builtin.identity")
+@kernel_def("basic.identity")
 def _identity(pfunc: PFunction, value: Value) -> Value:
     # Runtime guarantees exactly one argument; no extra arity checks here.
     return value
 
 
-@kernel_def("builtin.read")
+@kernel_def("basic.read")
 def _read(pfunc: PFunction) -> Value:
     path = pfunc.attrs.get("path")
     if path is None:
-        raise ValueError("missing path attr for builtin.read")
+        raise ValueError("missing path attr for basic.read")
     out_t = pfunc.outs_info[0]
     uri = resolve_uri(str(path))
     prov = get_provider(uri.scheme)
@@ -45,7 +45,7 @@ def _read(pfunc: PFunction) -> Value:
     try:
         data = prov.read(uri, out_t, ctx=ctx)
     except Exception as e:  # pragma: no cover - provider errors
-        raise RuntimeError(f"builtin.read failed: {e}") from e
+        raise RuntimeError(f"basic.read failed: {e}") from e
 
     if isinstance(out_t, TableType):
         if isinstance(data, TableValue):
@@ -56,15 +56,15 @@ def _read(pfunc: PFunction) -> Value:
             return data
         return TensorValue(np.asarray(data))
     raise TypeError(
-        f"builtin.read only supports TableType/TensorType outputs, got {type(out_t).__name__}"
+        f"basic.read only supports TableType/TensorType outputs, got {type(out_t).__name__}"
     )
 
 
-@kernel_def("builtin.write")
+@kernel_def("basic.write")
 def _write(pfunc: PFunction, obj: Value) -> Value:
     path = pfunc.attrs.get("path")
     if path is None:
-        raise ValueError("missing path attr for builtin.write")
+        raise ValueError("missing path attr for basic.write")
     uri = resolve_uri(str(path))
     prov = get_provider(uri.scheme)
     if prov is None:
@@ -74,16 +74,16 @@ def _write(pfunc: PFunction, obj: Value) -> Value:
     try:
         prov.write(uri, obj, ctx=ctx)
     except Exception as e:  # pragma: no cover
-        raise RuntimeError(f"builtin.write failed: {e}") from e
+        raise RuntimeError(f"basic.write failed: {e}") from e
     return obj
 
 
-@kernel_def("builtin.constant")
+@kernel_def("basic.constant")
 def _constant(pfunc: PFunction) -> Value:
     """Return constants as Value types (TensorValue or TableValue)."""
     data_bytes = pfunc.attrs.get("data_bytes")
     if data_bytes is None:
-        raise ValueError("missing data_bytes attr for builtin.constant")
+        raise ValueError("missing data_bytes attr for basic.constant")
     out_t = pfunc.outs_info[0]
     fmt = pfunc.attrs.get("data_format")
     if isinstance(out_t, TableType):
@@ -98,7 +98,7 @@ def _constant(pfunc: PFunction) -> Value:
     return TensorValue(arr)
 
 
-@kernel_def("builtin.rank")
+@kernel_def("basic.rank")
 def _rank(pfunc: PFunction) -> TensorValue:
     """Return rank as TensorValue."""
     ctx = cur_kctx()
@@ -106,7 +106,7 @@ def _rank(pfunc: PFunction) -> TensorValue:
     return TensorValue(arr)
 
 
-@kernel_def("builtin.prand")
+@kernel_def("basic.prand")
 def _prand(pfunc: PFunction) -> TensorValue:
     """Return random data as TensorValue."""
     shape = pfunc.attrs.get("shape", ())
@@ -118,7 +118,7 @@ def _prand(pfunc: PFunction) -> TensorValue:
     return TensorValue(data)
 
 
-@kernel_def("builtin.table_to_tensor")
+@kernel_def("basic.table_to_tensor")
 def _table_to_tensor(pfunc: PFunction, table: TableValue) -> TensorValue:
     """Convert table to tensor, return as TensorValue."""
     arrow_table = table.to_arrow()
@@ -131,7 +131,7 @@ def _table_to_tensor(pfunc: PFunction, table: TableValue) -> TensorValue:
     return TensorValue(mat)
 
 
-@kernel_def("builtin.tensor_to_table")
+@kernel_def("basic.tensor_to_table")
 def _tensor_to_table(pfunc: PFunction, tensor: TensorValue) -> TableValue:
     """Convert tensor to table, return as TableValue."""
     import pyarrow as pa  # type: ignore
@@ -168,7 +168,7 @@ def _summ(v: Value) -> str:
         return f"<unprintable {type(v).__name__}: {e}>"
 
 
-@kernel_def("builtin.debug_print")
+@kernel_def("basic.debug_print")
 def _debug_print(pfunc: PFunction, val: Value) -> Value:
     prefix = pfunc.attrs.get("prefix", "")
     ctx = cur_kctx()
@@ -176,16 +176,16 @@ def _debug_print(pfunc: PFunction, val: Value) -> Value:
     return val
 
 
-@kernel_def("builtin.pack")
+@kernel_def("basic.pack")
 def _pack(pfunc: PFunction, value: Value) -> TensorValue:
     outs_info = pfunc.outs_info
     if len(outs_info) != 1:
-        raise ValueError("builtin.pack expects single output type")
+        raise ValueError("basic.pack expects single output type")
     out_ty = outs_info[0]
     if not isinstance(out_ty, TensorType):
-        raise TypeError("builtin.pack must return TensorType")
+        raise TypeError("basic.pack must return TensorType")
     if out_ty.dtype.numpy_dtype() != np.uint8:
-        raise TypeError("builtin.pack output dtype must be uint8")
+        raise TypeError("basic.pack output dtype must be uint8")
 
     if isinstance(value, TableValue):
         # Serialize Arrow table using IPC stream for consistency with Value serde
@@ -203,14 +203,14 @@ def _pack(pfunc: PFunction, value: Value) -> TensorValue:
         arr = value.to_numpy()
         return TensorValue(np.frombuffer(arr.tobytes(order="C"), dtype=np.uint8))
 
-    raise TypeError(f"builtin.pack does not support Value type {type(value).__name__}")
+    raise TypeError(f"basic.pack does not support Value type {type(value).__name__}")
 
 
-@kernel_def("builtin.unpack")
+@kernel_def("basic.unpack")
 def _unpack(pfunc: PFunction, packed: TensorValue) -> Value:
     outs_info = pfunc.outs_info
     if len(outs_info) != 1:
-        raise ValueError("builtin.unpack expects single output type")
+        raise ValueError("basic.unpack expects single output type")
     out_ty = outs_info[0]
 
     b = packed.to_numpy().astype(np.uint8, copy=False).reshape(-1)
@@ -219,7 +219,7 @@ def _unpack(pfunc: PFunction, packed: TensorValue) -> Value:
         np_dtype = out_ty.dtype.numpy_dtype()
         shape = tuple(out_ty.shape)
         if any(dim < 0 for dim in shape):
-            raise ValueError("builtin.unpack does not support dynamic tensor shapes")
+            raise ValueError("basic.unpack does not support dynamic tensor shapes")
         elem_count = int(np.prod(shape))
         expected = elem_count * np.dtype(np_dtype).itemsize
         if b.size != expected:
@@ -239,4 +239,4 @@ def _unpack(pfunc: PFunction, packed: TensorValue) -> Value:
         table = reader.read_all()
         return TableValue(table)
 
-    raise TypeError("builtin.unpack output type must be TensorType or TableType")
+    raise TypeError("basic.unpack output type must be TensorType or TableType")

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/kernels/context.py

@@ -35,7 +35,7 @@ def _ensure_impl_imported() -> None:
     global _IMPL_IMPORTED
     if _IMPL_IMPORTED:
         return
-    from mplang.kernels import builtin as _impl_builtin  # noqa: F401
+    from mplang.kernels import basic as _impl_basic  # noqa: F401
     from mplang.kernels import crypto as _impl_crypto  # noqa: F401
     from mplang.kernels import mock_tee as _impl_tee  # noqa: F401
     from mplang.kernels import phe as _impl_phe  # noqa: F401
@@ -49,18 +49,18 @@ def _ensure_impl_imported() -> None:
 # imports consolidated above
 
 _DEFAULT_BINDINGS: dict[str, str] = {
-    # builtin
-    "builtin.identity": "builtin.identity",
-    "builtin.read": "builtin.read",
-    "builtin.write": "builtin.write",
-    "builtin.constant": "builtin.constant",
-    "builtin.rank": "builtin.rank",
-    "builtin.prand": "builtin.prand",
-    "builtin.table_to_tensor": "builtin.table_to_tensor",
-    "builtin.tensor_to_table": "builtin.tensor_to_table",
-    "builtin.debug_print": "builtin.debug_print",
-    "builtin.pack": "builtin.pack",
-    "builtin.unpack": "builtin.unpack",
+    # basic
+    "basic.identity": "basic.identity",
+    "basic.read": "basic.read",
+    "basic.write": "basic.write",
+    "basic.constant": "basic.constant",
+    "basic.rank": "basic.rank",
+    "basic.prand": "basic.prand",
+    "basic.table_to_tensor": "basic.table_to_tensor",
+    "basic.tensor_to_table": "basic.tensor_to_table",
+    "basic.debug_print": "basic.debug_print",
+    "basic.pack": "basic.pack",
+    "basic.unpack": "basic.unpack",
     # crypto
     "crypto.keygen": "crypto.keygen",
     "crypto.enc": "crypto.enc",

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/ops/__init__.py

@@ -19,12 +19,12 @@ This module contains compilers that transform high-level functions into
 portable, serializable intermediate representations.
 """
 
-from mplang.ops import builtin, crypto, ibis_cc, jax_cc, phe, spu, sql_cc, tee
+from mplang.ops import basic, crypto, ibis_cc, jax_cc, phe, spu, sql_cc, tee
 from mplang.ops.base import FeOperation as FeOperation
 
 __all__ = [
     "FeOperation",
-    "builtin",
+    "basic",
     "crypto",
     "ibis_cc",
     "jax_cc",

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/ops/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.run", "mlir.stablehlo").
+    - Keep routing information in PFunction.fn_type (e.g., "basic.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_nightly-0.1.dev170/mplang/ops/builtin.py → mplang_nightly-0.1.dev171/mplang/ops/basic.py

@@ -23,10 +23,10 @@ from mplang.core.tensor import ScalarType, Shape, TensorLike, TensorType
 from mplang.ops.base import stateless_mod
 from mplang.utils import table_utils
 
-_BUILTIN_MOD = stateless_mod("builtin")
+_BASIC_MOD = stateless_mod("basic")
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def identity(x: TensorType) -> TensorType:
     """Return the input type unchanged.
 
@@ -40,7 +40,7 @@ def identity(x: TensorType) -> TensorType:
     return x
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def read(*, path: str, ty: TensorType) -> TensorType:
     """Declare reading a value of type ``ty`` from ``path`` (type-only).
 
@@ -63,7 +63,7 @@ def read(*, path: str, ty: TensorType) -> TensorType:
     return ty
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def write(x: TensorType, *, path: str) -> TensorType:
     """Declare writing the input value to ``path`` and return the same type.
 
@@ -77,7 +77,7 @@ def write(x: TensorType, *, path: str) -> TensorType:
     return x
 
 
-@_BUILTIN_MOD.op_def()
+@_BASIC_MOD.op_def()
 def constant(
     data: TensorLike | ScalarType | TableLike,
 ) -> tuple[PFunction, list[MPObject], PyTreeDef]:
@@ -89,7 +89,7 @@ def constant(
 
     Returns:
         Tuple[PFunction, list[MPObject], PyTreeDef]:
-        - PFunction: ``fn_type='builtin.constant'`` with one output whose type
+        - PFunction: ``fn_type='basic.constant'`` with one output whose type
             matches ``data``; payload serialized via ``data_bytes`` with
             ``data_format`` ('bytes[numpy]' or 'bytes[csv]').
         - list[MPObject]: Empty (no inputs captured).
@@ -120,7 +120,7 @@ def constant(
         data_format = "bytes[numpy]"
 
     pfunc = PFunction(
-        fn_type="builtin.constant",
+        fn_type="basic.constant",
         ins_info=(),
         outs_info=(out_type,),
         data_bytes=data_bytes,
@@ -130,7 +130,7 @@ def constant(
     return pfunc, [], treedef
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def rank() -> TensorType:
     """Return the scalar UINT64 tensor type for the current party rank.
 
@@ -140,7 +140,7 @@ def rank() -> TensorType:
     return TensorType(UINT64, ())
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def prand(*, shape: Shape = ()) -> TensorType:
     """Declare a private random UINT64 tensor with the given shape.
 
@@ -153,7 +153,7 @@ def prand(*, shape: Shape = ()) -> TensorType:
     return TensorType(UINT64, shape)
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def debug_print(
     x: TensorType | TableType, *, prefix: str = ""
 ) -> TableType | TensorType:
@@ -169,7 +169,7 @@ def debug_print(
     return x
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def pack(x: TensorType | TableType) -> TensorType:
     """Serialize a tensor/table into a byte vector (type-only).
 
@@ -189,7 +189,7 @@ def pack(x: TensorType | TableType) -> TensorType:
     return TensorType(UINT8, (-1,))
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def unpack(b: TensorType, *, out_ty: TensorType | TableType) -> TensorType | TableType:
     """Deserialize a byte vector into the explicit output type.
 
@@ -215,7 +215,7 @@ def unpack(b: TensorType, *, out_ty: TensorType | TableType) -> TensorType | Tab
     return out_ty
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def table_to_tensor(table: TableType, *, number_rows: int) -> TensorType:
     """Convert a homogeneous-typed table to a dense 2D tensor.
 
@@ -248,7 +248,7 @@ def table_to_tensor(table: TableType, *, number_rows: int) -> TensorType:
     return TensorType(first, shape)  # type: ignore[arg-type]
 
 
-@_BUILTIN_MOD.simple_op()
+@_BASIC_MOD.simple_op()
 def tensor_to_table(tensor: TensorType, *, column_names: list[str]) -> TableType:
     """Convert a rank-2 tensor into a table with named columns.
 

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/mplang/simp/__init__.py

@@ -105,7 +105,7 @@ def run_impl(
         The result of evaluating the function through the appropriate handler
 
     Raises:
-        ValueError: If builtin.write is called without required arguments
+        ValueError: If basic.write is called without required arguments
         TypeError: If the function compilation or evaluation fails
         RuntimeError: If the underlying peval execution encounters errors
 
@@ -114,11 +114,11 @@ def run_impl(
 
         >>> tensor_info = TensorType(shape=(10, 10), dtype=np.float32)
         >>> attrs = {"format": "binary"}
-        >>> result = run_impl(builtin.read, "data/input.bin", tensor_info, attrs)
+        >>> result = run_impl(basic.read, "data/input.bin", tensor_info, attrs)
 
         Writing data to a file:
 
-        >>> run_impl(builtin.write, data, "data/output.bin")
+        >>> run_impl(basic.write, data, "data/output.bin")
 
         Running a JAX function:
 

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/tests/core/test_primitive.py

@@ -349,9 +349,9 @@ class TestBasicPrimitives:
         expected = """
 () {
   %0 = pconst() {data=42} : i64<3>
-  %1 = peval(%0) {fn_type=builtin.identity, rmask=0x1} : i64<1>
+  %1 = peval(%0) {fn_type=basic.identity, rmask=0x1} : i64<1>
   %2 = pconst() {data=24} : i64<3>
-  %3 = peval(%2) {fn_type=builtin.identity, rmask=0x2} : i64<2>
+  %3 = peval(%2) {fn_type=basic.identity, rmask=0x2} : i64<2>
   %4 = pconv(%1, %3) : i64<3>
   return %4
 }

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/tests/integration/test_crypto_roundtrip.py

@@ -23,7 +23,7 @@ import pytest
 import mplang
 import mplang.simp as simp
 from mplang.core.tensor import TensorType
-from mplang.ops import builtin, crypto
+from mplang.ops import basic, crypto
 
 pytestmark = pytest.mark.integration
 
@@ -78,8 +78,8 @@ def test_pack_unpack_roundtrip_various():
         outs = []
         for _idx, (shape, dt) in enumerate(shapes_dtypes):
             arr = simp.runAt(0, lambda s=shape, d=dt: np.zeros(s, dtype=d))()
-            packed = simp.runAt(0, builtin.pack)(arr)
-            unpacked = simp.runAt(0, builtin.unpack)(
+            packed = simp.runAt(0, basic.pack)(arr)
+            unpacked = simp.runAt(0, basic.unpack)(
                 packed, out_ty=TensorType.from_obj(arr)
             )
             outs.append(unpacked)

{mplang_nightly-0.1.dev170 → mplang_nightly-0.1.dev171}/tests/integration/test_symbols_roundtrip.py

@@ -22,7 +22,7 @@ Flow:
 
 This tests end-to-end interaction between:
  - Global symbol CRUD endpoints
- - ``builtin.read`` path using ``symbols://`` scheme
+ - ``basic.read`` path using ``symbols://`` scheme
  - Driver evaluation and fetch
  - HttpExecutorClient helpers for symbol CRUD
 """
@@ -40,7 +40,7 @@ from mplang.core.cluster import ClusterSpec, Device, Node, RuntimeInfo
 from mplang.core.dtype import DType
 from mplang.core.tensor import TensorType
 from mplang.kernels.value import TensorValue
-from mplang.ops import builtin as fb
+from mplang.ops import basic as fb
 from mplang.runtime.client import HttpExecutorClient
 
 pytest_plugins = ("tests.utils.server_fixtures",)