mplang-nightly 0.1.dev139__py3-none-any.whl → 0.1.dev140__py3-none-any.whl

mplang/backend/builtin.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import os
 from typing import Any
 
 import numpy as np
@@ -24,6 +23,7 @@ from mplang.backend.base import cur_kctx, kernel_def
 from mplang.core.pfunc import PFunction
 from mplang.core.table import TableType
 from mplang.core.tensor import TensorType
+from mplang.runtime.data_providers import get_provider, resolve_uri
 from mplang.utils import table_utils
 
 
@@ -50,16 +50,14 @@ def _read(pfunc: PFunction) -> Any:
     if path is None:
         raise ValueError("missing path attr for builtin.read")
     out_t = pfunc.outs_info[0]
+    uri = resolve_uri(str(path))
+    prov = get_provider(uri.scheme)
+    if prov is None:
+        raise NotImplementedError(f"no resource provider for scheme: {uri.scheme}")
+    ctx = cur_kctx()
     try:
-        if isinstance(out_t, TableType):
-            with open(path, "rb") as f:
-                csv_bytes = f.read()
-            df = table_utils.csv_to_dataframe(csv_bytes)
-            return df
-        else:
-            data = np.load(path)
-            return data
-    except Exception as e:  # pragma: no cover - filesystem errors
+        return 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
 
 
@@ -68,16 +66,13 @@ def _write(pfunc: PFunction, obj: Any) -> Any:
     path = pfunc.attrs.get("path")
     if path is None:
         raise ValueError("missing path attr for builtin.write")
+    uri = resolve_uri(str(path))
+    prov = get_provider(uri.scheme)
+    if prov is None:
+        raise NotImplementedError(f"no resource provider for scheme: {uri.scheme}")
+    ctx = cur_kctx()
     try:
-        dir_name = os.path.dirname(path)
-        if dir_name:
-            os.makedirs(dir_name, exist_ok=True)
-        if hasattr(obj, "__dataframe__") or isinstance(obj, pd.DataFrame):
-            csv_bytes = table_utils.dataframe_to_csv(obj)  # type: ignore
-            with open(path, "wb") as f:
-                f.write(csv_bytes)
-        else:
-            np.save(path, _to_numpy(obj))
+        prov.write(uri, obj, ctx=ctx)
         return obj
     except Exception as e:  # pragma: no cover
         raise RuntimeError(f"builtin.write failed: {e}") from e

mplang/frontend/builtin.py

@@ -28,22 +28,32 @@ _BUILTIN_MOD = stateless_mod("builtin")
 
 @_BUILTIN_MOD.simple_op()
 def identity(x: TensorType) -> TensorType:
-    """Identity on type: captures the underlying MPObject (if any) but kernel sees only the type.
+    """Return the input type unchanged.
 
-    Under strict typed_op semantics positional MPObject is converted to its TensorType before entering.
+    Args:
+        x: The input tensor type. If called with an MPObject, the value is
+            captured positionally; the kernel sees only the type.
+
+    Returns:
+        The same type as ``x``.
     """
     return x
 
 
 @_BUILTIN_MOD.simple_op()
 def read(*, path: str, ty: TensorType) -> TensorType:
-    """Type-only kernel for reading a tensor/table from a path.
+    """Declare reading a value of type ``ty`` from ``path`` (type-only).
+
+    Args:
+        path: Non-empty path or URI to read from (stored as an attribute).
+        ty: The expected output type/schema.
 
-    Attributes:
-      - path: str destination to read from (carried as PFunction attr)
-      - ty:   TensorType/TableType describing the expected output type
+    Returns:
+        Exactly ``ty``.
 
-    Returns: ty (shape/dtype/schema), no inputs captured.
+    Raises:
+        ValueError: If ``path`` is empty.
+        TypeError: If ``ty`` is not a TensorType or TableType.
     """
     if not isinstance(path, str) or path == "":
         raise ValueError("path must be a non-empty string")
@@ -55,9 +65,14 @@ def read(*, path: str, ty: TensorType) -> TensorType:
 
 @_BUILTIN_MOD.simple_op()
 def write(x: TensorType, *, path: str) -> TensorType:
-    """Write op: returns same type it consumes; runtime handles side effect.
+    """Declare writing the input value to ``path`` and return the same type.
+
+    Args:
+        x: The value's type to be written; values are captured positionally.
+        path: Destination path or URI (attribute).
 
