uptimely-core 0.2.0.dev1__tar.gz → 0.3.0__tar.gz

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uptimely-core
-Version: 0.2.0.dev1
+Version: 0.3.0
 Summary: Manage data-driven numerical analytics with complex dependencies at scale
 License-Expression: MIT
 License-File: LICENSE

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "uptimely-core"
-version = "0.2.0.dev1"
+version = "0.3.0"
 description = "Manage data-driven numerical analytics with complex dependencies at scale"
 authors = [{ name = "Mikael Ahonen", email = "mikael.ahonen@uptimely.ai" }]
 license = "MIT"

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/__init__.py

@@ -3,36 +3,28 @@
 from .compiler import CallableGraph, CallableNode, Compiler, ExecutionPlan
 from .engine import Engine
 from .spec import (
-    Call,
     Dimension,
     Entity,
     FeatureGraph,
-    Function,
-    PreparedSpec,
     PythonSpec,
     Spec,
     SubGraph,
     from_python,
     load_spec,
-    prepare_spec,
     write_document,
 )
 
 __all__ = [
     "Spec",
-    "Call",
     "CallableGraph",
     "CallableNode",
     "Compiler",
     "Dimension",
     "Entity",
     "ExecutionPlan",
-    "Function",
     "PythonSpec",
-    "PreparedSpec",
     "from_python",
     "load_spec",
-    "prepare_spec",
     "write_document",
     "SubGraph",
     "FeatureGraph",

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/compiler/callable_node.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import dataclasses
 
-from uptimely import render, row_context, spec
+from uptimely import render, row_context
 
 
 @dataclasses.dataclass(frozen=True)
@@ -17,7 +17,7 @@ class CallableNode:
     mapping_id: str | None = None
     output_features: tuple[str, ...] = ()
     args: dict[str, object] = dataclasses.field(default_factory=dict, compare=False, hash=False)
-    callable: spec.Call | None = dataclasses.field(default=None, compare=False, hash=False)
+    input_features: tuple[str, ...] = ()
     row_context: row_context.RowContext | None = dataclasses.field(
         default=None, compare=False, hash=False
     )
@@ -49,6 +49,6 @@ class CallableNode:
             feature=self.feature,
             output_features=list(self.output_features),
             depends_on_features=(
-                self.callable.depends_on_features if self.callable is not None else None
+                list(self.input_features) if self.operation == "vectorize" else None
             ),
         )

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/compiler/compiler.py

@@ -183,6 +183,8 @@ class Compiler:
     ) -> None:
         """Require the Python return annotation to satisfy the function contract."""
         returns = function.returns
