mainsequence 4.1.1__tar.gz → 4.1.2__tar.gz

{mainsequence-4.1.1 → mainsequence-4.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.1.1
+Version: 4.1.2
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.1.1 → mainsequence-4.1.2}/agent_scaffold/skills/data_publishing/data_nodes/SKILL.md

@@ -161,6 +161,16 @@ The DataNode constructor should accept:
 - a registered `storage_table: type[PlatformTimeIndexMetaData]`
 - optional `hash_namespace`
 
+The constructor `storage_table` is the output storage contract. Keep it out of
+`DataNodeConfiguration`.
+
+If the DataNode needs to select another DataNode's storage table as a
+dependency, put that dependency storage reference in the config as
+`type[PlatformTimeIndexMetaData]`. Do not add an extra constructor argument for
+dependency storage tables. Config values of this type are hashed by the bound
+`TimeIndexMetaData.uid` from `StorageClass.__time_index_metadata__`, so the class
+must be registered or bound before DataNode construction.
+
 Do not accept `test_node`. It has been removed. Use explicit
 `hash_namespace(...)` or `hash_namespace="..."`.
 
@@ -287,6 +297,9 @@ Time index must be datetime64[ns, UTC]
 
 Dependencies belong in constructor setup and `dependencies()`.
 
+Dependency storage-table selection belongs in `DataNodeConfiguration`, because
+changing it changes the dependency graph and update identity.
+
 Do not construct dependency graphs dynamically inside `update()`.
 
 ### 8. Asset-Scoped Updates Must Be Explicit
@@ -318,7 +331,8 @@ surface for new DataNode work.
 
 When reviewing an existing DataNode, look for:
 
-- storage contract hidden in `DataNodeConfiguration`
+- output storage contract hidden in `DataNodeConfiguration`
+- dependency storage table passed as an ad hoc constructor argument
 - old `RecordDefinition` or `DataNodeMetaData` schema patterns
 - `update_only`, `runtime_only`, or `ignore_from_storage_hash`
 - `test_node=True`
@@ -339,6 +353,7 @@ Do not claim success until you have checked:
 - the relevant docs were read first
 - storage is a registered or bound `PlatformTimeIndexMetaData` class
 - the DataNode constructor requires `storage_table`
+- dependency storage-table references live in config and are registered or bound
 - config fields are updater-scoped by default
 - no removed hash metadata markers remain
 - no `test_node` usage remains

{mainsequence-4.1.1 → mainsequence-4.1.2}/mainsequence/meta_tables/data_nodes/build_operations.py

@@ -19,16 +19,12 @@ from pydantic import BaseModel
 from mainsequence.client import BaseObjectOrm
 from mainsequence.client.models_helpers import get_model_class
 from mainsequence.client.models_metatables import _resolve_local_pod_project
-from mainsequence.instrumentation import tracer, tracer_instrumentator
 from mainsequence.meta_tables.pydantic_metadata import (
     is_serialized_pydantic_model,
     serialize_pydantic_model,
     strip_pydantic_hash_exclusions,
 )
 
-from .namespacing import disable_hash_namespace
-from .persist_managers import PersistManager
-
 if TYPE_CHECKING:
     from .data_nodes import APIDataNode, DataNode
 
@@ -70,6 +66,46 @@ def _serialize_api_timeserie(value: APIDataNode) -> dict[str, Any]:
     }
 
 
+def _import_qualified_name(module_name: str, qualname: str) -> Any:
+    module = importlib.import_module(module_name)
+    value: Any = module
+    for part in qualname.split("."):
+        value = getattr(value, part)
+    return value
+
+
+def _is_platform_time_index_metadata_class(value: Any) -> bool:
+    try:
+        from mainsequence.meta_tables.sqlalchemy_contracts import PlatformTimeIndexMetaData
+    except ImportError:
+        return False
+
+    try:
+        return isinstance(value, type) and issubclass(value, PlatformTimeIndexMetaData)
+    except TypeError:
+        return False
+
+
+@serialize_argument.register(type)
+def _(value: type[Any]) -> Any:
+    if not _is_platform_time_index_metadata_class(value):
+        return value
+
+    time_index_metadata = value.get_time_index_metadata()
+    uid = getattr(time_index_metadata, "uid", None)
+    if uid in (None, ""):
+        raise ValueError(
+            "PlatformTimeIndexMetaData config values must be registered or bound "
+            "before they can be hashed."
+        )
+    return {
+        "__type__": "platform_time_index_metadata",
+        "uid": str(uid),
+        "module": value.__module__,
+        "qualname": value.__qualname__,
+    }
+
+
 @serialize_argument.register(datetime.datetime)
 def _(value: datetime.datetime) -> str:
     return value.isoformat()