-    Positional MPObject (tensor/table) will be captured; kernel sees only its type.
+    Returns:
+        The same type as ``x``.
     """
     return x
 
@@ -66,6 +81,20 @@ def write(x: TensorType, *, path: str) -> TensorType:
 def constant(
     data: TensorLike | ScalarType | TableLike,
 ) -> tuple[PFunction, list[MPObject], PyTreeDef]:
+    """Embed a literal tensor/table and return the full triad.
+
+    Args:
+        data: Constant payload. Supports scalars, array-like tensors, or
+            table-like dataframes.
+
+    Returns:
+        Tuple[PFunction, list[MPObject], PyTreeDef]:
+        - PFunction: ``fn_type='builtin.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).
+        - PyTreeDef: Output tree (single leaf).
+    """
     import numpy as np
 
     data_bytes: bytes
@@ -103,19 +132,23 @@ def constant(
 
 @_BUILTIN_MOD.simple_op()
 def rank() -> TensorType:
-    """Type-only kernel: returns the UINT64 scalar tensor type for current rank.
+    """Return the scalar UINT64 tensor type for the current party rank.
 
-    Runtime provides the concrete rank value per party during execution; here we
-    only declare the output type with no inputs captured and no attributes.
+    Returns:
+        A scalar ``UINT64`` tensor type (shape ``()``).
     """
     return TensorType(UINT64, ())
 
 
 @_BUILTIN_MOD.simple_op()
 def prand(*, shape: Shape = ()) -> TensorType:
-    """Type-only kernel: private random UINT64 tensor of given shape.
+    """Declare a private random UINT64 tensor with the given shape.
+
+    Args:
+        shape: Output tensor shape. Defaults to ``()``.
 
-    Shape is attached as a PFunction attribute via typed_op; no inputs.
+    Returns:
+        A ``UINT64`` tensor type with the specified shape.
     """
     return TensorType(UINT64, shape)
 
@@ -124,21 +157,30 @@ def prand(*, shape: Shape = ()) -> TensorType:
 def debug_print(
     x: TensorType | TableType, *, prefix: str = ""
 ) -> TableType | TensorType:
-    """Debug-print pass-through: type identity with side-effect attribute.
+    """Print a value at runtime and return the same type.
 
-    Accepts tensor/table type; MPObject positional (if provided) is captured automatically.
+    Args:
+        x: The value to print (captured positionally; kernel sees only type).
+        prefix: Optional text prefix for the printed output.
+
+    Returns:
+        The same type as ``x``.
     """
     return x
 
 
 @_BUILTIN_MOD.simple_op()
 def pack(x: TensorType | TableType) -> TensorType:
-    """Type-only pack operator: models serialization into a byte vector.
+    """Serialize a tensor/table into a byte vector (type-only).
+
+    Args:
+        x: Input type to pack.
 
-    The frontend only declares the type transformation; the runtime decides
-    whether any actual serialization takes place. The result is always a
-    one-dimensional UINT8 tensor with unknown length (-1 means runtime
-    determined).
+    Returns:
+        A ``UINT8`` tensor type with shape ``(-1,)`` (length decided at runtime).
+
+    Raises:
+        TypeError: If ``x`` is not a TensorType or TableType.
     """
 
     if not isinstance(x, (TensorType, TableType)):
@@ -149,10 +191,19 @@ def pack(x: TensorType | TableType) -> TensorType:
 
 @_BUILTIN_MOD.simple_op()
 def unpack(b: TensorType, *, out_ty: TensorType | TableType) -> TensorType | TableType:
-    """Type-only unpack operator: inverse of `pack`.
+    """Deserialize a byte vector into the explicit output type.
+
+    Args:
+        b: Byte vector type. Must be ``UINT8`` with shape ``(N,)`` (``N`` may be
+            ``-1``).
+        out_ty: Resulting type/schema after unpacking.
 
-    Requires a one-dimensional UINT8 tensor input (length can be -1) and
-    returns the explicit `out_ty` type description.
+    Returns:
+        Exactly ``out_ty``.
+
+    Raises:
+        TypeError: If ``out_ty`` is not a TensorType/TableType, or if ``b`` is
+            not a 1-D UINT8 tensor.
     """
 
     if not isinstance(out_ty, (TensorType, TableType)):
@@ -166,6 +217,21 @@ def unpack(b: TensorType, *, out_ty: TensorType | TableType) -> TensorType | Tab
 
 @_BUILTIN_MOD.simple_op()
 def table_to_tensor(table: TableType, *, number_rows: int) -> TensorType:
+    """Convert a homogeneous-typed table to a dense 2D tensor.
+
+    Args:
+        table: Input table whose columns all share the same dtype.
+        number_rows: Number of rows in the resulting tensor. Must be ``>= 0``.
+
+    Returns:
+        A rank-2 tensor with dtype equal to the table column dtype and shape
+        ``(number_rows, table.num_columns())``.
+
+    Raises:
+        ValueError: If the table is empty or ``number_rows < 0``.
+        TypeError: If the table has heterogeneous column dtypes or ``number_rows``
+            is not an int.
+    """
     if table.num_columns() == 0:
         raise ValueError("Cannot pack empty table")
     col_dtypes = list(table.column_types())
