mplang-nightly 0.1.dev269__py3-none-any.whl → 0.1.dev271__py3-none-any.whl

mplang/v1/ops/phe.py

@@ -1,216 +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.
-
-"""PHE (Partially Homomorphic Encryption) frontend operations."""
-
-from mplang.v1.core import UINT8, TensorType
-from mplang.v1.ops.base import stateless_mod
-
-_PHE_MOD = stateless_mod("phe")
-
-
-@_PHE_MOD.simple_op()
-def keygen(
-    *,
-    scheme: str = "paillier",
-    key_size: int = 2048,
-    max_value: int | None = None,
-    fxp_bits: int | None = None,
-) -> tuple[TensorType, TensorType]:
-    """Generate a PHE key pair: returns (public_key, private_key).
-
-    Keys are represented with a sentinel TensorType UINT8[(-1, 0)] to indicate
-    non-structural, backend-only handles. Runtime validation will treat this
-    shape as an opaque placeholder and skip dtype/shape checks.
-
-    Attributes (forwarded to backend):
-        scheme: PHE scheme (default: 'paillier')
-        key_size: Modulus size in bits (default: 2048)
-        max_value: Optional range-encoding bound B. If provided, the backend will
-            encode/decode integers/floats within [-B, B] and treat (B, N-B) as overflow.
-            Pick B to exceed the largest intermediate magnitude you expect in homomorphic
-            combinations. If omitted, backend default is used (currently 2**32).
-        fxp_bits: Optional fixed-point fractional bits for float encoding (default backend value).
-    """
-    key_spec = TensorType(UINT8, (-1, 0))
-    return key_spec, key_spec
-
-
-@_PHE_MOD.simple_op()
-def encrypt(plaintext: TensorType, public_key: TensorType) -> TensorType:
-    """Encrypt plaintext using PHE public key: returns ciphertext with same semantic type as plaintext."""
-    _ = public_key
-    return plaintext
-
-
-@_PHE_MOD.simple_op()
-def add(operand1: TensorType, operand2: TensorType) -> TensorType:
-    """Add two PHE operands (semantics depend on backend representation)."""
-    _ = operand2
-    return operand1
-
-
-@_PHE_MOD.simple_op()
-def mul(ciphertext: TensorType, plaintext: TensorType) -> TensorType:
-    """Multiply a PHE ciphertext with a plaintext value (ciphertext dtype preserved)."""
-    if plaintext.dtype.is_floating:
-        raise ValueError(
-            "PHE multiplication does not support floating-point plaintext."
-        )
-    return ciphertext
-
-
-@_PHE_MOD.simple_op()
-def decrypt(ciphertext: TensorType, private_key: TensorType) -> TensorType:
-    """Decrypt ciphertext using PHE private key: returns plaintext with same semantic type as ciphertext."""
-    _ = private_key
-    return ciphertext
-
-
-@_PHE_MOD.simple_op()
-def dot(ciphertext: TensorType, plaintext: TensorType) -> TensorType:
-    """Compute dot product of ciphertext with plaintext.
-
-    Args:
-        ciphertext: The ciphertext operand (first argument)
-        plaintext: The plaintext operand (second argument)
-
-    Returns:
-        TensorType: Result tensor type with computed shape following numpy dot product rules
-    """
-    # For dot product, we need to calculate the result shape
-    # This follows numpy dot product rules
-    import numpy as np
-
-    # Create dummy arrays to determine result shape
-    dummy_ct = np.zeros(ciphertext.shape)
-    dummy_pt = np.zeros(plaintext.shape)
-    dummy_result = np.dot(dummy_ct, dummy_pt)
-
-    return TensorType(ciphertext.dtype, dummy_result.shape)
-
-
-@_PHE_MOD.simple_op()
-def gather(ciphertext: TensorType, indices: TensorType, *, axis: int = 0) -> TensorType:
-    """Gather elements from ciphertext using indices.
-
-    Args:
-        ciphertext: The ciphertext to gather from
-        indices: The indices to gather
-        axis: The axis along which to gather (default: 0)
-    """
-    # Calculate result shape based on axis parameter
-    ct_shape = list(ciphertext.shape)
-    indices_shape = list(indices.shape)
-
-    # Normalize negative axis
-    normalized_axis = axis if axis >= 0 else len(ct_shape) + axis
-
-    # Result shape: replace the axis dimension with indices shape
-    result_shape = (
-        ct_shape[:normalized_axis] + indices_shape + ct_shape[normalized_axis + 1 :]
-    )
-    return TensorType(ciphertext.dtype, tuple(result_shape))
-
-
-@_PHE_MOD.simple_op()
-def scatter(
-    ciphertext: TensorType,
-    indices: TensorType,
-    updates: TensorType,
-    *,
-    axis: int = 0,
-) -> TensorType:
-    """Scatter updates into ciphertext at specified indices.
-
-    Args:
-        ciphertext: The ciphertext to scatter into
-        indices: The indices to scatter at
-        updates: The ciphertext updates to scatter
-        axis: The axis along which to scatter (default: 0)
-
-    Returns:
-        TensorType: Result tensor type with same shape and dtype as original ciphertext
-    """
-    return ciphertext
-
-
-@_PHE_MOD.simple_op()
-def concat(operand0: TensorType, operand1: TensorType, *, axis: int = 0) -> TensorType:
-    """Concatenate ciphertext tensors along specified axis.
-
-    Args:
-        operand0: The first ciphertext operand to concatenate
-        operand1: The second ciphertext operand to concatenate
-        axis: Axis along which to concatenate
-
-    Returns:
-        TensorType: Result tensor type with computed shape following numpy concatenation rules
-    """
-    # All operands should have same dtype
-    first_dtype = operand0.dtype
-    if operand1.dtype != first_dtype:
-        raise ValueError("All operands must have the same dtype for concatenation")
-
-    # Calculate result shape using numpy concatenation logic
-    import numpy as np
-
-    dummy_arrays = [np.zeros(operand0.shape), np.zeros(operand1.shape)]
-    dummy_result = np.concatenate(dummy_arrays, axis=axis)
-
-    return TensorType(first_dtype, dummy_result.shape)
-
-
-@_PHE_MOD.simple_op()
-def reshape(ciphertext: TensorType, *, new_shape: tuple[int, ...]) -> TensorType:
-    """Reshape ciphertext to new shape.
-
-    Args:
-        ciphertext: The ciphertext to reshape
-        new_shape: The target shape (can contain -1 for inferred dimension)
-
-    Returns:
-        TensorType: Result tensor type with computed shape following numpy reshape rules
-    """
-    # Calculate the actual result shape (handling -1 inference)
-    import numpy as np
-
-    dummy_array = np.zeros(ciphertext.shape)
-    # use this to check the correctness of new_shape
-    dummy_result = dummy_array.reshape(new_shape)
-    actual_shape = dummy_result.shape
-
-    return TensorType(ciphertext.dtype, actual_shape)
-
-
-@_PHE_MOD.simple_op()
-def transpose(
-    ciphertext: TensorType, *, axes: tuple[int, ...] | None = None
-) -> TensorType:
-    """Transpose ciphertext by permuting axes.
-
-    Args:
-        ciphertext: The ciphertext to transpose
-        axes: Permutation of axes (None for default reverse order)
-
-    Returns:
-        TensorType: Result tensor type with computed shape following numpy transpose rules
-    """
-    # Calculate result shape using numpy transpose logic
-    import numpy as np
-
-    dummy_array = np.zeros(ciphertext.shape)
-    dummy_result = np.transpose(dummy_array, axes)
-
-    return TensorType(ciphertext.dtype, dummy_result.shape)

