Merge pull request #71 from BAMresearch/tracing_trouble

Tracing trouble

Author: toqduj

src/modacor/dataclasses/process_step.py

@@ -25,10 +25,11 @@
 from .messagehandler import MessageHandler
 from .process_step_describer import ProcessStepDescriber
 from .processing_data import ProcessingData
-from .validators import is_list_of_ints
 
+# from .validators import is_list_of_ints
 
-@define
+
+@define(eq=False)
 class ProcessStep:
     """A base class defining a processing step"""
 
@@ -54,7 +55,7 @@ class ProcessStep:
     # class attribute for a machine-readable description of the process step
     documentation = ProcessStepDescriber(
         calling_name="Generic Process step",
-        calling_id=None,
+        calling_id="",  # to be filled in by the process
         calling_module_path=Path(__file__),
         calling_version=__version__,
     )
@@ -66,7 +67,7 @@ class ProcessStep:
     )
 
     # flags and attributes for running the pipeline
-    requires_steps: list[int] = field(factory=list, validator=is_list_of_ints)
+    requires_steps: list[str] = field(factory=list)
     step_id: int | str = field(default=-1, validator=v.instance_of((Integral, str)))
     executed: bool = field(default=False, validator=v.instance_of(bool))
 
@@ -77,7 +78,7 @@ class ProcessStep:
 
     # a message handler, supporting logging, warnings, errors, etc. emitted by the process
     # during execution
-    message_handler: MessageHandler = field(default=MessageHandler(), validator=v.instance_of(MessageHandler))
+    message_handler: MessageHandler = field(factory=MessageHandler, validator=v.instance_of(MessageHandler))
 
     # internal variables:
     __prepared: bool = field(default=False, validator=v.instance_of(bool))
@@ -88,15 +89,17 @@ def __attrs_post_init__(self):
         Post-initialization method to set up the process step.
         """
         self.configuration = self.default_config()
-        self.configuration.update(self.documentation.calling_arguments)
+        self.configuration.update(self.documentation.default_configuration)
 
     def __call__(self, processing_data: ProcessingData) -> None:
         """Allow the process step to be called like a function"""
         self.execute(processing_data)
 
     # add hash function. equality can be checked
-    def __hash__(self):
-        return hash((self.documentation.__repr__(), self.configuration.__repr__(), self.step_id))
+    # def __hash__(self):
+    #     return hash((self.documentation.__repr__(), self.configuration.__repr__(), self.step_id))
+    def __hash__(self) -> int:
+        return object.__hash__(self)
 
     def prepare_execution(self):
         """

src/modacor/dataclasses/process_step_describer.py

@@ -14,7 +14,7 @@
 from pathlib import Path
 from typing import Any
 
-from attrs import define, field
+from attrs import define, evolve, field
 from attrs import validators as v
 
 __all__ = ["ProcessStepDescriber"]
@@ -26,17 +26,9 @@
 def validate_required_keys(instance, attribute, value):
     # keys = [key.strip() for key in value.keys()]
     keys = [key.strip() for key in instance.required_arguments]
-    missing = [key for key in keys if key not in instance.calling_arguments]
+    missing = [key for key in keys if key not in instance.default_configuration]
     if missing:
-        raise ValueError(f"Missing required argument keys in calling_arguments: {missing}")
-
-
-def validate_required_data_keys(instance, attribute, value):
-    # keys = [key.strip() for key in value.keys()]
-    keys = [key.strip() for key in instance.documentation.required_data_keys]
-    missing = [key for key in keys if key not in instance.data.data]
-    if missing:
-        raise ValueError(f"Missing required data keys in instance.data: {missing}")
+        raise ValueError(f"Missing required argument keys in default_configuration: {missing}")
 
 
 @define
@@ -49,7 +41,7 @@ class ProcessStepDescriber:
     calling_version: str = field()  # module version being executed
     required_data_keys: list[str] = field(factory=list)  # list of data keys required by the process
     required_arguments: list[str] = field(factory=list)  # list of argument key-val combos required by the process
-    calling_arguments: dict[str, Any] = field(factory=dict, validator=validate_required_keys)
+    default_configuration: dict[str, Any] = field(factory=dict, validator=validate_required_keys)
     modifies: dict[str, list] = field(
         factory=dict, validator=v.instance_of(dict)
     )  # which aspects of BaseData are modified by this