@@ -184,6 +250,21 @@ def table_to_tensor(table: TableType, *, number_rows: int) -> TensorType:
 
 @_BUILTIN_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.
+
+    Args:
+        tensor: Rank-2 tensor with shape ``(N, F)``.
+        column_names: List of unique, non-whitespace column names of length ``F``.
+
+    Returns:
+        A table with ``F`` columns named as provided, each with dtype
+        ``tensor.dtype``.
+
+    Raises:
+        TypeError: If ``tensor`` is not rank-2, or if any column name is not a
+            string.
+        ValueError: If names are empty/whitespace, duplicated, or length != ``F``.
+    """
     if len(tensor.shape) != 2:
         raise TypeError("tensor_to_table expects a rank-2 tensor (N,F)")
     n_cols = tensor.shape[1]

mplang/runtime/client.py

@@ -403,3 +403,57 @@ class HttpExecutorClient:
             raise self._raise_http_error(
                 f"list computations for session {session_name}", e
             ) from e
+
+    # ---------------- Global Symbols (process-level) ----------------
+    async def create_global_symbol(
+        self, symbol_name: str, data: Any, mptype: dict | None = None
+    ) -> None:
+        """Create or replace a process-global symbol.
+
+        Args:
+            symbol_name: Identifier
+            data: Python object to store (pickle based)
+            mptype: Optional metadata dict
+        """
+        url = f"/api/v1/symbols/{symbol_name}"
+        try:
+            payload = {
+                "data": base64.b64encode(pickle.dumps(data)).decode("utf-8"),
+                "mptype": mptype or {},
+            }
+            resp = await self._client.put(url, json=payload)
+            resp.raise_for_status()
+        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+            raise self._raise_http_error(
+                f"create global symbol {symbol_name}", e
+            ) from e
+
+    async def get_global_symbol(self, symbol_name: str) -> Any:
+        url = f"/api/v1/symbols/{symbol_name}"
+        try:
+            resp = await self._client.get(url)
+            resp.raise_for_status()
+            payload = resp.json()
+            data_bytes = base64.b64decode(payload["data"])
+            return pickle.loads(data_bytes)
+        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+            raise self._raise_http_error(f"get global symbol {symbol_name}", e) from e
+
+    async def delete_global_symbol(self, symbol_name: str) -> None:
+        url = f"/api/v1/symbols/{symbol_name}"
+        try:
+            resp = await self._client.delete(url)
+            resp.raise_for_status()
+        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+            raise self._raise_http_error(
+                f"delete global symbol {symbol_name}", e
+            ) from e
+
+    async def list_global_symbols(self) -> list[str]:
+        url = "/api/v1/symbols"
+        try:
+            resp = await self._client.get(url)
+            resp.raise_for_status()
+            return list(resp.json().get("symbols", []))
+        except (httpx.HTTPStatusError, httpx.RequestError) as e:
+            raise self._raise_http_error("list global symbols", e) from e

mplang/runtime/data_providers.py

@@ -0,0 +1,248 @@
+# 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 dataclasses import dataclass
+from typing import Any
+from urllib.parse import ParseResult, urlparse
+
+import numpy as np
+import pandas as pd
+
+from mplang.backend.base import KernelContext
+from mplang.core.table import TableType
+from mplang.core.tensor import TensorType
+from mplang.utils import table_utils
+
+
+@dataclass(frozen=True)
+class ResolvedURI:
+    """Result of resolving a resource path into a normalized form.
+
+    Attributes:
+      scheme: The URI scheme (e.g., 'file', 's3', 'mem', 'var', 'secret').
+      raw: The original path string as provided by the user.
+      parsed: The ParseResult if a scheme was present; otherwise None.
+      local_path: For file paths: concrete filesystem path (absolute or as given).
+    """
+
+    scheme: str
+    raw: str
+    parsed: ParseResult | None
+    local_path: str | None
+
+
+def resolve_uri(path: str) -> ResolvedURI:
+    """Resolve a user-provided resource location into a normalized URI form.
+
+    This helper accepts plain filesystem paths and RFC 3986 style URIs. A path
+    is treated as ``file`` when ``urlparse(path).scheme`` is empty. Detection
+    no longer depends on the presence of the literal substring ``"://"`` so
+    that forms like ``mem:foo`` (no slashes) are still recognized as a URI.
+
+    Captured fields
+    - ``scheme``: Lower-cased scheme (``file`` when absent)
+    - ``raw``: Original input
+    - ``parsed``: ``ParseResult`` when a scheme was provided, else ``None``
+    - ``local_path``: Filesystem path for ``file`` scheme, else ``None``
+
+    Supported (pluggable) schemes out-of-the-box:
+      * ``file`` (default)
+      * ``mem``
+      * ``s3`` (stub)
+      * ``secret`` (stub)
+      * ``symbols`` (registered server-side)
+
+    Examples
+    >>> resolve_uri("data/train.npy").scheme
+    'file'
+    >>> resolve_uri("mem:dataset1").scheme
+    'mem'
+    >>> resolve_uri("mem://dataset1").scheme  # both forms acceptable
+    'mem'
+    >>> resolve_uri("symbols://shared_model").scheme
+    'symbols'
+    >>> resolve_uri("file:///tmp/x.npy").local_path
+    '/tmp/x.npy'
+    """
+
+    pr = urlparse(path)
+    if not pr.scheme:
+        return ResolvedURI("file", path, None, path)
+
+    scheme = pr.scheme.lower()
+    local_path: str | None = None
+    if scheme == "file":
+        local_path = pr.path
+        if pr.netloc and not local_path.startswith("/"):
+            local_path = f"//{pr.netloc}/{pr.path}"
+    return ResolvedURI(scheme, path, pr, local_path)
+
+
+class DataProvider:
+    """Abstract base for data providers.
+
+    Minimal contract: read/write by URI and type spec. Providers may ignore the
+    type spec but SHOULD validate when feasible.
+    """
+
+    def read(
+        self, uri: ResolvedURI, out_spec: TensorType | TableType, *, ctx: KernelContext
+    ) -> Any:
+        raise NotImplementedError
+
+    def write(self, uri: ResolvedURI, value: Any, *, ctx: KernelContext) -> None:
+        raise NotImplementedError
+
+
+_REGISTRY: dict[str, DataProvider] = {}
+
+
+def register_provider(
+    scheme: str, provider: DataProvider, *, replace: bool = False, quiet: bool = False
+) -> None:
+    """Register a provider implementation.
+
+    Args:
+        scheme: URI scheme handled (case-insensitive)
+        provider: Implementation
+        replace: If False and scheme exists -> ValueError
+        quiet: If True, suppress duplicate log messages when replacing
+    """
+    import logging
+
+    key = scheme.lower()
+    if not replace and key in _REGISTRY:
+        raise ValueError(f"provider already registered for scheme: {scheme}")
+    if replace and key in _REGISTRY and not quiet:
+        logging.info(f"Replacing existing provider for scheme '{scheme}'")
+    _REGISTRY[key] = provider
+
+
+def get_provider(scheme: str) -> DataProvider | None:
+    return _REGISTRY.get(scheme.lower())
+
+
+# ---------------- Default Providers ----------------
+
+
+class FileProvider(DataProvider):
+    """Local filesystem provider.
+
+    For tables: CSV bytes via table_utils.
+    For tensors: NumPy .npy via np.load/np.save.
+    """
+
+    def read(
+        self, uri: ResolvedURI, out_spec: TensorType | TableType, *, ctx: KernelContext
+    ) -> Any:
+        path = uri.local_path or uri.raw
+        if isinstance(out_spec, TableType):
+            with open(path, "rb") as f:
+                csv_bytes = f.read()
+            return table_utils.csv_to_dataframe(csv_bytes)
+        # tensor path
+        return np.load(path)
+
+    def write(self, uri: ResolvedURI, value: Any, *, ctx: KernelContext) -> None:
+        import os
+
+        path = uri.local_path or uri.raw
+        dir_name = os.path.dirname(path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+        # Table-like to CSV bytes
+        if hasattr(value, "__dataframe__") or isinstance(value, pd.DataFrame):
+            csv_bytes = table_utils.dataframe_to_csv(value)  # type: ignore
+            with open(path, "wb") as f:
+                f.write(csv_bytes)
+            return
+        # Tensor-like via numpy
+        np.save(path, np.asarray(value))
+
+
+class _KeyedPocket:
+    """Small helper to keep a dict in KernelContext.state under a namespaced key."""
+
+    def __init__(self, ns: str):
+        self.ns = ns
+
+    def get_map(self, ctx: KernelContext) -> dict[str, Any]:
+        pocket = ctx.state.setdefault("resource.providers", {})
+        store = pocket.get(self.ns)
+        if store is None:
+            store = {}
+            pocket[self.ns] = store
+        return store  # type: ignore[return-value]
+
+
+class MemProvider(DataProvider):
+    """In-memory per-runtime KV provider (per rank, per session/runtime)."""
+
+    def __init__(self) -> None:
+        self._pocket = _KeyedPocket("mem")
+
+    def read(
+        self, uri: ResolvedURI, out_spec: TensorType | TableType, *, ctx: KernelContext
+    ) -> Any:
+        store = self._pocket.get_map(ctx)
+        key = uri.raw
+        if key not in store:
+            raise FileNotFoundError(f"mem resource not found: {key}")
+        return store[key]
+
+    def write(self, uri: ResolvedURI, value: Any, *, ctx: KernelContext) -> None:
+        store = self._pocket.get_map(ctx)
+        store[uri.raw] = value
+
+
+class S3Provider(DataProvider):
+    """Placeholder S3 provider. Install external plugin to enable."""
+
+    def read(
+        self, uri: ResolvedURI, out_spec: TensorType | TableType, *, ctx: KernelContext
+    ) -> Any:
+        raise NotImplementedError(
+            "S3 provider not installed. Provide an external plugin via register_provider('s3', ...) ."
+        )
+
+    def write(self, uri: ResolvedURI, value: Any, *, ctx: KernelContext) -> None:
+        raise NotImplementedError(
+            "S3 provider not installed. Provide an external plugin via register_provider('s3', ...) ."
+        )
+
+
+class SecretProvider(DataProvider):
+    """Placeholder secret provider. Integrate with KMS/secret manager via plugin."""
+
+    def read(
+        self, uri: ResolvedURI, out_spec: TensorType | TableType, *, ctx: KernelContext
+    ) -> Any:
+        raise NotImplementedError(
+            "secret provider not installed. Provide an external plugin via register_provider('secret', ...) ."
+        )
+
+    def write(self, uri: ResolvedURI, value: Any, *, ctx: KernelContext) -> None:
+        raise NotImplementedError(
+            "secret provider not installed. Provide an external plugin via register_provider('secret', ...) ."
+        )
+
+
+# Register default providers
+register_provider("file", FileProvider())
+register_provider("mem", MemProvider())
+# Stubs to signal missing providers explicitly (can be overridden by plugins)
+register_provider("s3", S3Provider())
+register_provider("secret", SecretProvider())

mplang/runtime/resource.py

@@ -36,7 +36,7 @@ from mplang.backend import (  # noqa: F401
     stablehlo,
     tee,
 )
-from mplang.backend.base import create_runtime
+from mplang.backend.base import BackendRuntime, create_runtime
 from mplang.backend.spu import PFunction  # type: ignore
 from mplang.core.expr.ast import Expr
 from mplang.core.expr.evaluator import IEvaluator, create_evaluator
@@ -98,6 +98,9 @@ class Session:
 # Global session storage
 _sessions: dict[str, Session] = {}
 
+# Service-level global symbol table (process-local for this server)
+_global_symbols: dict[str, Symbol] = {}
+
 
 # Session Management
 def create_session(
@@ -223,6 +226,14 @@ def execute_computation(
     # Build evaluator
     # Explicit per-rank backend runtime (deglobalized)
     runtime = create_runtime(rank, session.communicator.world_size)
+    # Inject global symbol storage into backend runtime state so that
+    # symbols:// provider can access it during builtin.read/write.
+    if isinstance(runtime, BackendRuntime):
+        pocket = runtime.state.setdefault("resource.providers", {})
+        if "symbols" not in pocket:
+            pocket["symbols"] = _global_symbols
+        else:
+            raise RuntimeError("resource.providers.symbols already exists")
     evaluator: IEvaluator = create_evaluator(
         rank=rank, env=bindings, comm=session.communicator, runtime=runtime
     )
@@ -274,6 +285,45 @@ def execute_computation(
             session.symbols[name] = Symbol(name=name, mptype={}, data=val)
 
 
+# Global symbol CRUD (service-level)
+def create_global_symbol(name: str, mptype: Any, data: str) -> Symbol:
+    """Create or update a global symbol in the service-level table.
+
+    WARNING: Uses Python pickle for arbitrary object deserialization. Deploy
+    only in trusted environments. Future work may replace this with a
+    restricted / structured serialization.
+
+    The `data` argument is a base64-encoded pickled Python object. Minimal
+    validation of `mptype` is performed for tensor metadata (shape/dtype)
+    when present to catch obvious mismatches.
+    """
+    try:
+        data_bytes = base64.b64decode(data)
+        obj = pickle.loads(data_bytes)
+    except Exception as e:
+        raise InvalidRequestError(f"Invalid global symbol data encoding: {e!s}") from e
+
+    sym = Symbol(name, mptype, obj)
+    _global_symbols[name] = sym
+    return sym
+
+
+def get_global_symbol(name: str) -> Symbol | None:
+    return _global_symbols.get(name)
+
+
+def list_global_symbols() -> list[str]:
+    return list(_global_symbols.keys())
+
+
+def delete_global_symbol(name: str) -> bool:
+    if name in _global_symbols:
+        del _global_symbols[name]
+        logging.info(f"Global symbol {name} deleted")
+        return True
+    return False
+
+
 # Symbol Management
 def create_symbol(session_name: str, name: str, mptype: Any, data: Any) -> Symbol:
     """Create a symbol in a session's symbol table.