mplang/v1/ops/spu.py

@@ -1,151 +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 __future__ import annotations
-
-from collections.abc import Callable
-from typing import Any
-
-import jax.numpy as jnp
-import spu.libspu as libspu
-import spu.utils.frontend as spu_fe
-from jax import ShapeDtypeStruct
-from jax.tree_util import PyTreeDef, tree_flatten
-
-from mplang.v1.core import MPObject, PFunction, TensorType, get_fn_name
-from mplang.v1.ops.base import stateless_mod
-from mplang.v1.utils.func_utils import normalize_fn
-
-
-class Visibility:
-    """Frontend visibility constants mapping to libspu.Visibility.
-
-    Note: these are direct aliases to libspu.Visibility members so that
-    downstream serialization and backends receive the exact enum type
-    they expect. Keep the friendly names (SECRET/PUBLIC/PRIVATE) for
-    frontend ergonomics.
-    """
-
-    SECRET = libspu.Visibility.VIS_SECRET
-    PUBLIC = libspu.Visibility.VIS_PUBLIC
-    PRIVATE = libspu.Visibility.VIS_PRIVATE
-
-
-_SPU_MOD = stateless_mod("spu")
-
-
-@_SPU_MOD.simple_op()
-def makeshares(
-    data: TensorType,
-    *,
-    world_size: int,
-    visibility: libspu.Visibility = Visibility.SECRET,
-    owner_rank: int = -1,
-    enable_private: bool = False,
-) -> tuple:
-    """Create SPU shares from a plaintext tensor (type-only kernel).
-
-    Returns a PyTree of TensorType repeated `world_size` times.
-    Validation only; PFunction assembly handled by typed_op decorator.
-    """
-    if world_size <= 0:
-        raise ValueError("world_size must be positive")
-    if visibility == Visibility.PRIVATE:
-        if not enable_private:
-            raise ValueError("PRIVATE visibility disabled; set enable_private=True")
-        if owner_rank < 0 or owner_rank >= world_size:
-            raise ValueError(f"owner_rank {owner_rank} out of range [0,{world_size})")
-    return tuple(data for _ in range(world_size))
-
-
-@_SPU_MOD.op_def()
-def reconstruct(*shares: MPObject) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    """Reconstruct plaintext tensor from shares."""
-    if len(shares) == 0:
-        raise ValueError("reconstruct requires at least one share")
-
-    ins_info = tuple(TensorType.from_obj(s) for s in shares)
-    outs_info = (ins_info[0],)
-    pfunc = PFunction(
-        fn_type="spu.reconstruct",
-        ins_info=ins_info,
-        outs_info=outs_info,
-    )
-    _, treedef = tree_flatten(outs_info[0])
-    return pfunc, list(shares), treedef
-
-
-def _compile_jax(
-    copts: libspu.CompilerOptions,
-    fn: Callable,
-    *args: Any,
-    **kwargs: Any,
-) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    """Compile a JAX function into SPU pphlo MLIR and wrap as PFunction.
-
-    Resulting PFunction uses fn_type 'spu.run_pphlo'.
-    """
-
-    def is_variable(arg: Any) -> bool:
-        return isinstance(arg, MPObject)
-
-    normalized_fn, in_vars = normalize_fn(fn, args, kwargs, is_variable)
-
-    jax_params = [
-        ShapeDtypeStruct(arg.shape, jnp.dtype(arg.dtype.name)) for arg in in_vars
-    ]
-    in_vis = [libspu.Visibility.VIS_SECRET for _ in in_vars]
-    in_names = [f"in{idx}" for idx in range(len(in_vars))]
-    out_names_gen = lambda outs: [f"out{idx}" for idx in range(len(outs))]
-
-    executable, out_info = spu_fe.compile(
-        spu_fe.Kind.JAX,
-        normalized_fn,
-        [jax_params],
-        {},
-        in_names,
-        in_vis,
-        out_names_gen,
-        static_argnums=(),
-        static_argnames=None,
-        copts=copts,
-    )
-    out_info_flat, out_tree = tree_flatten(out_info)
-    output_tensor_infos = [TensorType.from_obj(out) for out in out_info_flat]
-
-    executable_code = executable.code
-    assert isinstance(executable_code, bytes), (
-        f"Expected bytes, got {type(executable_code)}"
-    )
-    executable_code = executable_code.decode("utf-8")
-
-    pfunc = PFunction(
-        fn_type="spu.run_pphlo",
-        ins_info=tuple(TensorType.from_obj(x) for x in in_vars),
-        outs_info=tuple(output_tensor_infos),
-        fn_name=get_fn_name(fn),
-        fn_text=executable_code,
-        input_visibilities=in_vis,
-        input_names=list(executable.input_names),
-        output_names=list(executable.output_names),
-        executable_name=executable.name,
-    )
-    return pfunc, in_vars, out_tree
-
-
-@_SPU_MOD.op_def()
-def jax_compile(
-    fn: Callable, *args: Any, **kwargs: Any
-) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    return _compile_jax(libspu.CompilerOptions(), fn, *args, **kwargs)

