grdl-runtime 0.1.2__tar.gz → 0.2.0__tar.gz

{grdl_runtime-0.1.2/grdl_runtime.egg-info → grdl_runtime-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: grdl-runtime
-Version: 0.1.2
+Version: 0.2.0
 Summary: GEOINT Rapid Development Library Runtime — headless execution engine for GRDL workflow orchestration
 Author: Claude Code (Anthropic)
 Maintainer: Steven Siebert
@@ -19,7 +19,7 @@ Classifier: Topic :: Scientific/Engineering :: GIS
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: grdl>=0.5.1
+Requires-Dist: grdl>=0.8.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: requests>=2.25
 Requires-Dist: packaging>=21.0
@@ -118,6 +118,27 @@ wf = (
 result = wf.execute(my_array)
 ```
 
+### Memory timeline profiling
+
+Memory time-series collection is **disabled by default** for all execution
+paths, including the NISAR example. No sampler thread or tracemalloc session
+is started, and JSON metrics omit `memory_timeline` (including its large
+`timestamps` and `values` arrays). Sampled memory peaks are reported as zero
+when profiling is disabled; run start/end times and elapsed durations are
+still recorded.
+
+To opt in, set `GRDL_RT_MEMORY_TIMELINE_ENABLED=true` before launching Python,
+or add this to `~/.grdl/runtime.toml`:
+
+```toml
+[memory]
+timeline_enabled = true
+```
+
+When enabled, the timeline is sampled every millisecond and included in JSON
+metrics. Memory estimation and safety thresholds are independent of profiling
+and remain active.
+
 ### Batch Execution
 
 ```python

{grdl_runtime-0.1.2 → grdl_runtime-0.2.0}/README.md

@@ -64,6 +64,27 @@ wf = (
 result = wf.execute(my_array)
 ```
 
+### Memory timeline profiling
+
+Memory time-series collection is **disabled by default** for all execution
+paths, including the NISAR example. No sampler thread or tracemalloc session
+is started, and JSON metrics omit `memory_timeline` (including its large
+`timestamps` and `values` arrays). Sampled memory peaks are reported as zero
+when profiling is disabled; run start/end times and elapsed durations are
+still recorded.
+
+To opt in, set `GRDL_RT_MEMORY_TIMELINE_ENABLED=true` before launching Python,
+or add this to `~/.grdl/runtime.toml`:
+
+```toml
+[memory]
+timeline_enabled = true
+```
+
+When enabled, the timeline is sampled every millisecond and included in JSON
+metrics. Memory estimation and safety thresholds are independent of profiling
+and remain active.
+
 ### Batch Execution
 
 ```python

{grdl_runtime-0.1.2 → grdl_runtime-0.2.0}/grdl_rt/execution/band_adaptation.py

@@ -54,13 +54,19 @@ logger = get_logger(__name__)
 # ------------------------------------------------------------------
 
 
-def detect_band_axis(source: np.ndarray) -> int | None:
+def detect_band_axis(
+    source: np.ndarray,
+    axis_order: str | None = None,
+) -> int | None:
     """Auto-detect the band axis of an image array.
 
     Parameters
     ----------
     source : np.ndarray
         2-D or 3-D image array.
+    axis_order : str, optional
+        Metadata ``axis_order`` (``'CYX'`` or ``'YXC'``).  When given for
+        a 3-D array it is used instead of the shape heuristic.
 
     Returns
     -------
@@ -69,34 +75,43 @@ def detect_band_axis(source: np.ndarray) -> int | None:
 
     Notes
     -----
-    Heuristic for 3-D arrays:
+    Heuristic for 3-D arrays without ``axis_order``:
 
     - ``shape[0] <= shape[2]`` → CHW (bands-first, e.g. ``(3, 512, 512)``)
     - ``shape[2] < shape[0]`` → HWC (bands-last, e.g. ``(512, 512, 3)``)
+
+    The heuristic misreads small tiles (e.g. ``(4, 3, 3)``), so pass
+    ``axis_order`` whenever metadata is available.
     """
     if source.ndim == 2:
         return None
     if source.ndim != 3:
         return None
+    if axis_order == "CYX":
+        return 0
+    if axis_order == "YXC":
+        return 2
     if source.shape[0] <= source.shape[2]:
         return 0  # CHW
     return 2  # HWC
 
 
-def get_band_count(source: np.ndarray) -> int:
+def get_band_count(source: np.ndarray, axis_order: str | None = None) -> int:
     """Return the number of spectral bands in an image array.
 
     Parameters
     ----------
     source : np.ndarray
         2-D or 3-D image array.
+    axis_order : str, optional
+        Metadata ``axis_order``; see :func:`detect_band_axis`.
 
     Returns
     -------
     int
         Number of bands (1 for 2-D arrays).
     """
-    axis = detect_band_axis(source)
+    axis = detect_band_axis(source, axis_order)
     if axis is None:
         return 1
     return source.shape[axis]
@@ -112,6 +127,7 @@ def adapt_bands(
     required_bands: int,
     expansion: BandExpansion = BandExpansion.REPEAT,
     reduction: BandReduction = BandReduction.FIRST_N,
+    axis_order: str | None = None,
 ) -> np.ndarray:
     """Adapt *source* to have exactly *required_bands* bands.
 
@@ -127,6 +143,8 @@ def adapt_bands(
         Strategy when the source has fewer bands than required.
     reduction : BandReduction
         Strategy when the source has more bands than required.
+    axis_order : str, optional
+        Metadata ``axis_order``; see :func:`detect_band_axis`.
 
     Returns
     -------
@@ -138,12 +156,12 @@ def adapt_bands(
     ValueError
         If LUMINANCE reduction is requested with a non-3-band input.
     """
-    current_bands = get_band_count(source)
+    current_bands = get_band_count(source, axis_order)
 
     if current_bands == required_bands:
         return source
 
-    axis = detect_band_axis(source)
+    axis = detect_band_axis(source, axis_order)
 
     logger.warning(
         "band_adaptation",

{grdl_runtime-0.1.2 → grdl_runtime-0.2.0}/grdl_rt/execution/builder.py

@@ -68,6 +68,7 @@ from grdl_rt.execution.resilience import (
 )
 from grdl_rt.execution.result import WorkflowResult
 from grdl_rt.execution.tags import ExecutionPhase, ImageModality, OutputFormat, WorkflowTags
+from grdl_rt.execution.tiled import ReaderSource, TiledExecutor, TilingConfig
 
 logger = get_logger(__name__)
 
@@ -382,6 +383,9 @@ class Workflow:
         self._steps: list[WorkflowStep | DeferredStep | TapOutStep] = []
         self._source: Callable[[], np.ndarray] | None = None
         self._reader_cls: type | None = None
+        self._reader_kwargs: dict[str, Any] = {}
+        self._tiling: TilingConfig | None = None
+        self._collection_checks: dict[str, Any] | None = None
         self._chip_strategy: str | None = None
         self._chip_kwargs: dict[str, Any] = {}
         self._current_phase: str | None = None
@@ -441,7 +445,7 @@ class Workflow:
     # Builder
     # ------------------------------------------------------------------
 
-    def reader(self, reader_cls: type) -> "Workflow":
+    def reader(self, reader_cls: type, **reader_kwargs: Any) -> "Workflow":
         """Declare the reader type for this workflow.
 
         When :meth:`execute` is called with a filepath, the framework
@@ -451,6 +455,11 @@ class Workflow:
         ----------
         reader_cls : type
             An ``ImageReader`` subclass (e.g., ``SICDReader``).
+        **reader_kwargs
+            Extra constructor arguments, e.g. ``polarizations='all'`` for
+            ``NISARReader``.  For collection readers such as
+            ``SICDCollectionReader``, pass a list of paths to
+            :meth:`execute` as the source.
 
         Returns
         -------
@@ -458,6 +467,76 @@ class Workflow:
             Self, for fluent chaining.
         """
         self._reader_cls = reader_cls
+        self._reader_kwargs = reader_kwargs
+        return self
+
+    def tiling(
+        self,
+        tile_size: int | tuple[int, int] = 1024,
+        *,
+        stride: int | tuple[int, int] | None = None,
+        workers: int | None = None,
+        backend: str = "process",
+        overlap_method: str = "weighted",
+        scratch_dir: str | Path | None = None,
+    ) -> "Workflow":
+        """Run tile-safe steps in parallel on halo tiles.
+
+        Consecutive steps whose processors declare a ``tile_halo`` run
+        tile by tile; any other step runs on the assembled full array, and
+        later tile-safe steps tile again.  Only file mode with a linear
+        workflow is supported, and not together with ``chip('center')``.
+        See :class:`~grdl_rt.execution.tiled.TilingConfig` for options.
+
+        Returns
+        -------
+        Workflow
+            Self, for fluent chaining.
+        """
+        self._tiling = TilingConfig(
+            tile_size=tile_size,
+            stride=stride,
+            workers=workers,
+            backend=backend,
+            overlap_method=overlap_method,
+            scratch_dir=scratch_dir,
+        )
+        return self
+
+    def validate_collection(
+        self,
+        *,
+        strict: bool = True,
+        reciprocity: str | None = None,
+        **thresholds: Any,
+    ) -> "Workflow":
+        """Check that a multi-channel input is a consistent collection.
+
+        Runs ``grdl.IO.sar.validate_collection`` after the reader opens and
+        before any pixels are processed.
+
+        Parameters
+        ----------
+        strict : bool
+            Raise on validation errors; otherwise only log them.
+        reciprocity : {None, 'warn', 'strict'}
+            Also test HV/VH reciprocity on sampled chips of a quad-pol
+            input; ``'strict'`` raises on failure, ``'warn'`` warns.
+        **thresholds
+            Forwarded to ``validate_collection``.
+
+        Returns
+        -------
+        Workflow
+            Self, for fluent chaining.
+        """
+        if reciprocity not in (None, "warn", "strict"):
+            raise ValueError("reciprocity must be None, 'warn' or 'strict'")
+        self._collection_checks = {
+            "strict": strict,
+            "reciprocity": reciprocity,
+            "thresholds": thresholds,
+        }
         return self
 
     def chip(self, strategy: str = "center", **kwargs: Any) -> "Workflow":
@@ -868,7 +947,7 @@ class Workflow:
 
     def execute(
         self,
-        source: np.ndarray | str | Path | None = None,
+        source: np.ndarray | str | Path | list[str | Path] | tuple[str | Path, ...] | None = None,
         *,
         prefer_gpu: bool = False,
         progress_callback: Callable[[float], None] | None = None,
@@ -900,8 +979,9 @@ class Workflow:
 
         Parameters
         ----------
-        source : np.ndarray, str, Path, or None
-            Input data.
+        source : np.ndarray, str, Path, list of paths, or None
+            Input data.  A list of paths is passed to the configured
+            reader as one argument (multi-file collections).
         prefer_gpu : bool
             If ``True``, attempt GPU acceleration for compatible steps.
         progress_callback : callable, optional
@@ -929,13 +1009,16 @@ class Workflow:
         RuntimeError
             If any step fails.
         """
-        source_path: Path | None = None
-
         # File mode → framework orchestration
-        if isinstance(source, (str, Path)):
-            source_path = Path(source)
+        if isinstance(source, (str, Path, list, tuple)):
+            if isinstance(source, (list, tuple)):
+                if not source:
+                    raise ValueError("source path list is empty")
+                paths: Path | list[Path] = [Path(p) for p in source]
+            else:
+                paths = Path(source)
             return self._execute_from_file(
-                source_path,
+                paths,
                 prefer_gpu=prefer_gpu,
                 progress_callback=progress_callback,
                 metadata_override=metadata,
@@ -1069,7 +1152,7 @@ class Workflow:
 
     def _execute_from_file(
         self,
-        filepath: Path,
+        filepath: Path | list[Path],
         *,
         prefer_gpu: bool,
         progress_callback: Callable[[float], None] | None,
@@ -1084,10 +1167,26 @@ class Workflow:
                 f"Workflow '{self._name}' received a filepath but no reader "
                 f"is configured.  Call .reader(ReaderClass) first."
             )
+        if self._tiling is not None:
+            self._check_tiling_supported()
 
-        with self._reader_cls(filepath) as rdr:
+        reader_cls, reader_kwargs = self._reader_cls, self._reader_kwargs
+        with reader_cls(filepath, **reader_kwargs) as rdr:
             meta = metadata_override if metadata_override is not None else rdr.metadata
 
+            if self._collection_checks is not None:
+                self._run_collection_checks(rdr)
+
+            if self._tiling is not None:
+                return self._execute_tiled(
+                    functools.partial(reader_cls, filepath, **reader_kwargs),
+                    meta,
+                    prefer_gpu=prefer_gpu,
+                    progress_callback=progress_callback,
+                )
+
+            source_path = filepath[0] if isinstance(filepath, list) else filepath
+
             # Read chip according to strategy
             chip = self._read_chip(rdr)
 
@@ -1109,7 +1208,7 @@ class Workflow:
                     resolved,
                     prefer_gpu=prefer_gpu,
                     progress_callback=progress_callback,
-                    source_path=filepath,
+                    source_path=source_path,
                     tap_out_format=tap_out_format,
                     tap_out_dir=tap_out_dir,
                 )
@@ -1121,6 +1220,119 @@ class Workflow:
                 metadata=meta,
             )
 
+    def _check_tiling_supported(self) -> None:
+        if self._is_dag:
+            raise ValueError("tiling() supports linear workflows only, not DAGs")
+        if self._chip_strategy == "center":
+            raise ValueError("tiling() cannot be combined with chip('center')")
+
+    def _run_collection_checks(self, rdr: Any) -> None:
+        """Validate the opened reader as a collection and test reciprocity."""
+        try:
+            from grdl.IO.sar import check_reciprocity_reader, validate_collection
+        except ImportError as e:
+            raise ImportError(
+                "validate_collection() requires grdl with " "grdl.IO.sar.collection_validation"
+            ) from e
+
+        checks = self._collection_checks or {}
+        report = validate_collection(rdr, **checks.get("thresholds", {}))
+        for issue in report.issues:
+            logger.warning(
+                "collection_issue",
+                level=issue.level,
+                code=issue.code,
+                message=issue.message,
+            )
+        if checks.get("strict", True):
+            report.raise_if_invalid()
+
+        mode = checks.get("reciprocity")
+        if mode is not None and report.is_quad_pol:
+            check_reciprocity_reader(rdr, strict=(mode == "strict"))
+
+    def _execute_tiled(
+        self,
+        reader_factory: Callable[[], Any],
+        meta: Any,
+        *,
+        prefer_gpu: bool,
+        progress_callback: Callable[[float], None] | None,
+    ) -> WorkflowResult:
+        """Run the workflow with :class:`TiledExecutor`."""
+        assert self._tiling is not None
+        ctx = ExecutionContext(
+            workflow_id=f"{self._name}:{self._version}",
+            workflow_name=self._name,
+        )
+        hardware = _capture_hardware()
+        sampler = MemorySampler()
+        sampler.start()
+        started_at = datetime.now(UTC).isoformat()
+        wall_t0 = time.perf_counter()
+        cpu_t0 = time.process_time()
+
+        resolved = self._resolve_steps(meta)
+        gpu = GpuBackend(prefer_gpu=prefer_gpu)
+        n_steps = len(resolved)
+
+        def run_global(ws: Any, data: Any, step_meta: Any, index: int) -> tuple[Any, Any, bool]:
+            if gpu.is_gpu_array(data):
+                data = gpu.to_cpu(data)
+            return self._execute_step_gpu_aware(
+                ws,
+                data,
+                gpu,
+                index,
+                n_steps,
+                metadata=step_meta,
+            )
+
+        run = TiledExecutor(self._tiling).run(
+            ReaderSource(reader_factory),
+            (meta.rows, meta.cols),
+            resolved,
+            meta,
+            run_global,
+            self._execute_tap_out,
+            progress_callback=progress_callback,
+        )
+
+        step_metrics = [
+            StepMetrics(
+                step_index=i,
+                processor_name=ws.name,
+                wall_time_s=timing.wall_time_s,
+                cpu_time_s=timing.cpu_time_s,
+                peak_rss_bytes=0,
+                gpu_used=gpu_used,
+                concurrent=tiled,
+                wall_start=timing.wall_start,
+                wall_end=timing.wall_end,
+            )
+            for i, (ws, timing, tiled, gpu_used) in enumerate(run.step_times)
+        ]
+        timeline = sampler.stop()
+        metrics = WorkflowMetrics(
+            workflow_id=ctx.workflow_id,
+            run_id=ctx.run_id,
+            workflow_name=self._name,
+            workflow_version=self._version,
+            total_wall_time_s=time.perf_counter() - wall_t0,
+            total_cpu_time_s=time.process_time() - cpu_t0 + run.worker_cpu_time_s,
+            peak_rss_bytes=timeline.peak(),
+            step_metrics=step_metrics,
+            started_at=started_at,
+            completed_at=datetime.now(UTC).isoformat(),
+            hardware=hardware,
+            memory_timeline=timeline,
+        )
+        return WorkflowResult(
+            result=run.result,
+            metrics=metrics,
+            metadata_trace=run.metadata_trace,
+        )
+
     def _read_chip(self, reader: Any) -> np.ndarray:
         """Plan and read a chip from the reader.
 
@@ -1371,6 +1583,7 @@ class Workflow:
                         ws.required_bands,
                         expansion=exp,
                         reduction=red,
+                        axis_order=getattr(current_meta, "axis_order", None),
                     )
 
                 # Capture step-level metrics

{grdl_runtime-0.1.2 → grdl_runtime-0.2.0}/grdl_rt/execution/config.py

@@ -92,6 +92,10 @@ class RetryDefaults(BaseModel):
 class MemoryConfig(BaseModel):
     """Memory estimation and threshold configuration."""
 
+    timeline_enabled: bool = Field(
+        default=False,
+        description="Collect and serialize the sampled memory timeline (opt-in profiling)",
+    )
     warn_threshold: float = Field(
         default=0.80,
         ge=0,
@@ -240,6 +244,7 @@ _ENV_MAP: dict[str, tuple] = {
     "GRDL_RT_MEMORY_WARN_THRESHOLD": ("memory", "warn_threshold"),
     "GRDL_RT_MEMORY_ABORT_THRESHOLD": ("memory", "abort_threshold"),
     "GRDL_RT_MEMORY_ESTIMATION_MULTIPLIER": ("memory", "estimation_multiplier"),
+    "GRDL_RT_MEMORY_TIMELINE_ENABLED": ("memory", "timeline_enabled"),
     "GRDL_RT_GPU_PREFER_GPU": ("gpu", "prefer_gpu"),
     "GRDL_RT_GPU_MEMORY_FRACTION": ("gpu", "memory_fraction"),
     "GRDL_RT_CATALOG_PATH": (None, "catalog_path"),
@@ -266,7 +271,7 @@ _BOOL_FALSY = {"0", "false", "no", "off", ""}
 def _coerce_env_value(raw: str, section: str | None, key: str) -> Any:
     """Coerce a string env var value to the appropriate Python type."""
     # Boolean fields
-    if key in ("prefer_gpu", "enabled"):
+    if key in ("prefer_gpu", "enabled", "timeline_enabled"):
         return raw.lower() in _BOOL_TRUTHY
 
     # Float fields

{grdl_runtime-0.1.2 → grdl_runtime-0.2.0}/grdl_rt/execution/memory_sampler.py

@@ -11,7 +11,7 @@ recorded values.
 
 Typical usage::
 
-    sampler = MemorySampler(interval_s=0.001)
+    sampler = MemorySampler(interval_s=0.001, enabled=True)
     sampler.start()
 
     # … run pipeline …
@@ -50,6 +50,8 @@ import time
 import tracemalloc
 from typing import Any
 
+from grdl_rt.execution.config import get_runtime_config
+
 
 class MemoryTimeline:
     """Immutable snapshot of a completed memory sampling session.
@@ -173,10 +175,15 @@ class MemorySampler:
     ----------
     interval_s : float
         Sampling interval in seconds.  Default ``0.001`` (1 ms).
+    enabled : bool, optional
+        Override ``memory.timeline_enabled`` in runtime configuration.
+        Disabled by default: no tracing, thread, or timestamp buffers are
+        started, and :meth:`stop` returns an empty timeline with peak 0.
     """
 
-    def __init__(self, interval_s: float = 0.001) -> None:
+    def __init__(self, interval_s: float = 0.1, *, enabled: bool | None = None) -> None:
         self.interval_s = interval_s
+        self.enabled = get_runtime_config().memory.timeline_enabled if enabled is None else enabled
         self._timestamps: array.array[float] | None = None
         self._mem_values: array.array[float] | None = None
         self._stop_event = threading.Event()
@@ -189,6 +196,8 @@ class MemorySampler:
 
     def start(self) -> None:
         """Start ``tracemalloc``, allocate buffers, and begin sampling."""
+        if not self.enabled:
+            return
         self._tracemalloc_was_running = tracemalloc.is_tracing()
         if not self._tracemalloc_was_running:
             tracemalloc.start()
@@ -225,6 +234,8 @@ class MemorySampler:
         MemoryTimeline
             Immutable timeline of corrected memory samples.
         """
+        if not self.enabled:
+            return MemoryTimeline(timestamps=[], values=[], t0=0.0)
         self._stop_event.set()
         if self._thread is not None:
             self._thread.join(timeout=2.0)

{grdl_runtime-0.1.2 → grdl_runtime-0.2.0}/grdl_rt/execution/metrics.py

@@ -2,11 +2,12 @@
 Execution Metrics — Structured timing and resource usage data.
 
 Provides ``StepMetrics`` and ``WorkflowMetrics`` dataclasses that capture
-wall-clock time, CPU time, peak memory, GPU usage, and a continuous
-memory timeline for every workflow execution.  These are returned as
+wall-clock time, CPU time, peak memory, GPU usage, and an optional
+memory timeline for workflow executions.  These are returned as
 part of ``WorkflowResult`` from all execution paths.
 
-Memory is measured by a background ``MemorySampler`` thread that polls
+When opted in via ``memory.timeline_enabled``, memory is measured by a
+background ``MemorySampler`` thread that polls
 ``tracemalloc`` at 1 ms intervals.  The resulting ``MemoryTimeline``
 on ``WorkflowMetrics`` can be overlaid with each step's
 ``wall_start`` / ``wall_end`` timestamps for visualization.
@@ -64,8 +65,13 @@ class StepMetrics:
         Fully-qualified or short name of the processor executed.
     wall_time_s : float
         Wall-clock duration in seconds (``time.perf_counter`` delta).
+        For tiled steps, elapsed span from the first tile invocation to
+        the last completion, not the sum of worker durations. Steps in
+        one tiled segment overlap, so their wall times are not additive.
     cpu_time_s : float
-        CPU time in seconds (``time.process_time`` delta).
+        Measured CPU seconds, not estimated from wall time. Tiled steps
+        sum worker process CPU deltas (serial/process backend) or calling
+        thread CPU deltas (thread backend, excluding native helper threads).
     peak_rss_bytes : int
         Peak memory in bytes.  For single-component benchmarks this
         is the timeline peak for the step.  For pipeline steps this
@@ -166,7 +172,8 @@ class StepMetrics:
 class WorkflowMetrics:
     """Aggregate metrics for a complete workflow execution.
 
-    Memory is measured via a ``MemorySampler`` background thread that
+    When ``memory.timeline_enabled`` is enabled, memory is measured via
+    a ``MemorySampler`` background thread that
     polls ``tracemalloc.get_traced_memory()`` at 1 ms intervals and
     subtracts its own storage overhead from every reading.  The
     resulting ``memory_timeline`` is a continuous time-series of
@@ -186,10 +193,12 @@ class WorkflowMetrics:
     total_wall_time_s : float
         Total wall-clock duration in seconds.
     total_cpu_time_s : float
-        Total CPU time in seconds.
+        Total CPU time in seconds. Tiled process execution includes measured
+        worker-job CPU in addition to parent process CPU; worker startup and
+        interprocess serialization outside tile jobs are not included.
     peak_rss_bytes : int
         Peak memory usage in bytes across the entire run, derived from
-        the ``memory_timeline``.
+        the ``memory_timeline``. Zero when memory profiling is disabled.
     step_metrics : List[StepMetrics]
         Per-step metrics, one entry per processing step.
     started_at : str
@@ -215,7 +224,8 @@ class WorkflowMetrics:
         readings sampled at 1 ms intervals over the pipeline lifetime.
         Correlate with each step's ``wall_start`` / ``wall_end`` for
         per-step memory visualization.  ``None`` for runs produced
-        before this field was added.
+        before this field was added. Empty when profiling is disabled;
+        empty timelines are omitted from serialization.
     """
 
     workflow_id: str
@@ -259,7 +269,7 @@ class WorkflowMetrics:
             d["hardware"] = self.hardware
         if self.step_depends_on is not None:
             d["step_depends_on"] = self.step_depends_on
-        if self.memory_timeline is not None:
+        if self.memory_timeline is not None and len(self.memory_timeline) > 0:
             d["memory_timeline"] = self.memory_timeline.to_dict()
         return d