mplang/runtime/server.py

@@ -20,15 +20,20 @@ It uses FastAPI to provide a RESTful API for managing computations.
 import base64
 import logging
 import re
+from typing import Any
 
 import cloudpickle as pickle
 from fastapi import FastAPI, HTTPException, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 
+from mplang.backend.base import KernelContext
 from mplang.core.mpir import Reader
+from mplang.core.table import TableType
+from mplang.core.tensor import TensorType
 from mplang.protos.v1alpha1 import mpir_pb2
 from mplang.runtime import resource
+from mplang.runtime.data_providers import DataProvider, ResolvedURI, register_provider
 from mplang.runtime.exceptions import InvalidRequestError, ResourceNotFound
 
 logger = logging.getLogger(__name__)
@@ -36,6 +41,75 @@ logger = logging.getLogger(__name__)
 app = FastAPI()
 
 
+class _SymbolsProvider(DataProvider):
+    """Server-local symbols provider backed by BackendRuntime.state."""
+
+    @staticmethod
+    def _symbol_name(uri: ResolvedURI) -> str:
+        if uri.scheme != "symbols" or uri.parsed is None:
+            raise InvalidRequestError(
+                "symbols provider expects URI in the form symbols://{name}"
+            )
+
+        parsed = uri.parsed
+        if parsed.query or parsed.params or parsed.fragment:
+            raise InvalidRequestError(
+                "symbols:// URI must not contain query or fragment"
+            )
+
+        if parsed.netloc:
+            # e.g. symbols://foo -> name is carried in netloc (path may be empty or "/")
+            if parsed.path not in ("", "/"):
+                raise InvalidRequestError("symbols:// URIs cannot include subpaths")
+            name = parsed.netloc
+        else:
+            # e.g. symbols:///foo -> netloc empty, single path segment is the symbol name
+            path = parsed.path.lstrip("/")
+            if not path or "/" in path:
+                raise InvalidRequestError(
+                    "symbols:// URI must specify a single symbol name"
+                )
+            name = path
+
+        if not name:
+            raise InvalidRequestError("symbols:// URI missing symbol name")
+        return name
+
+    def read(
+        self,
+        uri: ResolvedURI,
+        out_spec: TensorType | TableType,
+        *,
+        ctx: KernelContext,
+    ) -> Any:  # type: ignore[override]
+        name = self._symbol_name(uri)
+        sym = resource.get_global_symbol(name)
+        if sym is None:
+            raise ResourceNotFound(f"Global symbol '{name}' not found")
+        return sym.data
+
+    def write(
+        self,
+        uri: ResolvedURI,
+        value: Any,
+        *,
+        ctx: KernelContext,
+    ) -> None:  # type: ignore[override]
+        name = self._symbol_name(uri)
+        try:
+            data_b64 = base64.b64encode(pickle.dumps(value)).decode("utf-8")
+        except Exception as e:  # pragma: no cover - defensive
+            raise InvalidRequestError(
+                f"Failed to encode value for symbols:// write: {e!s}"
+            ) from e
+
+        resource.create_global_symbol(name, {}, data_b64)
+
+
+# Register symbols provider explicitly for server runtime
+register_provider("symbols", _SymbolsProvider())
+
+
 @app.exception_handler(ResourceNotFound)
 def resource_not_found_handler(request: Request, exc: ResourceNotFound) -> JSONResponse:
     """Handler for ResourceNotFound exceptions."""