+        if returns == "any":
+            return
         if annotation is None:
             raise ValueError(
                 f"Function {function.id} must annotate its return as "

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/compiler/execution_graph.py

@@ -6,7 +6,7 @@ import graphable as graphable_
 from graphable.views import texttree
 
 from uptimely import contracts, spec
-from uptimely.spec import api as spec_api
+from uptimely.spec import validation
 
 from ..spec import references as bindings
 from . import callable_node as callable_node_module
@@ -25,16 +25,12 @@ class CallableGraph:
             spec: The spec document containing function declarations and invocations.
         """
         self.spec = spec
-        prepared = spec_api.prepare_spec(spec)
+        validation.validate_spec(spec)
         self._datasets = {
             (entity_id, dataset.id): dataset
             for entity_id, entity in spec.entities.items()
             for dataset in entity.datasets
         }
-        self.calls = prepared.calls
-        self.functions = [function for function in prepared.functions if function.role == "spec"]
-        # Index all callables by (function_id, entity, feature) to resolve dependencies
-        self._callable_index: dict[tuple[str, str, str], callable_node_module.CallableNode] = {}
         # Map feature names to the callables that produce them
         self._feature_producers: dict[str, callable_node_module.CallableNode] = {}
         self._dataset_sources: dict[tuple[str, str], list[callable_node_module.CallableNode]] = {}
@@ -53,14 +49,6 @@ class CallableGraph:
                     primary_feature = (
                         mapping.output_features[0] if mapping.output_features else None
                     )
-                    call = next(
-                        (
-                            call
-                            for call in self.calls
-                            if call.entity == entity_id and call.feature in mapping.output_features
-                        ),
-                        None,
-                    )
                     node = callable_node_module.CallableNode(
                         function_id=mapping.binding.function,
                         entity=entity_id,
@@ -70,20 +58,18 @@ class CallableGraph:
                         mapping_id=mapping.id,
                         output_features=tuple(mapping.output_features),
                         args=mapping.binding.args,
-                        callable=call,
+                        input_features=tuple(mapping.input_features),
                         row_context=mapping.row_context,
                     )
                     nodes[node.node_id] = graphable_.graphable.Graphable(node)
                     if operation == "write":
                         self._dataset_sinks.setdefault(dataset_key, []).append(node)
-                    elif operation != "vectorize":
+                    elif operation in contracts.FRAGMENT_OPERATIONS:
                         self._dataset_sources.setdefault(dataset_key, []).append(node)
                     for feature in mapping.output_features:
                         if feature in self.spec.dimensions:
                             continue
                         self._feature_producers[feature] = node
-                        if operation == "vectorize":
-                            self._callable_index[(node.function_id, entity_id, feature)] = node
         graph = graphable_.graph.Graph(set(nodes.values()), discover=False)
         # Source transforms follow reads in their dataset.
         for fragments in self._dataset_sources.values():
@@ -129,7 +115,10 @@ class CallableGraph:
                     graph.add_edge(nodes[producer.node_id], graph_node)
 
         # Vectorize mappings consume the assembled dataset frame.
-        for callable_node in set(self._callable_index.values()):
+        calculation_nodes = [
+            node.reference for node in nodes.values() if node.reference.operation == "vectorize"
+        ]
+        for callable_node in calculation_nodes:
             consumer_node = nodes[callable_node.node_id]
             dataset_key = (callable_node.entity, callable_node.dataset_id)
             for source in self._dataset_sources.get(dataset_key, []):
@@ -137,13 +126,9 @@ class CallableGraph:
 
         for dataset_key, sinks in self._dataset_sinks.items():
             sources = self._dataset_sources.get(dataset_key, [])
-            calculations = list(
-                dict.fromkeys(
-                    node
-                    for node in self._callable_index.values()
-                    if (node.entity, node.dataset_id) == dataset_key
-                )
-            )
+            calculations = [
+                node for node in calculation_nodes if (node.entity, node.dataset_id) == dataset_key
+            ]
             for sink in sinks:
                 sink_node = nodes[sink.node_id]
                 for source in sources:
@@ -220,8 +205,6 @@ class CallableGraph:
         subset = self.__class__.__new__(self.__class__)
         subset.spec = self.spec
         subset._datasets = self._datasets
-        subset.functions = self.functions
-        subset._callable_index = self._callable_index
         subset._feature_producers = self._feature_producers
         subset._dataset_sources = self._dataset_sources
         subset._dataset_sinks = self._dataset_sinks

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/contracts.py

@@ -5,13 +5,16 @@ import typing
 FUNCTION_OPERATIONS = (
     "read",
     "write",
+    "escape",
     "vectorize",
     "collapse",
     "expand",
     "conform",
 )
-FunctionOperation = typing.Literal["read", "write", "vectorize", "collapse", "expand", "conform"]
-FunctionReturns = typing.Literal["dataframe", "none"]
+FunctionOperation = typing.Literal[
+    "read", "write", "escape", "vectorize", "collapse", "expand", "conform"
+]
+FunctionReturns = typing.Literal["dataframe", "none", "any"]
 FRAGMENT_OPERATIONS: tuple[FunctionOperation, ...] = ("read", "conform", "expand", "collapse")
 
 FEATURE_PREFIX = "$features."
@@ -22,17 +25,19 @@ ID_SELECTOR = ".id"
 DATAFRAME_SELECTOR = ".dataframe"
 STRUCTURAL_PREFIXES = (FEATURE_PREFIX, DATASET_PREFIX, DIMENSION_PREFIX)
 
-DATAFRAME_INPUT_COUNTS: dict[FunctionOperation, int] = {
+DATAFRAME_INPUT_COUNTS: dict[FunctionOperation, int | None] = {
     "read": 0,
     "collapse": 1,
     "conform": 2,
     "expand": 2,
     "vectorize": 1,
     "write": 1,
+    "escape": None,
 }
 OPERATION_RETURN_KINDS: dict[FunctionOperation, FunctionReturns] = {
     "read": "dataframe",
     "write": "none",
+    "escape": "any",
     "vectorize": "dataframe",
     "collapse": "dataframe",
     "expand": "dataframe",

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/engine/engine.py

@@ -78,13 +78,18 @@ class Engine:
                 started = time.perf_counter()
                 logger.debug("Running %s callable %s", callable.operation, callable.id)
                 try:
-                    dataframe.validate_inputs(callable)
-                    if contracts.OPERATION_RETURN_KINDS.get(callable.operation) == "dataframe":
-                        self._execute_dataframe_mapping(callable, state, bindings, dataframe)
-                    elif contracts.OPERATION_RETURN_KINDS.get(callable.operation) == "none":
-                        self._execute_sink(callable, state, bindings)
+                    if callable.operation == "escape":
+                        self._execute_escape(callable, bindings)
                     else:
-                        raise ValueError(f"Unsupported callable operation: {callable.operation}")
+                        dataframe.validate_inputs(callable)
+                        if contracts.OPERATION_RETURN_KINDS.get(callable.operation) == "dataframe":
+                            self._execute_dataframe_mapping(callable, state, bindings, dataframe)
+                        elif contracts.OPERATION_RETURN_KINDS.get(callable.operation) == "none":
+                            self._execute_sink(callable, state, bindings)
+                        else:
+                            raise ValueError(
+                                f"Unsupported callable operation: {callable.operation}"
+                            )
                 except Exception as error:
                     statuses[callable.id] = "failed"
                     failures[callable.id] = str(error)
@@ -133,6 +138,15 @@ class Engine:
                     fragment, [*dimensions, output]
                 )
 
+    def _execute_escape(
+        self,
+        callable: plan_module.Callable,
+        bindings: bindings_module.RuntimeBindings,
+    ) -> None:
+        """Invoke an uncontrolled mapping and discard its return value."""
+        kwargs = bindings.resolve_args(callable)
+        self.callable_loader.load(callable.entrypoint)(**kwargs)
+
     def _execute_sink(
         self,
         callable: plan_module.Callable,

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/explorer/graph_render.py

@@ -23,6 +23,7 @@ class GraphStyle:
     function_colors: dict[str, str] = dataclasses.field(
         default_factory=lambda: {
             "read": "#4c78a8",
+            "escape": "#a78bfa",
             "vectorize": "#f58518",
             "collapse": "#e45756",
             "conform": "#72b7b2",

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/explorer/lineage.py

@@ -18,6 +18,7 @@ class DataLineageColumn:
     role: str
     color: str
     producer: int | None
+    external: bool = False
 
 
 @dataclasses.dataclass(frozen=True)
@@ -89,8 +90,14 @@ def _build_stages(
                 for name in dimensions
             ]
             for role, features in (
-                ("Input", callable.input_features),
-                ("Output", callable.output_features),
+                (
+                    "Declared input" if callable.operation == "escape" else "Input",
+                    callable.input_features,
+                ),
+                (
+                    "Declared external output" if callable.operation == "escape" else "Output",
+                    callable.output_features,
+                ),
             ):
                 for feature in features:
                     if feature in dimensions:
@@ -107,6 +114,7 @@ def _build_stages(
                             if feature in spec_definition.dimensions
                             else "#cbd5e1",
                             numbers[producer.id] if producer else None,
+                            producer is not None and producer.operation == "escape",
                         )
                     )
             dataset = datasets.get(callable.dataset_id)

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/explorer/plan_render.py

@@ -75,11 +75,14 @@ def _render_step(
         "dataset": callable.dataset_id,
         "feature": (
             ", ".join(callable.output_features)
-            if callable.operation == "collapse"
+            if callable.operation in {"collapse", "escape"}
             else callable.output
             if callable.operation == "vectorize"
             else None
         ),
+        "input_features": callable.input_features,
+        "output_features": callable.output_features,
+        "uncontrolled": callable.operation == "escape",
         "row_context": callable.row_context.to_dict() if callable.row_context else None,
         "depends_on_callables": [
             {
@@ -155,7 +158,15 @@ def _create_website_pages(
             "function_id": callable.function_id,
             "entity": callable.entity_id,
             "dataset_id": callable.dataset_id,
-            "feature": callable.output if callable.operation == "vectorize" else None,
+            "feature": (
+                ", ".join(callable.output_features)
+                if callable.operation == "escape"
+                else callable.output
+                if callable.operation == "vectorize"
+                else None
+            ),
+            "input_features": callable.input_features,
+            "output_features": callable.output_features,
             "dependency_ids": sorted(callable.dependency_ids),
         }
         for callable in sorted(plan.callables, key=lambda callable: callable.id)

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/explorer/spec_render.py

@@ -9,9 +9,10 @@ import typing
 from importlib import util
 from urllib import parse
 
-from uptimely import contracts, project, render, spec
+from uptimely import contracts, project, render
 from uptimely import entrypoint as entrypoint_module
 from uptimely.spec import model as spec_model
+from uptimely.spec import references
 
 SPEC_PAGES = render.WEBSITE_PAGES["spec"]
 __all__ = [
@@ -117,12 +118,15 @@ def _create_website_pages(
         )
 
 
-def _feature_data(configuration: dict[str, typing.Any]) -> tuple[list[dict], list[dict], set[str]]:
+def _feature_data(
+    configuration: dict[str, typing.Any],
+) -> tuple[list[dict], list[dict], set[str], list[dict]]:
     """Collect mapped feature metadata and calculated feature references."""
     entities = configuration.get("entities", {})
     functions = configuration.get("functions", {})
     fragment_features: list[dict] = []
     calculated_features: list[dict] = []
+    escape_features: list[dict] = []
     seen_inputs: set[tuple[str, str]] = set()
     for entity in entities.values():
         for dataset in entity.get("datasets", []):
@@ -142,6 +146,10 @@ def _feature_data(configuration: dict[str, typing.Any]) -> tuple[list[dict], lis
                                 "inputs": mapping.get("features", {}).get("inputs", []),
                             }
                         )
+                    elif operation == "escape":
+                        if (dataset.get("id", ""), feature_id) not in seen_inputs:
+                            escape_features.append(feature)
+                            seen_inputs.add((dataset.get("id", ""), feature_id))
                     elif (dataset.get("id", ""), feature_id) not in seen_inputs:
                         fragment_features.append(feature)
                         seen_inputs.add((dataset.get("id", ""), feature_id))
@@ -153,7 +161,7 @@ def _feature_data(configuration: dict[str, typing.Any]) -> tuple[list[dict], lis
             for reference in calculation.get("inputs", [])
         )
     }
-    return fragment_features, calculated_features, referenced_features
+    return fragment_features, calculated_features, referenced_features, escape_features
 
 
 def _build_context(spec_definition: spec_model.Spec, include_generated_at: bool) -> ExplorerContext:
@@ -177,6 +185,23 @@ def _build_context(spec_definition: spec_model.Spec, include_generated_at: bool)
         operation = function.get("operation")
         if isinstance(operation, str):
             function_groups.setdefault(operation, {})[function_id] = function
+            function["declared_returns"] = contracts.OPERATION_RETURN_KINDS[operation]
+            function["escape_mappings"] = []
+    for entity_id, dataset, mapping in references.iter_mappings(spec_definition):
+        function = function_definitions[mapping.binding.function]
+        if function.get("operation") == "escape":
+            function["escape_mappings"].append(
+                {
+                    "entity": entity_id,
+                    "dataset": dataset.id,
+                    "mapping": mapping.id,
+                    "inputs": mapping.input_features,
+                    "outputs": mapping.output_features,
+                }
+            )
+    for function in function_definitions.values():
+        if not isinstance(function, dict):
+            continue
         entrypoint = function.get("entrypoint")
         if not isinstance(entrypoint, str) or ":" not in entrypoint:
             continue
@@ -202,7 +227,12 @@ def _build_context(spec_definition: spec_model.Spec, include_generated_at: bool)
             return_type = None
         if return_type:
             function["return_type"] = return_type
-    fragment_features, calculated_features, referenced_features = _feature_data(configuration)
+    (
+        fragment_features,
+        calculated_features,
+        referenced_features,
+        escape_features,
+    ) = _feature_data(configuration)
     feature_buckets = {
         "input": len(fragment_features),
         "intermediate": sum(
@@ -211,6 +241,7 @@ def _build_context(spec_definition: spec_model.Spec, include_generated_at: bool)
         "output": sum(
             calculation["id"] not in referenced_features for calculation in calculated_features
         ),
+        "external": len(escape_features),
     }
     function_buckets = {
         operation: len(function_groups.get(operation, {}))
@@ -232,7 +263,7 @@ def _build_context(spec_definition: spec_model.Spec, include_generated_at: bool)
         dataset_count=dataset_count,
         mapping_count=mapping_count,
         dimension_count=len(dimensions),
-        feature_count=len([*fragment_features, *calculated_features]),
+        feature_count=len([*fragment_features, *calculated_features, *escape_features]),
         bound_feature_count=len(calculated_features),
         function_count=sum(
             len(group) for group in function_groups.values() if isinstance(group, dict)
@@ -243,11 +274,14 @@ def _build_context(spec_definition: spec_model.Spec, include_generated_at: bool)
     )
     dependencies = [
         {
-            "function": call.function,
-            "feature": call.feature,
-            "dependencies": call.depends_on_features,
+            "function": mapping.binding.function,
+            "operation": spec_definition.functions[mapping.binding.function].operation,
+            "feature": feature,
+            "dependencies": mapping.input_features,
         }
-        for call in spec.prepare_spec(spec_definition).calls
+        for _entity_id, _dataset, mapping in references.iter_mappings(spec_definition)
+        if spec_definition.functions[mapping.binding.function].operation in {"escape", "vectorize"}
+        for feature in mapping.output_features
     ]
     generated_at = (
         datetime.datetime.now().astimezone().isoformat(timespec="seconds")

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/mcp/server.py

@@ -18,10 +18,11 @@ import typing
 import fastmcp
 import polars as pl
 
+from uptimely import contracts, entrypoint, spec
 from uptimely import engine as uptimely_engine
-from uptimely import entrypoint, spec
 from uptimely.project import build as project_build
 from uptimely.spec import model as spec_model
+from uptimely.spec import references
 
 logger = logging.getLogger(__name__)
 
@@ -110,24 +111,31 @@ def create_server(state: ServerState) -> fastmcp.FastMCP:
 
     @mcp.tool()
     def list_functions() -> str:
-        """List every function id and its operation."""
+        """List every function id, operation, and declared return contract."""
         catalog = state.load_snapshot().spec.functions
         return _to_json(
             [
-                {"id": function_id, "operation": function.operation}
+                {
+                    "id": function_id,
+                    "operation": function.operation,
+                    "returns": contracts.OPERATION_RETURN_KINDS[function.operation],
+                }
                 for function_id, function in sorted(catalog.root.items())
             ]
         )
 
     @mcp.tool()
     def describe_function(function_id: str) -> str:
-        """Describe one catalog function: entrypoint, declared args, Python signature.
+        """Describe a function's return contract, bindings, args, and Python signature.
+
+        Escape functions include declared feature boundaries and their uncontrolled
+        execution semantics.
 
         Args:
             function_id: The function id from `list_functions`.
         """
-        catalog = state.load_snapshot().spec.functions
-        template = catalog.get(function_id)
+        snapshot = state.load_snapshot()
+        template = snapshot.spec.functions.get(function_id)
         if template is None:
             raise ValueError(f"Unknown function: {function_id}")
         signature = entrypoint.read_signature(template.entrypoint, root=state.project_root)
@@ -135,6 +143,26 @@ def create_server(state: ServerState) -> fastmcp.FastMCP:
             {
                 "id": function_id,
                 "operation": template.operation,
+                "declared_returns": contracts.OPERATION_RETURN_KINDS[template.operation],
+                "escape_mappings": [
+                    {
+                        "entity": entity_id,
+                        "dataset": dataset.id,
+                        "mapping": mapping_id,
+                        "inputs": mapping.input_features,
+                        "outputs": mapping.output_features,
+                    }
+                    for entity_id, dataset, mapping_id, mapping in references.iter_mapping_items(
+                        snapshot.spec
+                    )
+                    if mapping.binding.function == function_id and template.operation == "escape"
+                ],
+                "execution_semantics": (
+                    "Uncontrolled external operation; its return value is ignored, and declared "
+                    "outputs are not verified or materialized as dataframe columns."
+                    if template.operation == "escape"
+                    else None
+                ),
                 "entrypoint": template.entrypoint,
                 "declared_args": {
                     name: {"type": argument.type, "comment": argument.comment}
@@ -183,23 +211,29 @@ def create_server(state: ServerState) -> fastmcp.FastMCP:
             features needed to compute it.
         """
         spec_definition = state.load_snapshot().spec
-        by_feature = {call.feature: call for call in spec.prepare_spec(spec_definition).calls}
-        call = by_feature.get(feature_id)
-        if call is None:
+        by_feature = {
+            feature: (entity_id, mapping)
+            for entity_id, _dataset, mapping in references.iter_mappings(spec_definition)
+            if spec_definition.functions[mapping.binding.function].operation == "vectorize"
+            for feature in mapping.output_features
+        }
+        producer = by_feature.get(feature_id)
+        if producer is None:
             raise ValueError(
                 f"Unknown calculated feature: {feature_id}. "
                 "Use list_calculated_features to see available features."
             )
 
+        entity_id, mapping = producer
         transitive: list[str] = []
-        queue = list(call.depends_on_features)
+        queue = list(mapping.input_features)
         seen = set(queue)
         while queue:
             current = queue.pop(0)
             transitive.append(current)
-            parent_call = by_feature.get(current)
-            if parent_call is not None:
-                for parent in parent_call.depends_on_features:
+            parent_producer = by_feature.get(current)
+            if parent_producer is not None:
+                for parent in parent_producer[1].input_features:
                     if parent not in seen:
                         seen.add(parent)
                         queue.append(parent)
@@ -207,9 +241,9 @@ def create_server(state: ServerState) -> fastmcp.FastMCP:
         return _to_json(
             {
                 "feature": feature_id,
-                "entity": call.entity,
-                "function": call.function,
-                "direct_dependencies": call.depends_on_features,
+                "entity": entity_id,
+                "function": mapping.binding.function,
+                "direct_dependencies": mapping.input_features,
                 "transitive_dependencies": transitive,
                 "input_features": [name for name in transitive if name not in by_feature],
                 "calculated_dependencies": [name for name in transitive if name in by_feature],

{uptimely_core-0.2.0.dev1 → uptimely_core-0.3.0}/src/uptimely/spec/__init__.py

@@ -2,7 +2,7 @@
 
 from uptimely.row_context import RowContext
 
-from .api import from_python, load_spec, prepare_spec
+from .api import from_python, load_spec
 from .feature_graph import FeatureGraph, SubGraph
 from .json.codec import write_document
 from .model import (
@@ -29,18 +29,15 @@ from .python import (
     ref,
     row_context,
 )
-from .resolved import Call, Function, PreparedSpec
 
 __all__ = [
     "Argument",
     "Binding",
-    "Call",
     "Dataset",
     "Dimension",
     "Entity",
     "Feature",
     "FeatureGraph",
-    "Function",
     "FunctionCatalog",
     "Mapping",
     "Order",
@@ -48,10 +45,8 @@ __all__ = [
     "RowContext",
     "RowScope",
     "Spec",
-    "PreparedSpec",
     "from_python",
     "load_spec",
-    "prepare_spec",
     "write_document",
     "SubGraph",
     "bind",