mplang/v1/ops/sql_cc.py

@@ -1,303 +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 typing import Any
-
-import sqlglot as sg
-from jax.tree_util import PyTreeDef, tree_flatten
-from sqlglot import exp as sge
-from sqlglot.optimizer import annotate_types as opt_annot
-from sqlglot.optimizer import qualify as opt_qualify
-
-from mplang.v1.core import MPObject, PFunction, TableType
-from mplang.v1.core.dtypes import (
-    BINARY,
-    BOOL,
-    DATE,
-    DECIMAL,
-    FLOAT32,
-    FLOAT64,
-    INT8,
-    INT16,
-    INT32,
-    INT64,
-    INTERVAL,
-    JSON,
-    STRING,
-    TIME,
-    TIMESTAMP,
-    UINT8,
-    UINT16,
-    UINT32,
-    UINT64,
-    UUID,
-    DType,
-)
-from mplang.v1.ops.base import stateless_mod
-
-_SQL_MOD = stateless_mod("sql")
-
-
-# Static dtype mappings (MPLang <-> SQL)
-MP_TO_SQL_TYPE: dict[DType, str] = {
-    # Floats
-    FLOAT64: "DOUBLE",
-    FLOAT32: "FLOAT",
-    # Signed ints
-    INT8: "TINYINT",
-    INT16: "SMALLINT",
-    INT32: "INT",
-    INT64: "BIGINT",
-    # Unsigned ints (portable approximations)
-    UINT8: "SMALLINT",
-    UINT16: "INT",
-    UINT32: "BIGINT",
-    UINT64: "DECIMAL(38)",
-    # Booleans & strings
-    BOOL: "BOOLEAN",
-    STRING: "VARCHAR",
-    # Dates / times
-    DATE: "DATE",
-    TIME: "TIME",
-    TIMESTAMP: "TIMESTAMP",
-    # Other table types
-    DECIMAL: "DECIMAL",
-    JSON: "JSON",
-    BINARY: "BLOB",
-    UUID: "UUID",
-    INTERVAL: "INTERVAL",
-}
-
-SQL_TYPE_TO_MP: dict[str, DType] = {
-    # Floats
-    "double": FLOAT64,
-    "double precision": FLOAT64,
-    "float": FLOAT32,
-    "real": FLOAT32,
-    # Signed ints
-    "bigint": INT64,
-    "long": INT64,
-    "int": INT32,
-    "integer": INT32,
-    "int4": INT32,
-    "smallint": INT16,
-    "int2": INT16,
-    "tinyint": INT8,
-    "int1": INT8,
-    # Unsigned (rare in SQL)
-    "uint8": UINT8,
-    "ubyte": UINT8,
-    "uint16": UINT16,
-    "uint32": UINT32,
-    "uint64": UINT64,
-    # Booleans / strings
-    "bool": BOOL,
-    "boolean": BOOL,
-    "char": STRING,
-    "varchar": STRING,
-    "text": STRING,
-    "string": STRING,
-    # Dates / times
-    "date": DATE,
-    "time": TIME,
-    "timestamp": TIMESTAMP,
-    # Decimal / numeric
-    "decimal": DECIMAL,
-    "numeric": DECIMAL,
-    # Others
-    "json": JSON,
-    "binary": BINARY,
-    "varbinary": BINARY,
-    "blob": BINARY,
-    "uuid": UUID,
-    "interval": INTERVAL,
-}
-
-
-def _deduce_out_schema(
-    parsed: sge.Expression,
-    dialect: str,
-    in_schemas: dict[str, TableType],
-) -> TableType:
-    """Deduce output schema using sqlglot's qualify + annotate_types.
-
-    This implementation leverages sqlglot's optimizer to resolve table/column
-    references (including star expansion) and annotate expression types. It then
-    maps sqlglot DataType to mplang DType and returns a TableType.
-    """
-
-    # 1) Build sqlglot schema from MPObject/TableType inputs
-    def _dtype_to_sql(dt: DType) -> str:
-        return MP_TO_SQL_TYPE.get(dt, "VARCHAR")
-
-    sqlglot_schema: dict[str, dict[str, str]] = {
-        tname: {col: _dtype_to_sql(dt) for col, dt in schema.columns}
-        for tname, schema in in_schemas.items()
-    }
-
-    # 2) Parse with read dialect; 3) Qualify (resolve names, expand star); 4) Annotate types
-    qualified = opt_qualify.qualify(parsed, schema=sqlglot_schema, dialect=dialect)
-    typed = opt_annot.annotate_types(qualified, schema=sqlglot_schema)
-
-    # 5) Extract projection names and types
-    select = typed if isinstance(typed, sge.Select) else typed.find(sge.Select)
-    if select is None:
-        raise NotImplementedError(
-            "Only SELECT queries are supported for schema deduction"
-        )
-
-    def _sqlglot_type_to_dtype(tobj: Any) -> DType:
-        ts = str(tobj).lower().replace(" with time zone", "").strip()
-        base = ts.split("(", 1)[0].strip()
-        return SQL_TYPE_TO_MP.get(base, STRING)
-
-    pairs: list[tuple[str, DType]] = []
-    idx = 0
-    used: set[str] = set()
-    for proj in select.expressions:
-        name = getattr(proj, "alias_or_name", None) or getattr(proj, "name", None)
-        if not name:
-            name = f"expr_{idx}"
-            idx += 1
-        t = getattr(proj, "type", None)
-        if t is None:
-            raise NotImplementedError(
-                "Cannot infer type for projection; please provide out_type explicitly"
-            )
-        dtype = _sqlglot_type_to_dtype(t)
-        if name in used:
-            raise ValueError(
-                f"Duplicate output column name '{name}' after qualification"
-            )
-        used.add(name)
-        pairs.append((name, dtype))
-
-    return TableType.from_pairs(pairs)
-
-
-@_SQL_MOD.op_def()
-def run_sql(
-    query: str,
-    *,
-    out_type: TableType | None = None,
-    dialect: str = "duckdb",
-    **in_tables: Any,
-) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    """Build a sql.run PFunction from a SQL query with optional schema deduction.
-
-    API: run_sql(query: str, *, out_type: TableType | None = None, dialect: str = "duckdb", **in_tables) -> (PFunction, [MPObject], PyTreeDef)
-
-    Semantics:
-    - Parses the SQL and binds only the tables that are actually referenced in the query by name.
-    - If ``out_type`` is not provided, attempts to deduce the output table schema using sqlglot (qualify + annotate types).
-    - Returns a triad consisting of the constructed PFunction (``fn_type='sql.run'``), the ordered list of input MPObjects, and the output PyTreeDef.
-
-    Difference vs ``run_sql_raw``: this op can infer ``out_type`` and will parse the SQL to filter inputs; ``run_sql_raw`` requires an explicit ``out_type`` and does not parse/filter inputs.
-    """
-    # Extract required table names from SQL (order by first appearance)
-    parsed = sg.parse_one(query, read=dialect)
-    required_names: list[str] = []
-    for t in parsed.find_all(sge.Table):
-        # Prefer .name; fallback to str(this) if needed
-        tname = getattr(t, "name", None) or str(t.this)
-        if tname not in required_names:
-            required_names.append(tname)
-
-    # Disallow extras not referenced by the query to avoid surprises
-    extra = set(in_tables.keys()) - set(required_names)
-    if extra:
-        raise ValueError(
-            f"Unexpected tables provided that are not referenced in SQL: {sorted(extra)}"
-        )
-
-    # Validate required tables and require MPObject for runtime registration
-    in_names: list[str] = []
-    ins_info: list[TableType] = []
-    in_vars: list[MPObject] = []
-    for name in required_names:
-        if name not in in_tables:
-            raise KeyError(f"Missing required table '{name}' for SQL query")
-        obj = in_tables[name]
-        if not isinstance(obj, MPObject):
-            raise TypeError(
-                f"Table '{name}' must be an MPObject (for runtime registration), got {type(obj).__name__}"
-            )
-        assert obj.schema is not None, f"Input table '{name}' missing schema"
-        in_vars.append(obj)
-        ins_info.append(obj.schema)
-        in_names.append(name)
-
-    if out_type is None:
-        in_schemas: dict[str, TableType] = {
-            n: in_tables[n].schema for n in required_names
-        }
-        out_type = _deduce_out_schema(parsed, dialect, in_schemas)
-
-    pfn = PFunction(
-        fn_type="sql.run",
-        ins_info=tuple(ins_info),
-        outs_info=(out_type,),
-        fn_name="",
-        fn_text=query,
-        in_names=tuple(in_names),
-        dialect=dialect,
-    )
-    _, treedef = tree_flatten(out_type)
-    return pfn, in_vars, treedef
-
-
-@_SQL_MOD.op_def()
-def run_sql_raw(
-    query: str,
-    out_type: TableType,
-    *,
-    dialect: str = "duckdb",
-    in_tables: dict[str, MPObject] | None = None,
-) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    """Build a sql.run PFunction from a SQL query with an explicit output schema.
-
-    API: run_sql_raw(query: str, out_type: TableType, *, dialect: str = "duckdb", in_tables: dict[str, MPObject] | None = None) -> (PFunction, [MPObject], PyTreeDef)
-
-    Semantics:
-    - Does not parse the SQL; carries all tables provided via ``in_tables`` in the mapping's iteration order.
-    - Requires an explicit ``out_type``; no schema deduction is attempted.
-    - Returns a triad consisting of the constructed PFunction (``fn_type='sql.run'``), the ordered list of input MPObjects, and the output PyTreeDef.
-
-    Difference vs ``run_sql``: this op requires ``out_type`` and does not parse/filter inputs; ``run_sql`` can infer ``out_type`` and selects only tables referenced by the query.
-    """
-
-    # Collect inputs strictly as provided by caller
-    in_names: list[str] = []
-    ins_info: list[TableType] = []
-    in_vars: list[MPObject] = []
-    if in_tables:
-        for name, tbl in in_tables.items():
-            if not isinstance(tbl, MPObject):
-                raise TypeError(f"Input table '{name}' is not an MPObject {type(tbl)}")
-            assert tbl.schema is not None, f"Input table '{name}' is missing a schema"
-            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=dialect,
-    )
-    _, treedef = tree_flatten(out_type)
-    return pfn, in_vars, treedef

mplang/v1/ops/tee.py

@@ -1,36 +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 __future__ import annotations
-
-from mplang.v1.core import UINT8, TensorType
-from mplang.v1.ops.base import stateless_mod
-
-_TEE_MOD = stateless_mod("tee")
-
-
-@_TEE_MOD.simple_op()
-def quote_gen(pk: TensorType) -> TensorType:
-    """TEE quote generation binding the provided ephemeral public key."""
-    _ = pk  # Mark as used for the decorator
-    return TensorType(UINT8, (-1,))
-
-
-@_TEE_MOD.simple_op()
-def attest(quote: TensorType) -> TensorType:
-    """TEE quote verification returning the attested TEE public key.
-    API (mock): attest(quote: u8[33]) -> tee_pk: u8[32]
-    """
-    _ = quote  # Mark as used for the decorator
-    return TensorType(UINT8, (32,))