@@ -139,6 +213,12 @@ class ComputationListResponse(BaseModel):
     computations: list[str]
 
 
+class GlobalSymbolResponse(BaseModel):
+    name: str
+    mptype: dict
+    data: str
+
+
 @app.get("/health")
 async def health_check() -> dict[str, str]:
     """Health check endpoint."""
@@ -303,6 +383,39 @@ def delete_symbol(session_name: str, symbol_name: str) -> dict[str, str]:
         )
 
 
+# Global Symbols endpoints
+@app.put("/api/v1/symbols/{symbol_name}", response_model=GlobalSymbolResponse)
+def create_global_symbol(
+    symbol_name: str, request: CreateSymbolRequest
+) -> GlobalSymbolResponse:
+    validate_name(symbol_name, "symbol")
+    sym = resource.create_global_symbol(symbol_name, request.mptype, request.data)
+    return GlobalSymbolResponse(name=sym.name, mptype=sym.mptype, data=request.data)
+
+
+@app.get("/api/v1/symbols/{symbol_name}", response_model=GlobalSymbolResponse)
+def get_global_symbol(symbol_name: str) -> GlobalSymbolResponse:
+    sym = resource.get_global_symbol(symbol_name)
+    if not sym:
+        raise ResourceNotFound(f"Global symbol '{symbol_name}' not found")
+    data_bytes = pickle.dumps(sym.data)
+    data_b64 = base64.b64encode(data_bytes).decode("utf-8")
+    return GlobalSymbolResponse(name=sym.name, mptype=sym.mptype, data=data_b64)
+
+
+@app.get("/api/v1/symbols")
+def list_global_symbols() -> dict[str, list[str]]:
+    return {"symbols": resource.list_global_symbols()}
+
+
+@app.delete("/api/v1/symbols/{symbol_name}")
+def delete_global_symbol(symbol_name: str) -> dict[str, str]:
+    if resource.delete_global_symbol(symbol_name):
+        return {"message": f"Global symbol '{symbol_name}' deleted successfully"}
+    else:
+        raise ResourceNotFound(f"Global symbol '{symbol_name}' not found")
+
+
 # Communication endpoints
 # TODO(jint) this should be computation level, add multi computation parallel support.
 @app.put("/sessions/{session_name}/comm/{key}/from/{from_rank}")