@@ -180,6 +216,8 @@ def parse_dictionary_before_hashing(dictionary: dict[str, Any]) -> dict[str, Any
                 # The value["items"] are already serialized dicts
 
                 local_ts_dict_to_hash[key] = [v["unique_identifier"] for v in value["items"]]
+            elif value.get("__type__") == "platform_time_index_metadata":
+                local_ts_dict_to_hash[key] = value["uid"]
             else:
                 # recursively apply hash signature
                 local_ts_dict_to_hash[key] = parse_dictionary_before_hashing(value)
@@ -327,6 +365,8 @@ class ConfigRebuilder(BaseRebuilder):
         return build_model(value)
 
     def _handle_complex_type(self, value: dict, **kwargs) -> Any:
+        if value.get("__type__") == "platform_time_index_metadata":
+            return _import_qualified_name(value["module"], value["qualname"])
         # Special case for ORM lists within the generic complex type handler
         if value.get("__type__") == "orm_model_list":
             return [build_model(item) for item in value["items"]]
@@ -434,97 +474,3 @@ def create_config(
         remote_initial_configuration=remote_config,
         build_configuration_json_schema=build_configuration_json_schema,
     )
-
-
-def rebuild_and_set_from_update_hash(
-    update_hash: str,
-    data_source_uid: str,
-    set_dependencies_df: bool = False,
-    graph_depth_limit: int = 1,
-) -> DataNode:
-    """
-    Rebuilds a DataNode from stored configuration and attaches runtime sessions.
-
-    Args:
-        update_hash: The local hash ID of the DataNode.
-        data_source_uid: The data source UID.
-        set_dependencies_df: Whether to set the dependencies DataFrame.
-        graph_depth_limit: The depth limit for graph traversal.
-
-    Returns:
-        The rebuilt DataNode object.
-    """
-    ts = rebuild_from_configuration(
-        update_hash=update_hash,
-        data_source=data_source_uid,
-    )
-    if set_dependencies_df:
-        ts.set_relation_tree()
-    ts._set_state_with_sessions(
-        graph_depth=0,
-        graph_depth_limit=graph_depth_limit,
-        include_client_objects=False,
-    )
-    ts.logger.debug(f"ts {update_hash} rebuilt from configuration")
-    return ts
-
-
-@tracer.start_as_current_span("TS: Rebuild From Configuration")
-def rebuild_from_configuration(update_hash: str, data_source: str | object) -> DataNode:
-    """
-    Rebuilds a DataNode instance from its configuration.
-
-    Args:
-        update_hash: The local hash ID of the DataNode.
-        data_source: The data source UID or object.
-
-    Returns:
-        The rebuilt DataNode instance.
-    """
-    import importlib
-
-    tracer_instrumentator.append_attribute_to_current_span("update_hash", update_hash)
-
-    data_source_uid = getattr(data_source, "uid", data_source)
-    data_node_update = PersistManager.UPDATE_CLASS.get_or_none(
-        update_hash=update_hash,
-        remote_table__data_source__uid=str(data_source_uid),
-        include_relations_detail=True,
-    )
-    if data_node_update is None:
-        raise ValueError(
-            f"DataNodeUpdate {update_hash!r} with data source {data_source_uid!r} was not found."
-        )
-    storage_table = data_node_update.data_node_storage
-    persist_manager = PersistManager.get_from_storage_table(
-        update_hash=update_hash,
-        storage_table=storage_table,
-        data_node_update=data_node_update,
-    )
-    try:
-        time_serie_config = persist_manager.local_build_configuration
-    except Exception as e:
-        raise e
-
-    try:
-        mod = importlib.import_module(time_serie_config["time_series_class_import_path"]["module"])
-        TimeSerieClass = getattr(
-            mod, time_serie_config["time_series_class_import_path"]["qualname"]
-        )
-    except Exception as e:
-        raise e
-
-    time_serie_class_name = time_serie_config["time_series_class_import_path"]["qualname"]
-
-    time_serie_config.pop("time_series_class_import_path")
-    time_serie_config = DeserializerManager().rebuild_serialized_config(
-        time_serie_config, time_serie_class_name=time_serie_class_name
-    )
-
-    # IMPORTANT:
-    # When rebuilding from stored config, ignore any ambient test namespace.
-    # If the stored config includes 'hash_namespace' (test tables), it will still be passed explicitly.
-    with disable_hash_namespace():
-        re_build_ts = TimeSerieClass(**time_serie_config)
-
-    return re_build_ts

{mainsequence-4.1.1 → mainsequence-4.1.2}/mainsequence/meta_tables/data_nodes/run_operations.py

@@ -31,9 +31,6 @@ from mainsequence.client.dtype_codec import (
 # Instrumentation and Logging
 from mainsequence.instrumentation import TracerInstrumentator, tracer
 
-# MetaTable DataNode core components and helpers
-from mainsequence.meta_tables.data_nodes import build_operations
-
 if TYPE_CHECKING:
     from .data_nodes import DataNode
 
@@ -377,7 +374,6 @@ class UpdateRunner:
 
     def _start_update(
         self,
-        reuse_declared_dependency_instances: bool,
         override_update_stats: BaseUpdateStatistics | None = None,
     ) -> tuple[bool, LocalUpdateResult]:
         """Orchestrates a single DataNode update, including pre/post routines."""
@@ -404,7 +400,6 @@ class UpdateRunner:
                 self.logger.debug(f"Update required for {self.ts}.")
                 update_result = self._update_local(
                     historical_update=historical_update,
-                    reuse_declared_dependency_instances=reuse_declared_dependency_instances,
                 )
             else:
                 self.logger.debug(f"Already up-to-date. Skipping update for {self.ts}.")
@@ -509,7 +504,6 @@ class UpdateRunner:
     def _update_local(
         self,
         historical_update: Any,
-        reuse_declared_dependency_instances: bool,
     ) -> LocalUpdateResult:
         """
         Calculates, validates, and persists the node update result.
@@ -519,14 +513,11 @@ class UpdateRunner:
                 ``set_start_of_execution()`` for this run. The node-specific
                 ``_execute_local_update(...)`` implementation is responsible for
                 interpreting any fields on this object.
-            reuse_declared_dependency_instances: When True in debug mode, dependency
-                updates reuse already-instantiated dependency nodes from the current
-                in-memory dependency graph instead of rebuilding them from backend
-                metadata.
+            Dependencies are executed from the source-declared in-memory graph.
         """
         # 1. Handle dependency tree update first
         if self.update_tree:
-            self._verify_tree_is_updated(reuse_declared_dependency_instances)
+            self._verify_tree_is_updated()
             if self.update_only_tree:
                 self.logger.info(
                     f"Dependency tree for {self.ts} updated. Halting run as requested."
@@ -552,10 +543,7 @@ class UpdateRunner:
                 self.ts.update_statistics = us
 
     @tracer.start_as_current_span("UpdateRunner._verify_tree_is_updated")
-    def _verify_tree_is_updated(
-        self,
-        reuse_declared_dependency_instances: bool,
-    ) -> None:
+    def _verify_tree_is_updated(self) -> None:
         """
         Ensures all dependencies in the tree are updated before the head node.
 
@@ -563,10 +551,9 @@ class UpdateRunner:
         then delegates the update execution to either a sequential (debug) or
         parallel (production) helper method.
 
-        Args:
-            reuse_declared_dependency_instances: If True in debug mode, reuse the
-                already-declared in-memory dependency instances instead of rebuilding
-                them from backend metadata.
+        Dependencies are executed from the currently declared DataNode graph.
+        Backend dependency metadata is ordering/state only; it is not used to
+        cold-rebuild executable DataNode instances.
         """
         # 1. Ensure the dependency graph is built in the backend
         declared_dependencies = self.ts.dependencies() or {}
@@ -611,10 +598,8 @@ class UpdateRunner:
             self.logger.debug("No dependencies to update.")
             return
 
-        # 3. Build a map of dependency instances if needed for debug mode
-        update_map = {}
-        if self.debug_mode and reuse_declared_dependency_instances:
-            update_map = self._get_update_map(declared_dependencies, logger=self.logger)
+        # 3. Build the executable dependency map from source declarations.
+        update_map = self._get_update_map(declared_dependencies, logger=self.logger)
 
         # 4. Delegate to the appropriate execution method
         self.logger.debug(f"Starting update for {len(dependencies_df)} dependencies...")
@@ -638,7 +623,7 @@ class UpdateRunner:
         declared_dependencies: dict[str, DataNode],
         logger: object,
         dependecy_map: dict | None = None,
-    ) -> dict[tuple[str, int], dict[str, Any]]:
+    ) -> dict[str, dict[str, Any]]:
         """
         Obtains all DataNode objects in the dependency graph by recursively
         calling the dependencies() method.
@@ -651,7 +636,7 @@ class UpdateRunner:
             dependecy_map: An optional dictionary to store the dependency map, used for recursion.
 
         Returns:
-            A dictionary mapping (update_hash, data_source_uid) to DataNode info.
+            A dictionary mapping update node uid to DataNode info.
         """
         # Initialize the map on the first call
         if dependecy_map is None:
@@ -660,16 +645,16 @@ class UpdateRunner:
         # Get the explicitly declared dependencies, just like set_relation_tree
 
         for name, dependency_ts in declared_dependencies.items():
-            key = (dependency_ts.update_hash, dependency_ts.data_source_uid)
-
-            # If we have already processed this node, skip it to prevent infinite loops
-            if key in dependecy_map:
-                continue
             if dependency_ts.is_api:
                 continue
 
-            # Ensure the dependency is initialized in the persistence layer
+            # Ensure the dependency is initialized in the persistence layer.
             _ = dependency_ts.local_persist_manager
+            key = _require_uid(dependency_ts.data_node_update, "DataNodeUpdate")
+
+            # If we have already processed this node, skip it to prevent infinite loops
+            if key in dependecy_map:
+                continue
 
             logger.debug(f"Adding dependency '{name}' to update map.")
             dependecy_map[key] = {"ts": dependency_ts}
@@ -686,7 +671,7 @@ class UpdateRunner:
     def _execute_sequential_debug_update(
         self,
         dependencies_df: pd.DataFrame,
-        update_map: dict[tuple[str, str], dict],
+        update_map: dict[str, dict],
     ) -> None:
         """Runs dependency updates sequentially in the same process for debugging."""
         self.logger.info("Executing dependency updates in sequential debug mode.")
@@ -707,40 +692,34 @@ class UpdateRunner:
             sorted_deps = priority_df.sort_values("number_of_upstreams", ascending=False)
 
             for _, ts_row in sorted_deps.iterrows():
-                key = (ts_row["update_hash"], ts_row["data_source_uid"])
-                ts_to_update = None
+                update_node_uid = str(ts_row["update_node_uid"])
                 try:
-                    if key in update_map:
-                        ts_to_update = update_map[key]["ts"]
-
-                        # update the update_statistics of the dependencies
-                        refresh_update_statistics_of_deps(ts_to_update)
-
-                    else:
-                        # If not in the map, it must be rebuilt from storage
-                        ts_to_update = build_operations.rebuild_and_set_from_update_hash(
-                            update_hash=key[0], data_source_uid=key[1]
+                    if update_node_uid not in update_map:
+                        raise DependencyUpdateError(
+                            "Backend dependency metadata includes an update node that "
+                            "is not declared by the current DataNode.dependencies() graph: "
+                            f"update_node_uid={update_node_uid!r}."
                         )
 
-                    if ts_to_update:
-                        self.logger.debug(
-                            f"Running debug update for dependency: {ts_to_update.update_hash}"
-                        )
-                        # Each dependency gets its own clean runner
-                        dep_runner = UpdateRunner(
-                            time_serie=ts_to_update,
-                            debug_mode=True,
-                            update_tree=False,  # We only update one node at a time
-                            force_update=self.force_update,
-                            remote_scheduler=self.scheduler,
-                        )
-                        dep_runner._setup_scheduler()
-
-                        dep_runner._start_update(
-                            reuse_declared_dependency_instances=False,
-                        )
+                    ts_to_update = update_map[update_node_uid]["ts"]
+                    refresh_update_statistics_of_deps(ts_to_update)
+
+                    self.logger.debug(
+                        f"Running debug update for dependency: {ts_to_update.update_hash}"
+                    )
+                    # Each dependency gets its own clean runner.
+                    dep_runner = UpdateRunner(
+                        time_serie=ts_to_update,
+                        debug_mode=True,
+                        update_tree=False,
+                        force_update=self.force_update,
+                        remote_scheduler=self.scheduler,
+                    )
+                    dep_runner._setup_scheduler()
+
+                    dep_runner._start_update()
                 except Exception as e:
-                    self.logger.exception(f"Failed to update dependency {key[0]}")
+                    self.logger.exception(f"Failed to update dependency {update_node_uid}")
                     raise e  # Re-raise to halt the entire process on failure
 
         # refresh update statistics of direct dependencies
@@ -803,7 +782,6 @@ class UpdateRunner:
 
                 # 5. Trigger the core update process
                 error_on_last_update, update_result = self._start_update(
-                    reuse_declared_dependency_instances=True,
                     override_update_stats=self.override_update_stats,
                 )
 

{mainsequence-4.1.1 → mainsequence-4.1.2}/mainsequence/meta_tables/sqlalchemy_contracts.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping, Sequence
-from typing import Any, ClassVar
+from typing import TYPE_CHECKING, Any, ClassVar
 from uuid import UUID
 
 from mainsequence.client.dtype_codec import (
@@ -21,6 +21,9 @@ from mainsequence.client.models_metatables import (
 
 from .hashing import build_meta_table_configured_storage_hash, build_meta_table_storage_hash
 
+if TYPE_CHECKING:
+    from mainsequence.client.models_metatables import TimeIndexMetaData
+
 DEFAULT_PLATFORM_MANAGED_PROVISIONING = {
     "create_table": True,
     "if_not_exists": True,
@@ -351,19 +354,19 @@ class PlatformTimeIndexMetaData(PlatformManagedMetaTable):
     ordinary non-null table columns.
     """
 
-    __time_index_metadata__: ClassVar[Any | None] = None
+    __time_index_metadata__: ClassVar[TimeIndexMetaData | None] = None
 
     if _sqlalchemy_declared_attr is not None:
         __mapper_args__ = _sqlalchemy_declared_attr.directive(_time_index_mapper_args)
 
     @classmethod
-    def bind_meta_table(cls, meta_table: Any) -> Any:
+    def bind_meta_table(cls, meta_table: TimeIndexMetaData) -> TimeIndexMetaData:
         bound = super().bind_meta_table(meta_table)
         cls.__time_index_metadata__ = bound
         return bound
 
     @classmethod
-    def get_time_index_metadata(cls) -> Any | None:
+    def get_time_index_metadata(cls) -> TimeIndexMetaData | None:
         return getattr(cls, "__time_index_metadata__", None)
 
     @classmethod

{mainsequence-4.1.1 → mainsequence-4.1.2}/mainsequence.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 4.1.1
+Version: 4.1.2
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License: MainSequence GmbH SDK License Agreement

{mainsequence-4.1.1 → mainsequence-4.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mainsequence"
-version = "4.1.1"
+version = "4.1.2"
 description = "Main Sequence SDK "
 readme = "README.md"
 requires-python = ">=3.11"

{mainsequence-4.1.1 → mainsequence-4.1.2}/tests/test_build_operations_hashing.py

@@ -10,8 +10,11 @@ os.environ.setdefault("MAINSEQUENCE_ACCESS_TOKEN", "test-access-token")
 os.environ.setdefault("MAINSEQUENCE_REFRESH_TOKEN", "test-refresh-token")
 
 import mainsequence.meta_tables.data_nodes.build_operations as build_operations
+from mainsequence.client.models_metatables import TimeIndexMetaData
 from mainsequence.meta_tables import (
+    DataNode,
     DataNodeConfiguration,
+    PlatformTimeIndexMetaData,
     RecordDefinition,
 )
 
@@ -170,6 +173,44 @@ def test_offset_start_changes_update_hash(monkeypatch):
     assert storage_hash_a != storage_hash_b
 
 
+def test_platform_time_index_metadata_config_hashes_by_bound_metadata_uid(monkeypatch):
+    monkeypatch.setattr(build_operations, "POD_PROJECT", None, raising=False)
+
+    class StorageA(PlatformTimeIndexMetaData):
+        pass
+
+    class StorageB(PlatformTimeIndexMetaData):
+        pass
+
+    class StorageC(PlatformTimeIndexMetaData):
+        pass
+
+    StorageA.bind_meta_table(TimeIndexMetaData.model_construct(uid="storage-uid-a"))
+    StorageB.bind_meta_table(TimeIndexMetaData.model_construct(uid="storage-uid-a"))
+    StorageC.bind_meta_table(TimeIndexMetaData.model_construct(uid="storage-uid-c"))
+
+    class NodeConfig(BaseModel):
+        dependency_storage: type[PlatformTimeIndexMetaData]
+
+    hashes_a = _hashes(NodeConfig(dependency_storage=StorageA))
+    hashes_b = _hashes(NodeConfig(dependency_storage=StorageB))
+    hashes_c = _hashes(NodeConfig(dependency_storage=StorageC))
+
+    assert hashes_a == hashes_b
+    assert hashes_a != hashes_c
+
+    config = build_operations.create_config(
+        ts_class_name="StorageConfigNode",
+        kwargs={"config": NodeConfig(dependency_storage=StorageA)},
+    )
+    assert (
+        config.local_initial_configuration["config"]["serialized_model"]["dependency_storage"][
+            "uid"
+        ]
+        == "storage-uid-a"
+    )
+
+
 def test_plain_dict_with_pydantic_model_import_path_key_is_not_treated_as_wrapper(monkeypatch):
     monkeypatch.setattr(build_operations, "POD_PROJECT", None, raising=False)
 

{mainsequence-4.1.1 → mainsequence-4.1.2}/tests/test_pod_project_resolution.py

@@ -486,58 +486,6 @@ def test_build_operations_api_node_reference_serialization_uses_data_source_uid(
     assert "is_api_time_serie_pickled" not in payload
 
 
-def test_build_operations_rebuilds_from_configuration_without_pickle(monkeypatch):
-    calls = []
-
-    class FakeLogger:
-        def debug(self, message):
-            calls.append(("debug", message))
-
-    class FakeDataNode:
-        logger = FakeLogger()
-
-        def set_relation_tree(self):
-            calls.append(("set_relation_tree",))
-
-        def _set_state_with_sessions(
-            self,
-            *,
-            graph_depth,
-            graph_depth_limit,
-            include_client_objects,
-        ):
-            calls.append(
-                (
-                    "set_state_with_sessions",
-                    graph_depth,
-                    graph_depth_limit,
-                    include_client_objects,
-                )
-            )
-
-    fake_ts = FakeDataNode()
-
-    def fake_rebuild_from_configuration(update_hash, data_source):
-        calls.append(("rebuild_from_configuration", update_hash, data_source))
-        return fake_ts
-
-    monkeypatch.setattr(
-        build_operations,
-        "rebuild_from_configuration",
-        fake_rebuild_from_configuration,
-    )
-
-    result = build_operations.rebuild_and_set_from_update_hash(
-        update_hash="update-hash-1",
-        data_source_uid=DATA_SOURCE_UID,
-        set_dependencies_df=True,
-        graph_depth_limit=3,
-    )
-
-    assert result is fake_ts
-    assert calls == [
-        ("rebuild_from_configuration", "update-hash-1", DATA_SOURCE_UID),
-        ("set_relation_tree",),
-        ("set_state_with_sessions", 0, 3, False),
-        ("debug", "ts update-hash-1 rebuilt from configuration"),
-    ]
+def test_build_operations_does_not_expose_data_node_cold_rebuild_helpers():
+    assert not hasattr(build_operations, "rebuild_from_configuration")
+    assert not hasattr(build_operations, "rebuild_and_set_from_update_hash")

{mainsequence-4.1.1 → mainsequence-4.1.2}/tests/test_update_runner_uid_runtime.py

@@ -16,6 +16,9 @@ class _Logger:
     def info(self, *_args, **_kwargs):
         return None
 
+    def exception(self, *_args, **_kwargs):
+        return None
+
 
 class _PersistManager:
     def __init__(self, data_node_update):
@@ -30,6 +33,9 @@ class _PersistManager:
     def set_data_node_update_lazy(self, include_relations_detail=False):
         self.include_relations_detail = include_relations_detail
 
+    def get_update_statistics_for_table(self):
+        return {"updated": self.data_node_update.uid}
+
 
 class _Scheduler:
     uid = "scheduler-uid"
@@ -172,9 +178,13 @@ def test_update_runner_verify_tree_uses_dependency_uids(monkeypatch):
         depth_df=depth_df,
         dependencies_df=depth_df.copy(),
     )
-    ts.dependencies = lambda: {
-        "dependency": SimpleNamespace(is_api=False, data_node_update=dependency_update)
-    }
+    dependency = SimpleNamespace(
+        is_api=False,
+        data_node_update=dependency_update,
+        local_persist_manager=_PersistManager(dependency_update),
+        dependencies=lambda: {},
+    )
+    ts.dependencies = lambda: {"dependency": dependency}
     runner = run_operations.UpdateRunner(ts, debug_mode=True)
     executed = {}
     monkeypatch.setattr(
@@ -188,10 +198,81 @@ def test_update_runner_verify_tree_uses_dependency_uids(monkeypatch):
         ),
     )
 
-    runner._verify_tree_is_updated(reuse_declared_dependency_instances=False)
+    runner._verify_tree_is_updated()
 
     assert patch_calls == []
     assert executed["update_node_uids"] == ["dep-uid"]
+    assert list(executed["update_map"]) == ["dep-uid"]
+
+
+def test_sequential_debug_update_uses_update_node_uid_without_data_source_uid(monkeypatch):
+    dependency_update = _update("dep-uid")
+    dependency = SimpleNamespace(
+        is_api=False,
+        data_node_update=dependency_update,
+        update_hash="dep-hash",
+        local_persist_manager=_PersistManager(dependency_update),
+        dependencies=lambda: {},
+        logger=_Logger(),
+    )
+    dependencies_df = pd.DataFrame(
+        [
+            {
+                "update_node_uid": "dep-uid",
+                "update_hash": "dep-hash",
+                "update_priority": 0,
+                "number_of_upstreams": 0,
+            }
+        ]
+    )
+    ts = _time_series()
+    ts.dependencies = lambda: {"dependency": dependency}
+    runner = run_operations.UpdateRunner(ts, debug_mode=True)
+    runner.scheduler = _Scheduler()
+    started = []
+
+    monkeypatch.setattr(
+        run_operations.UpdateRunner,
+        "_setup_scheduler",
+        lambda self: started.append(("scheduler", self.ts.data_node_update.uid)),
+    )
+    monkeypatch.setattr(
+        run_operations.UpdateRunner,
+        "_start_update",
+        lambda self, **_kwargs: started.append(("update", self.ts.data_node_update.uid)),
+    )
+
+    runner._execute_sequential_debug_update(
+        dependencies_df=dependencies_df,
+        update_map={"dep-uid": {"ts": dependency}},
+    )
+
+    assert started == [("scheduler", "dep-uid"), ("update", "dep-uid")]
+
+
+def test_sequential_debug_update_rejects_backend_dependency_not_declared():
+    dependencies_df = pd.DataFrame(
+        [
+            {
+                "update_node_uid": "stale-dep-uid",
+                "update_hash": "stale-dep-hash",
+                "update_priority": 0,
+                "number_of_upstreams": 0,
+            }
+        ]
+    )
+    runner = run_operations.UpdateRunner(_time_series(), debug_mode=True)
+
+    try:
+        runner._execute_sequential_debug_update(
+            dependencies_df=dependencies_df,
+            update_map={},
+        )
+    except run_operations.DependencyUpdateError as exc:
+        assert "not declared by the current DataNode.dependencies() graph" in str(exc)
+        assert "stale-dep-uid" in str(exc)
+    else:
+        raise AssertionError("Expected DependencyUpdateError")
 
 
 def test_data_node_update_dependency_priority_normalizes_uid_columns(monkeypatch):