@@ -68,5 +60,5 @@ class ProcessStepDescriber:
     # # on first run, and reused on subsequent runs. Maybe two chaches, one for per-file and
     # # one for per-execution.
 
-    def copy(self) -> ProcessStepDescriber:
-        raise NotImplementedError()
+    def copy(self) -> "ProcessStepDescriber":
+        return evolve(self)

src/modacor/dataclasses/trace_event.py

@@ -0,0 +1,118 @@
+# SPDX-License-Identifier: BSD-3-Clause
+# /usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+from __future__ import annotations
+
+__coding__ = "utf-8"
+__authors__ = ["Brian R. Pauw"]  # add names to the list as appropriate
+__copyright__ = "Copyright 2025, The MoDaCor team"
+__date__ = "13/12/2025"
+__status__ = "Development"  # "Development", "Production"
+__version__ = "20251213.1"
+
+__all__ = ["TraceEvent"]
+
+import json
+from hashlib import sha256
+from typing import Any
+
+from attrs import define, field, validators
+
+
+def _to_jsonable(value: Any) -> Any:
+    """
+    Convert arbitrary objects into a JSON-serializable structure.
+
+    Rules:
+    - dict keys become strings
+    - tuples/sets become lists
+    - unknown objects become str(value)
+    """
+    if value is None or isinstance(value, (str, int, float, bool)):
+        return value
+
+    if isinstance(value, dict):
+        return {str(k): _to_jsonable(v) for k, v in value.items()}
+
+    if isinstance(value, (list, tuple, set)):
+        return [_to_jsonable(v) for v in value]
+
+    # Common numpy-like scalars without importing numpy
+    if hasattr(value, "item") and callable(getattr(value, "item")):
+        try:
+            return _to_jsonable(value.item())
+        except Exception:
+            pass
+
+    return str(value)
+
+
+def _stable_hash_dict(d: dict[str, Any]) -> str:
+    """
+    Stable content hash of a dict (order-independent).
+    """
+    canonical = json.dumps(_to_jsonable(d), sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    return sha256(canonical.encode("utf-8")).hexdigest()
+
+
+@define(frozen=True, slots=True)
+class TraceEvent:
+    """
+    A small, UI-friendly trace record for a single executed step.
+
+    Intended to be embedded into Pipeline.to_spec() so graph viewers can show:
+      - configuration used by the step
+      - what changed (units/dimensionality/shape/NaNs/etc.)
+      - optional human messages (later)
+
+    Notes
+    -----
+    Keep this JSON-friendly and lightweight: no arrays, no heavy objects.
+    """
+
+    step_id: str
+    module: str
+    label: str = ""
+
+    module_path: str = ""
+    version: str = ""
+
+    requires_steps: tuple[str, ...] = field(factory=tuple)
+
+    # configuration as used for execution (JSON-friendly)
+    config: dict[str, Any] = field(factory=dict)
+
+    # computed stable hash of config
+    config_hash: str = field(init=False)
+
+    # dataset key -> { "diff": [...], "prev": {...} | None, "now": {...} }
+    # Use a simple key like "sample.signal" or "sample_background.signal"
+    datasets: dict[str, Any] = field(factory=dict)
+
+    # reserved for later (MessageHandler, timing, etc.)
+    messages: list[dict[str, Any]] = field(factory=list)
+
+    # wall-clock runtime for this step execution (seconds)
+    duration_s: float | None = field(default=None, validator=validators.optional(validators.instance_of(float)))
+
+    def __attrs_post_init__(self) -> None:
+        object.__setattr__(self, "config_hash", _stable_hash_dict(self.config))
+
+    def to_dict(self) -> dict[str, Any]:
+        """
+        JSON-serializable representation suitable for Pipeline.to_spec().
+        """
+        return {
+            "step_id": self.step_id,
+            "module": self.module,
+            "label": self.label,
+            "module_path": self.module_path,
+            "version": self.version,
+            "requires_steps": list(self.requires_steps),
+            "config": _to_jsonable(self.config),
+            "config_hash": self.config_hash,
+            "duration_s": self.duration_s,
+            "datasets": _to_jsonable(self.datasets),
+            "messages": _to_jsonable(self.messages),
+        }