{mplang_nightly-0.1.dev139.dist-info → mplang_nightly-0.1.dev140.dist-info}/METADATA

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

{mplang_nightly-0.1.dev139.dist-info → mplang_nightly-0.1.dev140.dist-info}/RECORD

@@ -5,7 +5,7 @@ mplang/analysis/__init__.py,sha256=CTHFvRsi-nFngojqjn08UaR3RY9i7CJ7T2UdR95kCrk,1
 mplang/analysis/diagram.py,sha256=ffwgD12gL1_KH1uJ_EYkjmIlDrfxYJJkWj-wHl09_Xk,19520
 mplang/backend/__init__.py,sha256=Pn1MGW7FZ8ZQWcx_r2Io4Q1JbrMINCpefQt7yCNq_dc,741
 mplang/backend/base.py,sha256=zaofB1MPC9Af8FS-rx7q6utFxiu9Mppr2gWaKFZ70Os,9863
-mplang/backend/builtin.py,sha256=usQjxzYPP8bYqazJveS91SXr0i1i4oe0N4b7aPABKuA,7181
+mplang/backend/builtin.py,sha256=Mk1uUO2Vpw3meqZ0B7B0hG-wndea6cmFv2Uk1vM_uTg,7052
 mplang/backend/crypto.py,sha256=H_s5HI7lUP7g0xz-a9qMbSn6dhJStUilKbn3-7SIh0I,3812
 mplang/backend/phe.py,sha256=Y07fkTHTSKHgpMQ1soA3d2eBMlqr25uHCAtZOd5D5_I,10555
 mplang/backend/spu.py,sha256=i6Qqgeg-Anwpb5xX5Uz8GdmTWNkRy_pjp-xptIvlxl4,9273
