mplang-nightly 0.1.dev192__py3-none-any.whl → 0.1.dev268__py3-none-any.whl

mplang/device.py

@@ -1,327 +0,0 @@
-# Copyright 2025 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.
-
-"""
-This module provides the device oriented programming interface for MPC.
-
-The device oriented programming interface is designed to provide a high-level
-abstraction for the MPC programming. It allows the user to write the program
-in a device-oriented manner, and the runtime will take care of the data
-transformation between devices.
-"""
-
-from __future__ import annotations
-
-from collections.abc import Callable
-from functools import partial, wraps
-from typing import Any
-
-from jax.tree_util import tree_map
-
-import mplang.host as mphost
-from mplang.core import (
-    ClusterSpec,
-    Device,
-    InterpContext,
-    MPObject,
-    TensorType,
-    cur_ctx,
-    primitive,
-)
-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
-from mplang.simp import mpi, smpc
-from mplang.simp.api import run_at
-
-# Automatic transfer between devices when parameter is not on the target device.
-g_auto_trans: bool = True
-
-_HKDF_INFO_LITERAL: str = "mplang/device/tee/v1"
-# Default KEM suite for TEE session establishment; make configurable via ClusterSpec in future.
-_TEE_KEM_SUITE: str = "x25519"
-
-
-# `function` decorator could also compile device-level apis.
-function = primitive.function
-
-# magic attribute name to mark a MPObject as a device object
-DEVICE_ATTR_NAME = "_devid_"
-
-
-def _is_device_obj(obj: Any) -> bool:
-    if not isinstance(obj, MPObject):
-        return False
-    return DEVICE_ATTR_NAME in obj.attrs
-
-
-def _set_devid(obj: MPObject, dev_id: str) -> MPObject:
-    if not isinstance(obj, MPObject):
-        raise TypeError(f"Input must be an instance of Object, {obj}")
-    obj.attrs[DEVICE_ATTR_NAME] = dev_id
-    return obj
-
-
-def _get_devid(obj: MPObject) -> str:
-    if not isinstance(obj, MPObject):
-        raise TypeError("Input must be an instance of Object")
-
-    return obj.attrs[DEVICE_ATTR_NAME]  # type: ignore[no-any-return]
-
-
-_is_mpobj = lambda x: isinstance(x, MPObject)
-
-
-def _device_run_spu(
-    dev_info: Device, op: FeOperation, *args: Any, **kwargs: Any
-) -> Any:
-    if not isinstance(op, JaxRunner):
-        raise ValueError("SPU device only supports JAX frontend.")
-    fn, *aargs = args
-    var = smpc.srun(fn)(*aargs, **kwargs)
-    return tree_map(partial(_set_devid, dev_id=dev_info.name), var)
-
-
-def _device_run_tee(
-    dev_info: Device, op: FeOperation, *args: Any, **kwargs: Any
-) -> Any:
-    if not isinstance(op, JaxRunner) and not isinstance(op, IbisRunner):
-        raise ValueError("TEE device only supports JAX and Ibis frontend.")
-    assert len(dev_info.members) == 1
-    rank = dev_info.members[0].rank
-    var = run_at(rank, op, *args, **kwargs)
-    return tree_map(partial(_set_devid, dev_id=dev_info.name), var)
-
-
-def _device_run_ppu(
-    dev_info: Device, op: FeOperation, *args: Any, **kwargs: Any
-) -> Any:
-    assert len(dev_info.members) == 1
-    rank = dev_info.members[0].rank
-    var = run_at(rank, op, *args, **kwargs)
-    return tree_map(partial(_set_devid, dev_id=dev_info.name), var)
-
-
-def _device_run(dev_id: str, op: FeOperation, *args: Any, **kwargs: Any) -> Any:
-    assert isinstance(op, FeOperation)
-    cluster_spec = mphost.cur_ctx().cluster_spec
-    if dev_id not in cluster_spec.devices:
-        raise ValueError(f"Device {dev_id} not found in cluster spec.")
-
-    if g_auto_trans:
-
-        def trans(obj: Any) -> Any:
-            if _is_mpobj(obj):
-                assert _is_device_obj(obj)
-                return _d2d(dev_id, obj)
-            else:
-                return obj
-
-        args, kwargs = tree_map(trans, (args, kwargs))
-
-    dev_info = cluster_spec.devices[dev_id]
-    if dev_info.kind.upper() == "SPU":
-        return _device_run_spu(dev_info, op, *args, **kwargs)
-    elif dev_info.kind.upper() == "TEE":
-        return _device_run_tee(dev_info, op, *args, **kwargs)
-    elif dev_info.kind.upper() == "PPU":
-        return _device_run_ppu(dev_info, op, *args, **kwargs)
-    else:
-        raise ValueError(f"Unknown device type: {dev_info.kind}")
-
-
-def device(dev_id: str, *, fe_type: str = "jax") -> Callable:
-    """Decorator to mark a function to be executed on a specific device.
-
-    Args:
-        dev_id: The device id.
-        fe_type: The frontend type of the device, could be "jax" or "ibis".
-
-    Note: 'fe_type' is not needed if the decorated function is already a FeOperation.
-
-    Example:
-        >>> @device("P0")
-        ... def foo(x, y):
-        ...     return x + y
-    """
-
-    def deco(fn: Callable) -> Callable:
-        @wraps(fn)
-        def wrapped(*args: Any, **kwargs: Any) -> Any:
-            if isinstance(fn, FeOperation):
-                return _device_run(dev_id, fn, *args, **kwargs)
-            else:
-                if fe_type == "jax":
-                    return _device_run(dev_id, jax_cc.run_jax, fn, *args, **kwargs)
-                elif fe_type == "ibis":
-                    return _device_run(dev_id, ibis_cc.run_ibis, fn, *args, **kwargs)
-                else:
-                    raise ValueError(f"Unsupported frontend type: {fe_type}")
-
-        return wrapped
-
-    return deco
-
-
-def _d2d(to_dev_id: str, obj: MPObject) -> MPObject:
-    assert isinstance(obj, MPObject)
-    frm_dev_id = _get_devid(obj)
-
-    if frm_dev_id == to_dev_id:
-        return obj
-
-    cluster_spec: ClusterSpec = mphost.cur_ctx().cluster_spec
-    frm_dev = cluster_spec.devices[frm_dev_id]
-    to_dev = cluster_spec.devices[to_dev_id]
-    frm_to_pair = (frm_dev.kind.upper(), to_dev.kind.upper())
-
-    if frm_to_pair == ("SPU", "SPU"):
-        raise NotImplementedError("Only one SPU is supported for now.")
-    elif frm_to_pair == ("SPU", "PPU"):
-        assert len(to_dev.members) == 1
-        to_rank = to_dev.members[0].rank
-        var = smpc.revealTo(obj, to_rank)
-        return tree_map(partial(_set_devid, dev_id=to_dev_id), var)  # type: ignore[no-any-return]
-    elif frm_to_pair == ("PPU", "SPU"):
-        assert len(frm_dev.members) == 1
-        frm_rank = frm_dev.members[0].rank
-        var = smpc.sealFrom(obj, frm_rank)
-        return tree_map(partial(_set_devid, dev_id=to_dev_id), var)  # type: ignore[no-any-return]
-    elif frm_to_pair == ("PPU", "PPU"):
-        assert len(frm_dev.members) == 1 and len(to_dev.members) == 1
-        frm_rank = frm_dev.members[0].rank
-        to_rank = to_dev.members[0].rank
-        var = mpi.p2p(frm_rank, to_rank, obj)
-        return tree_map(partial(_set_devid, dev_id=to_dev_id), var)  # type: ignore[no-any-return]
-    elif frm_to_pair == ("PPU", "TEE"):
-        # Transparent handshake + encryption for the first transfer; reuse thereafter
-        assert len(frm_dev.members) == 1 and len(to_dev.members) == 1
-        frm_rank = frm_dev.members[0].rank
-        tee_rank = to_dev.members[0].rank
-        # Ensure sessions (both directions) exist for this PPU<->TEE pair
-        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 = run_at(frm_rank, basic.pack, obj)
-        ct = run_at(frm_rank, crypto.enc, b, sess_p)
-        ct_at_tee = mpi.p2p(frm_rank, tee_rank, ct)
-        b_at_tee = run_at(tee_rank, crypto.dec, ct_at_tee, sess_t)
-        pt_at_tee = run_at(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
-        assert len(frm_dev.members) == 1 and len(to_dev.members) == 1
-        tee_rank = frm_dev.members[0].rank
-        ppu_rank = to_dev.members[0].rank
-        # 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 = run_at(tee_rank, basic.pack, obj)
-        ct = run_at(tee_rank, crypto.enc, b, sess_t)
-        ct_at_ppu = mpi.p2p(tee_rank, ppu_rank, ct)
-        b_at_ppu = run_at(ppu_rank, crypto.dec, ct_at_ppu, sess_p)
-        pt_at_ppu = run_at(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 = [
-            ("SPU", "PPU"),
-            ("PPU", "SPU"),
-            ("PPU", "PPU"),
-            ("PPU", "TEE"),
-            ("TEE", "PPU"),
-        ]
-        raise ValueError(
-            f"Unsupported device transfer: {frm_to_pair}. Supported pairs: {supported}."
-        )
-
-
-def _ensure_tee_session(
-    frm_dev_id: str, to_dev_id: str, frm_rank: int, tee_rank: int
-) -> tuple[MPObject, MPObject]:
-    """Ensure a TEE session (sess_p at sender, sess_t at TEE) exists.
-
-    Returns (sess_p, sess_t).
-    """
-    ctx = cur_ctx().root()
-    if not hasattr(ctx, "_tee_sessions"):
-        ctx._tee_sessions = {}  # type: ignore[attr-defined]
-    cache: dict[tuple[str, str], tuple[MPObject, MPObject]] = ctx._tee_sessions  # type: ignore
-
-    key = (frm_dev_id, to_dev_id)
-    if key in cache:
-        return cache[key]
-
-    # 1) TEE generates (sk, pk) and quote(pk)
-    # KEM suite currently constant; future: read from tee device config (e.g. cluster_spec.devices[dev_id].config)
-    tee_sk, tee_pk = run_at(tee_rank, crypto.kem_keygen, _TEE_KEM_SUITE)
-    quote = run_at(tee_rank, tee.quote_gen, tee_pk)
-
-    # 2) Send quote to sender and attest to obtain TEE pk
-    quote_at_sender = mpi.p2p(tee_rank, frm_rank, quote)
-    tee_pk_at_sender = run_at(frm_rank, tee.attest, quote_at_sender)
-
-    # 3) Sender generates its ephemeral keypair and sends its pk to TEE
-    v_sk, v_pk = run_at(frm_rank, crypto.kem_keygen, _TEE_KEM_SUITE)
-    v_pk_at_tee = mpi.p2p(frm_rank, tee_rank, v_pk)
-
-    # 4) Both sides derive the shared secret and session key
-    shared_p = run_at(
-        frm_rank, crypto.kem_derive, v_sk, tee_pk_at_sender, _TEE_KEM_SUITE
-    )
-    shared_t = run_at(tee_rank, crypto.kem_derive, tee_sk, v_pk_at_tee, _TEE_KEM_SUITE)
-    # Use a fixed ASCII string literal for HKDF info on both sides
-    sess_p = run_at(frm_rank, crypto.hkdf, shared_p, _HKDF_INFO_LITERAL)
-    sess_t = run_at(tee_rank, crypto.hkdf, shared_t, _HKDF_INFO_LITERAL)
-
-    cache[key] = (sess_p, sess_t)
-    return sess_p, sess_t
-
-
-def put(to_dev_id: str, obj: Any) -> MPObject:
-    if not isinstance(obj, MPObject):
-        return device(to_dev_id)(lambda x: x)(obj)  # type: ignore[no-any-return]
-    assert isinstance(obj, MPObject)
-    return _d2d(to_dev_id, obj)
-
-
-def _fetch(interp: InterpContext, obj: MPObject) -> Any:
-    dev_id = _get_devid(obj)
-    cluster_spec = interp.cluster_spec
-    dev_kind = cluster_spec.devices[dev_id].kind.upper()
-
-    dev_info = cluster_spec.devices[dev_id]
-    if dev_kind == "SPU":
-        revealed = mphost.evaluate(interp, smpc.reveal, obj)
-        result = mphost.fetch(interp, revealed)
-        # now all members have the same value, return the one at rank 0
-        return result[dev_info.members[0].rank]
-    elif dev_kind == "PPU":
-        assert len(dev_info.members) == 1
-        rank = dev_info.members[0].rank
-        result = mphost.fetch(interp, obj)
-        return result[rank]
-    elif dev_kind == "TEE":
-        assert len(dev_info.members) == 1
-        rank = dev_info.members[0].rank
-        result = mphost.fetch(interp, obj)
-        return result[rank]
-    else:
-        raise ValueError(f"Unknown device id: {dev_id}")
-
-
-def fetch(interp: InterpContext, objs: Any) -> Any:
-    ctx = interp or mphost.cur_ctx()
-    assert isinstance(ctx, InterpContext), f"Expect InterpContext, got {ctx}"
-    return tree_map(partial(_fetch, ctx), objs)

mplang/ops/crypto.py

@@ -1,108 +0,0 @@
-# Copyright 2025 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.
-
-"""
-Crypto frontend operations: operation signatures, types, and high-level semantics.
-
-Scope and contracts:
-- This module defines portable API shapes; it does not implement cryptography.
-- Backends execute the operations and must meet the security semantics required
-    by the deployment (confidentiality, authenticity, correctness, etc.).
-- The enc/dec API in this frontend uses a conventional 12-byte nonce prefix
-    (ciphertext = nonce || payload), and dec expects that format. Other security
-    properties (e.g., AEAD) are backend responsibilities.
-"""
-
-from __future__ import annotations
-
-from mplang.core import UINT8, TensorType
-from mplang.ops.base import stateless_mod
-
-_CRYPTO_MOD = stateless_mod("crypto")
-
-
-@_CRYPTO_MOD.simple_op()
-def keygen(*, length: int = 32) -> TensorType:
-    """Generate random bytes for symmetric keys or generic randomness.
-
-    API: keygen(length: int = 32) -> key: u8[length]
-
-    Notes:
-    - Frontend defines the type/shape; backend provides randomness.
-    - Raises ValueError when length <= 0.
-    """
-    if length <= 0:
-        raise ValueError("length must be > 0")
-    return TensorType(UINT8, (length,))
-
-
-@_CRYPTO_MOD.simple_op()
-def enc(plaintext: TensorType, key: TensorType) -> TensorType:
-    """Symmetric encryption.
-
-    API: enc(plaintext: u8[N], key: u8[M]) -> ciphertext: u8[N + 12]
-    """
-    pt_ty = plaintext
-    if pt_ty.dtype != UINT8:
-        raise TypeError("enc expects UINT8 plaintext")
-    if len(pt_ty.shape) != 1:
-        raise TypeError("enc expects 1-D plaintext")
-    length = pt_ty.shape[0]
-    if length >= 0:
-        return TensorType(UINT8, (length + 12,))
-    return TensorType(UINT8, (-1,))
-
-
-@_CRYPTO_MOD.simple_op()
-def dec(ciphertext: TensorType, key: TensorType) -> TensorType:
-    """Symmetric decryption.
-
-    API: dec(ciphertext: u8[N + 12], key: u8[M]) -> plaintext: u8[N]
-    """
-    ct_ty = ciphertext
-    if ct_ty.dtype != UINT8:
-        raise TypeError("dec expects UINT8 ciphertext")
-    if len(ct_ty.shape) != 1:
-        raise TypeError("dec expects 1-D ciphertext with nonce")
-    length = ct_ty.shape[0]
-    if length >= 0 and length < 12:
-        raise TypeError("dec expects 1-D ciphertext with nonce")
-    if length >= 0:
-        return TensorType(UINT8, (length - 12,))
-    return TensorType(UINT8, (-1,))
-
-
-@_CRYPTO_MOD.simple_op()
-def kem_keygen(*, suite: str = "x25519") -> tuple[TensorType, TensorType]:
-    """KEM-style keypair generation: returns (sk, pk) bytes."""
-    sk_ty = TensorType(UINT8, (32,))
-    pk_ty = TensorType(UINT8, (32,))
-    return sk_ty, pk_ty
-
-
-@_CRYPTO_MOD.simple_op()
-def kem_derive(
-    sk: TensorType, peer_pk: TensorType, *, suite: str = "x25519"
-) -> TensorType:
-    """KEM-style shared secret derivation: returns secret bytes."""
-    _ = sk
-    _ = peer_pk
-    return TensorType(UINT8, (32,))
-
-
-@_CRYPTO_MOD.simple_op()
-def hkdf(secret: TensorType, *, info: str) -> TensorType:
-    """HKDF-style key derivation: returns a 32-byte key."""
-    _ = secret
-    return TensorType(UINT8, (32,))

mplang/ops/ibis_cc.py

@@ -1,136 +0,0 @@
-# Copyright 2025 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.
-
-
-import inspect
-from collections.abc import Callable
-from typing import Any
-
-import ibis
-from jax.tree_util import PyTreeDef, tree_flatten
-
-from mplang.core import MPObject, PFunction, TableType, dtypes
-from mplang.ops.base import FeOperation, stateless_mod
-from mplang.utils.func_utils import normalize_fn
-
-
-def ibis2sql(
-    expr: ibis.Table,
-    in_schemas: list[ibis.Schema],
-    in_names: list[str],
-    fn_name: str = "",
-) -> PFunction:
-    """
-    Compile a ibis expr to sql and return the PFunction.
-
-    Args:
-        expr: ibis expr.
-        in_schemas: the input table schemas
-        in_names: the input table names, If there is only one table, it is usually defaulted to "table"
-    Return:
-        PFunction: The compiled PFunction
-    """
-    assert len(in_schemas) == len(in_names), (
-        f"length of input table names and schemas mismatch. {len(in_schemas)}!={len(in_names)}"
-    )
-
-    def _convert(s: ibis.Schema) -> TableType:
-        return TableType.from_pairs([
-            (name, dtypes.from_numpy(dt.to_numpy())) for name, dt in s.fields.items()
-        ])
-
-    ins_info = [_convert(s) for s in in_schemas]
-    outs_info = [_convert(expr.schema())]
-
-    sql = ibis.to_sql(expr, dialect="duckdb")
-    # Emit generic sql.run op; runtime maps to backend-specific kernel.
-    pfn = PFunction(
-        fn_type="sql.run",
-        fn_name=fn_name,
-        fn_text=sql,
-        ins_info=tuple(ins_info),
-        outs_info=tuple(outs_info),
-        in_names=tuple(in_names),
-        dialect="duckdb",
-    )
-    return pfn
-
-
-def is_ibis_function(func: Callable) -> bool:
-    """
-    Verify whether a function is an ibis function.
-    The func signature should like def foo(t0:ibis.Table, t1:ibis.Table)->ibis.Table
-    """
-    try:
-        sig = inspect.signature(func)
-    except (ValueError, TypeError):
-        return False
-
-    ret_anno = sig.return_annotation
-    if ret_anno is ibis.Table:
-        return True
-
-    for param in sig.parameters.values():
-        par_anno = param.annotation
-        if par_anno is ibis.Table:
-            return True
-
-    return False
-
-
-_IBIS_MOD = stateless_mod("ibis")
-
-
-class IbisRunner(FeOperation):
-    """Ibis runner frontend operation."""
-
-    def trace(
-        self, func: Callable, *args: Any, **kwargs: Any
-    ) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-        """Compile an Ibis function to SQL format.
-
-        Args:
-            func: The Ibis function to compile
-            *args: Positional arguments to the function
-            **kwargs: Keyword arguments to the function
-
-        Returns:
-            tuple[PFunction, list[MPObject], Any]: The compiled PFunction, input variables, and output tree
-        """
-
-        def is_variable(arg: Any) -> bool:
-            return isinstance(arg, MPObject)
-
-        normalized_fn, in_vars = normalize_fn(func, args, kwargs, is_variable)
-
-        in_args, in_schemas, in_names = [], [], []
-        idx = 0
-        for arg in in_vars:
-            columns = [(p[0], p[1].to_numpy()) for p in arg.schema.columns]
-            schema = ibis.schema(columns)
-            name = f"table{idx}"
-            table = ibis.table(schema=schema, name=name)
-            in_args.append(table)
-            in_schemas.append(schema)
-            in_names.append(name)
-            idx += 1
-
-        result = normalized_fn(in_args)
-        assert isinstance(result, ibis.Table)
-        pfunc = ibis2sql(result, in_schemas, in_names, func.__name__)
-        _, treedef = tree_flatten(result)
-        return pfunc, in_vars, treedef
-
-
-run_ibis = IbisRunner(_IBIS_MOD, "run")

mplang/ops/sql_cc.py

@@ -1,62 +0,0 @@
-# Copyright 2025 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 jax.tree_util import PyTreeDef, tree_flatten
-
-from mplang.core.mpobject import MPObject
-from mplang.core.pfunc import PFunction
-from mplang.core.table import TableType
-from mplang.ops.base import FeOperation, stateless_mod
-
-_SQL_MOD = stateless_mod("sql")
-
-
-class SqlRunner(FeOperation):
-    def __init__(self, dialect: str = "duckdb"):
-        # Bind to sql module with a stable op name for registry/dispatch
-        super().__init__(_SQL_MOD, "run")
-        self._dialect = dialect
-
-    # TODO(jint): we should deduce out_type according to query and in_tables' schema
-    def trace(
-        self,
-        query: str,
-        out_type: TableType,
-        in_tables: dict[str, MPObject] | None = None,
-    ) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-        in_names: list[str] = []
-        ins_info: list[TableType] = []
-        in_vars: list[MPObject] = []
-        if in_tables:
-            for name, tbl in in_tables.items():
-                assert isinstance(tbl, MPObject)
-                assert tbl.schema is not None
-                in_names.append(name)
-                ins_info.append(tbl.schema)
-                in_vars.append(tbl)
-
-        pfn = PFunction(
-            fn_type="sql.run",
-            fn_name="",
-            fn_text=query,
-            ins_info=tuple(ins_info),
-            outs_info=(out_type,),
-            in_names=tuple(in_names),
-            dialect=self._dialect,
-        )
-        _, treedef = tree_flatten(out_type)
-        return pfn, in_vars, treedef
-
-
-run_sql = SqlRunner("duckdb")