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

mplang/v1/ops/sql_cc.py

@@ -0,0 +1,303 @@
+# 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/{ops → v1/ops}/tee.py

@@ -14,13 +14,8 @@
 
 from __future__ import annotations
 
-from jax.tree_util import PyTreeDef, tree_flatten
-
-from mplang.core.dtype import UINT8
-from mplang.core.mpobject import MPObject
-from mplang.core.pfunc import PFunction
-from mplang.core.tensor import TensorType
-from mplang.ops.base import stateless_mod
+from mplang.v1.core import UINT8, TensorType
+from mplang.v1.ops.base import stateless_mod
 
 _TEE_MOD = stateless_mod("tee")
 
@@ -32,20 +27,10 @@ def quote_gen(pk: TensorType) -> TensorType:
     return TensorType(UINT8, (-1,))
 
 
-@_TEE_MOD.op_def()
-def attest(
-    quote: MPObject, platform: str
-) -> tuple[PFunction, list[MPObject], PyTreeDef]:
-    """TEE quote verification returning the attested TEE public key."""
-
-    ins_info = [TensorType.from_obj(quote)]
-    outs_info = [TensorType(UINT8, (32,))]  # pk is always 32 bytes for x25519
-    pfunc = PFunction(
-        fn_type="tee.attest",
-        ins_info=ins_info,
-        outs_info=outs_info,
-        platform=platform,
-    )
-    _, treedef = tree_flatten(outs_info[0])
-
-    return pfunc, [quote], treedef
+@_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,))

mplang/{protos → v1/protos}/v1alpha1/mpir_pb2.pyi

@@ -38,6 +38,7 @@ class _DataType:
 class _DataTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[_DataType.ValueType], builtins.type):
     DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
     UNDEFINED: _DataType.ValueType  # 0
+    """Undefined data type"""
     U8: _DataType.ValueType  # 1
     """uint8_t"""
     I8: _DataType.ValueType  # 2
@@ -83,6 +84,7 @@ class DataType(_DataType, metaclass=_DataTypeEnumTypeWrapper):
     """Data type enumeration"""
 
 UNDEFINED: DataType.ValueType  # 0
+"""Undefined data type"""
 U8: DataType.ValueType  # 1
 """uint8_t"""
 I8: DataType.ValueType  # 2
@@ -138,14 +140,23 @@ class AttrProto(google.protobuf.message.Message):
     class _AttrTypeEnumTypeWrapper(google.protobuf.internal.enum_type_wrapper._EnumTypeWrapper[AttrProto._AttrType.ValueType], builtins.type):
         DESCRIPTOR: google.protobuf.descriptor.EnumDescriptor
         UNDEFINED: AttrProto._AttrType.ValueType  # 0
+        """Undefined attribute type"""
         FLOAT: AttrProto._AttrType.ValueType  # 1
+        """Single float value"""
         INT: AttrProto._AttrType.ValueType  # 2
+        """Single integer value"""
         STRING: AttrProto._AttrType.ValueType  # 3
+        """Single string value"""
         BOOL: AttrProto._AttrType.ValueType  # 4
+        """Single boolean value"""
         BYTES: AttrProto._AttrType.ValueType  # 5
+        """Binary data"""
         FLOATS: AttrProto._AttrType.ValueType  # 6
+        """Array of float values"""
         INTS: AttrProto._AttrType.ValueType  # 7
+        """Array of integer values"""
         STRINGS: AttrProto._AttrType.ValueType  # 8
+        """Array of string values"""
         FUNCTION: AttrProto._AttrType.ValueType  # 10
         """Textual function reference"""
         GRAPH: AttrProto._AttrType.ValueType  # 11
@@ -155,14 +166,23 @@ class AttrProto(google.protobuf.message.Message):
         """Define possible attribute types"""
 
     UNDEFINED: AttrProto.AttrType.ValueType  # 0
+    """Undefined attribute type"""
     FLOAT: AttrProto.AttrType.ValueType  # 1
+    """Single float value"""
     INT: AttrProto.AttrType.ValueType  # 2
+    """Single integer value"""
     STRING: AttrProto.AttrType.ValueType  # 3
+    """Single string value"""
     BOOL: AttrProto.AttrType.ValueType  # 4
+    """Single boolean value"""
     BYTES: AttrProto.AttrType.ValueType  # 5
+    """Binary data"""
     FLOATS: AttrProto.AttrType.ValueType  # 6
+    """Array of float values"""
     INTS: AttrProto.AttrType.ValueType  # 7
+    """Array of integer values"""
     STRINGS: AttrProto.AttrType.ValueType  # 8
+    """Array of string values"""
     FUNCTION: AttrProto.AttrType.ValueType  # 10
     """Textual function reference"""
     GRAPH: AttrProto.AttrType.ValueType  # 11