@@ -37,7 +37,7 @@ mplang/core/expr/visitor.py,sha256=2Ge-I5N-wH8VVXy8d2WyNaEv8x6seiRx9peyH9S2BYU,2
 mplang/core/expr/walk.py,sha256=lXkGJEEuvKGDqQihbxXPxfz2RfR1Q1zYUlt11iooQW0,11889
 mplang/frontend/__init__.py,sha256=3ZBFX_acM96tZ2mtJaxJm150n1cf0LnnCRmkrAc4uBw,1463
 mplang/frontend/base.py,sha256=I-Hhh5o6GVqBA1YySl9Nk3zkbMoVrQqLMRyX2JypsPI,18268
-mplang/frontend/builtin.py,sha256=M3zquGYmZP0SgL6v34LiPibD1PiwFSn-zzo2Q1eeq4s,7259
+mplang/frontend/builtin.py,sha256=8qrlbe_SSy6QTXTnMG6_ADB8jSklVZGFBrkoR-p02FE,9368
 mplang/frontend/crypto.py,sha256=Nf8zT4Eko7MIs4R2tgZecKVd7d6Hvd_CGGmANhs3Ghs,3651
 mplang/frontend/ibis_cc.py,sha256=01joUdFS_Ja9--PkezBhEcW_a9mkDrLgOhu5320s_bQ,4167
 mplang/frontend/jax_cc.py,sha256=ssP6rCvyWQ5VAr80-7z9QZUE2mWXyozJCGpq1dYQYY8,6374
@@ -50,14 +50,15 @@ mplang/protos/v1alpha1/mpir_pb2.pyi,sha256=GwXR4wPB_kB_36iYS9x-cGI9KDKFMq89KhdLh
 mplang/protos/v1alpha1/mpir_pb2_grpc.py,sha256=xYOs94SXiNYAlFodACnsXW5QovLsHY5tCk3p76RH5Zc,158
 mplang/runtime/__init__.py,sha256=IRPP3TtpFC4iSt7_uaq-S4dL7CwrXL0XBMeaBoEYLlg,948
 mplang/runtime/cli.py,sha256=WehDodeVB4AukSWx1LJxxtKUqGmLPY4qjayrPlOg3bE,14438
-mplang/runtime/client.py,sha256=9YGyTGox-zAUIkGGiwruCJauEfzf5hQsDU3HBd_PxHE,13555
+mplang/runtime/client.py,sha256=w8sPuQzqaJI5uS_3JHu2mf0tLaFmZH3f6-SeUBfMLMY,15737
 mplang/runtime/communicator.py,sha256=Lek6_h_Wmr_W-_JpT-vMxL3CHxcVZdtf7jdaLGuxPgQ,3199
+mplang/runtime/data_providers.py,sha256=TPAJSko_2J95oiHCxAKALICVM_LvnxzfgcM48ubhnKU,8226
 mplang/runtime/driver.py,sha256=Ok1jY301ctN1_KTb4jwSxOdB0lI_xhx9AwhtEGJ-VLQ,11300
 mplang/runtime/exceptions.py,sha256=c18U0xK20dRmgZo0ogTf5vXlkix9y3VAFuzkHxaXPEk,981
 mplang/runtime/http_api.md,sha256=-re1DhEqMplAkv_wnqEU-PSs8tTzf4-Ml0Gq0f3Go6s,4883
 mplang/runtime/link_comm.py,sha256=uNqTCGZVwWeuHAb7yXXQf0DUsMXLa8leHCkrcZdzYMU,4559
-mplang/runtime/resource.py,sha256=nGNIYGS1qL34tumoTJKZqT30AnS9C2-JrHZuFMJ1BTA,10776
-mplang/runtime/server.py,sha256=onDw3hnqSIK8cOYuRgblTC4myr-V7ym72GW6pWrpFQE,10698
+mplang/runtime/resource.py,sha256=BkzpAjRrkjS-5FPawHHcVzxEE_htpMtS4JJCvcLrnU0,12564
+mplang/runtime/server.py,sha256=gTPqAux1EdefaBFnserYIXamoi7pbEsQrFX6cXbOjik,14716
 mplang/runtime/simulation.py,sha256=kj-RtvvypISO2xyYQGtm-N8yavnkVpD33KSLpvL-Vms,11107
 mplang/simp/__init__.py,sha256=DmSMcKvHVXWS2pYsuHazEmwOWWpZeKOJQsNU6VxC10U,11614
 mplang/simp/mpi.py,sha256=Wv_Q16TQ3rdLam6OzqXiefIGSMmagGkso09ycyOkHEs,4774
@@ -68,8 +69,8 @@ mplang/utils/crypto.py,sha256=rvPomBFtznRHc3RPi6Aip9lsU8zW2oxBqGv1K3vn7Rs,1052
 mplang/utils/func_utils.py,sha256=vCJcZmu0bEbqhOQKdpttV2_MBllIcPSN0b8U4WjNGGo,5164
 mplang/utils/spu_utils.py,sha256=S3L9RBkBe2AvSuMSQQ12cBY5Y1NPthubvErSX_7nj1A,4158
 mplang/utils/table_utils.py,sha256=aC-IZOKkSmFkpr3NZchLM0Wt0GOn-rg_xHBHREWBwAU,2202
-mplang_nightly-0.1.dev139.dist-info/METADATA,sha256=KejJXvQkNu9KXYerLe6dUhuyIuH54OrxhHq6IMDfJNA,16547
-mplang_nightly-0.1.dev139.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mplang_nightly-0.1.dev139.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
-mplang_nightly-0.1.dev139.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-mplang_nightly-0.1.dev139.dist-info/RECORD,,
+mplang_nightly-0.1.dev140.dist-info/METADATA,sha256=uvtKWbcwO-wpF_BxVBDWqof7tV82vY7vXMLH77prn5g,16547
+mplang_nightly-0.1.dev140.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mplang_nightly-0.1.dev140.dist-info/entry_points.txt,sha256=mG1oJT-GAjQR834a62_QIWb7litzWPPyVnwFqm-rWuY,55
+mplang_nightly-0.1.dev140.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+mplang_nightly-0.1.dev140.dist-info/RECORD,,