@@ -182,24 +202,24 @@ class AttrProto(google.protobuf.message.Message):
     type: global___AttrProto.AttrType.ValueType
     """Type of the attribute"""
     f: builtins.float
-    """FLOAT"""
+    """FLOAT value"""
     i: builtins.int
-    """INT"""
+    """INT value"""
     s: builtins.str
-    """STRING"""
+    """STRING value"""
     b: builtins.bool
-    """BOOL"""
+    """BOOL value"""
     raw_bytes: builtins.bytes
     """BYTES - for raw binary data"""
     @property
     def floats(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.float]:
-        """FLOATS"""
+        """FLOATS - array of float values"""
     @property
     def ints(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
-        """INTS"""
+        """INTS - array of integer values"""
     @property
     def strs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
-        """STRINGS"""
+        """STRINGS - array of string values"""
     @property
     def func(self) -> global___FuncProto:
         """FUNCTION - textual function reference"""
@@ -228,6 +248,8 @@ global___AttrProto = AttrProto
 
 @typing_extensions.final
 class FuncProto(google.protobuf.message.Message):
+    """Function prototype message"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -254,7 +276,7 @@ class FuncProto(google.protobuf.message.Message):
     DOC_STRING_FIELD_NUMBER: builtins.int
     ATTRS_FIELD_NUMBER: builtins.int
     type: builtins.str
-    """Function type."""
+    """Function type"""
     name: builtins.str
     """Function name"""
     body: builtins.str
@@ -279,13 +301,17 @@ global___FuncProto = FuncProto
 
 @typing_extensions.final
 class TensorTypeProto(google.protobuf.message.Message):
+    """Tensor type definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     DTYPE_FIELD_NUMBER: builtins.int
     SHAPE_DIMS_FIELD_NUMBER: builtins.int
     dtype: global___DataType.ValueType
+    """Data type of the tensor elements"""
     @property
-    def shape_dims(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]: ...
+    def shape_dims(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.int]:
+        """Shape dimensions of the tensor"""
     def __init__(
         self,
         *,
@@ -298,16 +324,22 @@ global___TensorTypeProto = TensorTypeProto
 
 @typing_extensions.final
 class TableTypeProto(google.protobuf.message.Message):
+    """Table type definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
     class Column(google.protobuf.message.Message):
+        """Column definition within a table"""
+
         DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
         NAME_FIELD_NUMBER: builtins.int
         DTYPE_FIELD_NUMBER: builtins.int
         name: builtins.str
+        """Name of the column"""
         dtype: global___DataType.ValueType
+        """Data type of the column"""
         def __init__(
             self,
             *,
@@ -318,7 +350,8 @@ class TableTypeProto(google.protobuf.message.Message):
 
     COLUMNS_FIELD_NUMBER: builtins.int
     @property
-    def columns(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TableTypeProto.Column]: ...
+    def columns(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___TableTypeProto.Column]:
+        """List of columns in the table"""
     def __init__(
         self,
         *,
@@ -330,6 +363,8 @@ global___TableTypeProto = TableTypeProto
 
 @typing_extensions.final
 class MPTypeProto(google.protobuf.message.Message):
+    """Multi-party type definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -355,14 +390,16 @@ class MPTypeProto(google.protobuf.message.Message):
     PMASK_FIELD_NUMBER: builtins.int
     ATTRS_FIELD_NUMBER: builtins.int
     @property
-    def tensor_type(self) -> global___TensorTypeProto: ...
+    def tensor_type(self) -> global___TensorTypeProto:
+        """Tensor type specification"""
     @property
-    def table_type(self) -> global___TableTypeProto: ...
+    def table_type(self) -> global___TableTypeProto:
+        """Table type specification"""
     pmask: builtins.int
-    """party mask (-1 for dynamic mask, >=0 for static mask)"""
+    """Party mask (-1 for dynamic mask, >=0 for static mask)"""
     @property
     def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]:
-        """attributes"""
+        """Additional attributes"""
     def __init__(
         self,
         *,
@@ -379,6 +416,8 @@ global___MPTypeProto = MPTypeProto
 
 @typing_extensions.final
 class NodeProto(google.protobuf.message.Message):
+    """Node prototype definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -406,16 +445,20 @@ class NodeProto(google.protobuf.message.Message):
     ATTRS_FIELD_NUMBER: builtins.int
     DOC_STRING_FIELD_NUMBER: builtins.int
     op_type: builtins.str
+    """Operation type of the node"""
     name: builtins.str
+    """Name of the node"""
     @property
     def inputs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
-        """{name:index}"""
+        """Input specifications in format {name:index}"""
     @property
     def outs_info(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___MPTypeProto]:
-        """"""
+        """Output type information"""
     @property
-    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]: ...
+    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]:
+        """Node attributes"""
     doc_string: builtins.str
+    """Documentation string"""
     def __init__(
         self,
         *,
@@ -432,6 +475,8 @@ global___NodeProto = NodeProto
 
 @typing_extensions.final
 class VersionInfo(google.protobuf.message.Message):
+    """Version information definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     MAJOR_FIELD_NUMBER: builtins.int
@@ -460,6 +505,8 @@ global___VersionInfo = VersionInfo
 
 @typing_extensions.final
 class GraphProto(google.protobuf.message.Message):
+    """Graph prototype definition"""
+
     DESCRIPTOR: google.protobuf.descriptor.Descriptor
 
     @typing_extensions.final
@@ -485,14 +532,17 @@ class GraphProto(google.protobuf.message.Message):
     OUTPUTS_FIELD_NUMBER: builtins.int
     ATTRS_FIELD_NUMBER: builtins.int
     @property
-    def version(self) -> global___VersionInfo: ...
+    def version(self) -> global___VersionInfo:
+        """Version information"""
     @property
-    def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeProto]: ...
+    def nodes(self) -> google.protobuf.internal.containers.RepeatedCompositeFieldContainer[global___NodeProto]:
+        """List of nodes in the graph"""
     @property
     def outputs(self) -> google.protobuf.internal.containers.RepeatedScalarFieldContainer[builtins.str]:
-        """{name:index}"""
+        """Output specifications in format {name:index}"""
     @property
-    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]: ...
+    def attrs(self) -> google.protobuf.internal.containers.MessageMap[builtins.str, global___AttrProto]:
+        """Graph attributes"""
     def __init__(
         self,
         *,

mplang/v1/protos/v1alpha1/value_pb2.py

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: mplang/protos/v1alpha1/value.proto
+# Protobuf Python Version: 5.26.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\"mplang/protos/v1alpha1/value.proto\x12\x16mplang.protos.v1alpha1\"\xe8\x02\n\x0eValueAttrProto\x12\x43\n\x04type\x18\x01 \x01(\x0e\x32/.mplang.protos.v1alpha1.ValueAttrProto.AttrTypeR\x04type\x12\x0c\n\x01\x66\x18\x02 \x01(\x02R\x01\x66\x12\x0c\n\x01i\x18\x03 \x01(\x03R\x01i\x12\x0c\n\x01s\x18\x04 \x01(\tR\x01s\x12\x0c\n\x01\x62\x18\x05 \x01(\x08R\x01\x62\x12\x1b\n\traw_bytes\x18\x06 \x01(\x0cR\x08rawBytes\x12\x16\n\x06\x66loats\x18\x07 \x03(\x02R\x06\x66loats\x12\x12\n\x04ints\x18\x08 \x03(\x03R\x04ints\x12\x12\n\x04strs\x18\t \x03(\tR\x04strs\"|\n\x08\x41ttrType\x12\r\n\tUNDEFINED\x10\x00\x12\t\n\x05\x46LOAT\x10\x01\x12\x07\n\x03INT\x10\x02\x12\n\n\x06STRING\x10\x03\x12\x08\n\x04\x42OOL\x10\x04\x12\t\n\x05\x42YTES\x10\x05\x12\n\n\x06\x46LOATS\x10\x06\x12\x08\n\x04INTS\x10\x07\x12\x0b\n\x07STRINGS\x10\x08\x12\t\n\x05\x45MPTY\x10\t\"\xa3\x02\n\nValueProto\x12\x12\n\x04kind\x18\x01 \x01(\tR\x04kind\x12#\n\rvalue_version\x18\x02 \x01(\rR\x0cvalueVersion\x12\x18\n\x07payload\x18\x03 \x01(\x0cR\x07payload\x12Y\n\rruntime_attrs\x18\x04 \x03(\x0b\x32\x34.mplang.protos.v1alpha1.ValueProto.RuntimeAttrsEntryR\x0cruntimeAttrs\x1ag\n\x11RuntimeAttrsEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12<\n\x05value\x18\x02 \x01(\x0b\x32&.mplang.protos.v1alpha1.ValueAttrProtoR\x05value:\x02\x38\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'mplang.protos.v1alpha1.value_pb2', _globals)
+if not _descriptor._USE_C_DESCRIPTORS:
+  DESCRIPTOR._loaded_options = None
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._loaded_options = None
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._serialized_options = b'8\001'
+  _globals['_VALUEATTRPROTO']._serialized_start=63
+  _globals['_VALUEATTRPROTO']._serialized_end=423
+  _globals['_VALUEATTRPROTO_ATTRTYPE']._serialized_start=299
+  _globals['_VALUEATTRPROTO_ATTRTYPE']._serialized_end=423
+  _globals['_VALUEPROTO']._serialized_start=426
+  _globals['_VALUEPROTO']._serialized_end=717
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._serialized_start=614
+  _globals['_VALUEPROTO_RUNTIMEATTRSENTRY']._serialized_end=717
+# @@protoc_insertion_point(module_scope)