dynamic-systems-testing-framework 1.0.1__py3-none-any.whl

dstf/backends/common/proc_kill.py

@@ -0,0 +1,238 @@
+"""Shared process-kill helpers for backends."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+
+def kill_process_tree(
+    pid: int,
+    name_hint: str | None = None,
+    create_time: float | None = None,
+) -> None:
+    """Kill *pid* and its entire child tree, children first.
+
+    The tracked PID is never the process doing the simulating: dymola.exe
+    spawns dymosim, omc spawns the compiled model binary. Killing only the
+    parent leaves that child burning CPU and holding the result files open
+    (on Windows the next run's rmtree then fails with PermissionError)
+    (review 2026-07-06, finding 22).
+
+    Two independent guards against PID reuse, because a PID we recorded
+    seconds ago may belong to something else by now — on Windows freed
+    PIDs come back almost immediately:
+
+    * ``name_hint`` — nothing is killed unless the process's name still
+      contains the hint (``"dymola"``, ``"omc"``, ``"julia"``).
+    * ``create_time`` — the exact process-creation timestamp recorded when
+      the PID was captured. A recycled PID has a later one, and nothing is
+      killed. Pass it whenever the PID was recorded earlier and the caller
+      can't otherwise prove the process is the same one.
+
+    Children resolved from the live tree in this call need neither guard —
+    they are read from the process we just validated, and the hint would
+    wrongly exclude exactly the children we're after (dymosim under
+    dymola). Children recorded *earlier* do need both: see
+    :func:`snapshot_children`, which records them with their create times
+    for feeding back through this function.
+
+    A parent that already exited takes its children out of reach here,
+    which is what ``snapshot_children`` exists to cover.
+
+    Best-effort throughout: psutil may be missing and processes may vanish
+    or be inaccessible mid-walk.
+    """
+    try:
+        import psutil
+    except ImportError:  # pragma: no cover — psutil is a hard dep in practice
+        return
+
+    try:
+        parent = psutil.Process(pid)
+        if name_hint and name_hint not in (parent.name() or "").lower():
+            return
+        if create_time is not None and parent.create_time() != create_time:
+            # PID reused since it was recorded — this is somebody else.
+            return
+        children = parent.children(recursive=True)
+    except (psutil.NoSuchProcess, psutil.AccessDenied):
+        return
+    except Exception:
+        # A kill path must never raise: an unexpected psutil error here
+        # would surface as a bogus "worker exception" in the dispatch
+        # loop instead of the timeout that actually happened.
+        return
+
+    for proc in [*children, parent]:
+        try:
+            proc.kill()
+        except Exception:
+            pass
+
+
+def snapshot_children(
+    pid: int,
+    name_hint: str | None = None,
+) -> set[tuple[int, float]]:
+    """Descendants of *pid* as ``(pid, create_time)`` pairs, recorded while
+    the parent is still alive.
+
+    Covers exactly one case: a graceful shutdown that succeeds. dymola.exe
+    exits on ``close()`` while dymosim keeps running and keeps the result
+    files open, and once the parent is gone nothing links the two, so
+    ``kill_process_tree`` can no longer find the child. The worker
+    therefore snapshots the tree immediately before its graceful attempt
+    and kills the recorded processes afterwards. (A parent that died
+    *before* ``close()`` was ever called has already orphaned its children
+    beyond the reach of this snapshot.)
+
+    The create times are what make the recorded PIDs safe to kill later:
+    the graceful window is seconds long, and a PID freed inside it can be
+    reissued to an unrelated process — or to another worker's fresh
+    dymosim. ``name_hint`` guards the parent the same way
+    :func:`kill_process_tree` does, so a recycled *parent* PID never hands
+    us a stranger's children in the first place.
+
+    Best-effort: an empty set on any failure.
+    """
+    try:
+        import psutil
+    except ImportError:  # pragma: no cover — psutil is a hard dep in practice
+        return set()
+
+    try:
+        parent = psutil.Process(pid)
+        if name_hint and name_hint not in (parent.name() or "").lower():
+            return set()
+        children = parent.children(recursive=True)
+    except Exception:
+        # Snapshotting sits on the close path; it must never raise there.
+        return set()
+
+    snapshot: set[tuple[int, float]] = set()
+    for child in children:
+        try:
+            snapshot.add((child.pid, child.create_time()))
+        except Exception:
+            # Vanished or inaccessible between the walk and the read —
+            # a PID without its create time is not safe to kill later.
+            continue
+    return snapshot
+
+
+def orphans_in(directory: str, born_after: float) -> set[tuple[int, float]]:
+    """Linux only: the processes a dead tool left behind in *directory*, as
+    ``(pid, create_time)`` pairs for :func:`kill_process_tree`.
+
+    A tool that dies by itself orphans its children, and a child nobody
+    recorded while the tool was alive cannot be found through it any more.
+    What it left is told from everything else on the machine by a mark of
+    three parts, ALL required:
+
+    * it runs in *directory* or below — the scratch directory of the one
+      test the dead tool was running, which the tool was told to work in
+      and no other worker uses;
+    * it was created no earlier than *born_after*, the tool's own creation
+      time on the same clock (a child cannot predate its parent);
+    * it has no parent of its own left: it hangs under init, or under a
+      reaper among this process's ancestors — where the kernel puts the
+      orphans of our descendants. A child of this process is not one, and
+      neither is a child of anybody else's live process.
+
+    Unreadable means unmarked: a process whose directory or parent cannot
+    be read is left alone. Other platforms report no working directory for
+    a foreign process without privileges, or do not reparent: ``set()``.
+    """
+    if not sys.platform.startswith("linux"):
+        return set()
+    try:
+        import psutil
+
+        reapers = {1} | {parent.pid for parent in psutil.Process().parents()}
+        root = os.path.realpath(directory)
+    except Exception:
+        return set()
+    found: set[tuple[int, float]] = set()
+    for proc in psutil.process_iter():
+        try:
+            if proc.ppid() not in reapers or proc.pid in reapers | {os.getpid()}:
+                continue
+            created = proc.create_time()
+            if created < born_after or proc.status() == psutil.STATUS_ZOMBIE:
+                continue
+            cwd = proc.cwd()
+            if cwd == root or cwd.startswith(root + os.sep):
+                found.add((proc.pid, created))
+        except Exception:
+            continue
+    return found
+
+
+def created_at(pids: set[int]) -> float | None:
+    """When the earliest of *pids* was created (the clock of
+    :func:`orphans_in`), or ``None`` when that cannot be read."""
+    try:
+        import psutil
+
+        return min(psutil.Process(pid).create_time() for pid in pids)
+    except Exception:
+        return None
+
+
+def process_gone(pids: set[int], name_hint: str | None = None) -> bool:
+    """True when *pids* names at least one process and none of them is
+    running any more — exited, or a zombie nobody has reaped yet. With
+    ``name_hint``, a PID that is no longer the tool's is not running
+    either: the process under it has another name (the guard of
+    :func:`kill_process_tree`, for a PID recorded long ago).
+
+    How a worker tells "the tool died" from "the tool is slow". Errs
+    towards alive: no PIDs, no psutil, or a process it cannot inspect all
+    read as not gone, since the answer triggers a kill and a restart.
+    """
+    if not pids:
+        return False
+    try:
+        import psutil
+
+        for pid in list(pids):
+            try:
+                proc = psutil.Process(pid)
+                if proc.status() == psutil.STATUS_ZOMBIE:
+                    continue
+                if name_hint and name_hint not in (proc.name() or "").lower():
+                    continue
+                return False
+            except psutil.NoSuchProcess:
+                continue
+        return True
+    except Exception:
+        return False
+
+
+def live_children(pids: set[int], name_hint: str | None = None) -> list:
+    """Every descendant of *pids* alive right now, as ``psutil.Process``
+    objects — what a backend's soft cancel looks through for the process
+    doing the simulating. A zombie is not alive: a child killed a moment
+    ago stays in the table until its parent reaps it. ``name_hint`` guards
+    each of *pids* as :func:`kill_process_tree` does: a PID whose process
+    is no longer the tool (recycled) hands over nobody's children — what
+    comes back is killed, or told to stop. Best-effort: ``[]`` on any
+    failure."""
+    try:
+        import psutil
+    except ImportError:  # pragma: no cover — psutil is a hard dep in practice
+        return []
+    children: list = []
+    for pid in list(pids):
+        try:
+            parent = psutil.Process(pid)
+            if name_hint and name_hint not in (parent.name() or "").lower():
+                continue
+            for child in parent.children(recursive=True):
+                if child.status() != psutil.STATUS_ZOMBIE:
+                    children.append(child)
+        except Exception:
+            continue
+    return children

dstf/backends/common/proc_output.py

@@ -0,0 +1,20 @@
+"""Shared subprocess-output helpers for backends."""
+
+from __future__ import annotations
+
+
+def decode_output(data: bytes | str | None) -> str:
+    """Normalize subprocess output (str, bytes, or None) to str.
+
+    review 2026-07-06 (finding 23): ``subprocess.TimeoutExpired.stdout`` /
+    ``.stderr`` are **bytes** even when the process was opened with
+    ``text=True``. Handlers that did ``(exc.stdout or "") + "..."`` or
+    ``write_text(exc.stdout)`` raised TypeError inside the timeout path —
+    aborting the whole run precisely when a test timed out after printing
+    output. Every backend's timeout handler funnels through this helper.
+    """
+    if data is None:
+        return ""
+    if isinstance(data, bytes):
+        return data.decode("utf-8", errors="replace")
+    return data

dstf/backends/common/result_files.py

@@ -0,0 +1,109 @@
+"""Any variable of a result file, by name — the three on-disk formats the
+bundled backends write, each as a pair: the names in the file (``None`` when
+there is no readable file) and the named series as ``{name: (time, values)}``
+(a name the file lacks is left out). A backend class points its
+``result_names`` / ``result_series`` at one pair. The tracked-variable read
+(``read_result``) stays where it is: it resolves patterns, indexes and
+diagnostics; this reads what a plot asks for."""
+
+from __future__ import annotations
+
+import json
+import zipfile
+from collections.abc import Collection
+from pathlib import Path
+
+import numpy as np
+
+from .mat_reader import list_result_mat_variables, read_result_mat
+
+SeriesByName = dict[str, tuple[np.ndarray, np.ndarray]]
+
+
+def mat_names(path: Path) -> list[str] | None:
+    if not path.exists():
+        return None
+    names = list_result_mat_variables(path)
+    return None if names is None else [n for n in names if n.lower() != "time"]
+
+
+def mat_series(path: Path, names: Collection[str]) -> SeriesByName:
+    if not path.exists() or not names:
+        return {}
+    # A partial or foreign .mat reads as None: the reader swallows its own
+    # errors.
+    data = read_result_mat(path, variable_names=set(names))
+    return {n: data[n] for n in names if data and n in data}
+
+
+def _json_payload(path: Path) -> dict | None:
+    try:
+        payload = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):  # unreadable, not UTF-8, not JSON
+        return None
+    if not isinstance(payload, dict) or not isinstance(payload.get("variables"), dict):
+        return None
+    return payload
+
+
+def json_names(path: Path) -> list[str] | None:
+    payload = _json_payload(path)
+    if payload is None:
+        return None
+    return [n for n in payload["variables"] if n != "time"]
+
+
+def json_series(path: Path, names: Collection[str]) -> SeriesByName:
+    payload = _json_payload(path)
+    if payload is None:
+        return {}
+    time = _vector(payload.get("time"))
+    if time is None:
+        return {}
+    out: SeriesByName = {}
+    for n in names:
+        values = _vector(payload["variables"].get(n)) if n != "time" else None
+        if values is not None and values.shape == time.shape:
+            out[n] = (time, values)
+    return out
+
+
+def _vector(raw: object) -> np.ndarray | None:
+    """``raw`` as a 1-D float array, or ``None`` for anything that is not a
+    list of numbers — a run killed mid-write, a driver that dumped strings."""
+    if not isinstance(raw, list):
+        return None
+    try:
+        arr = np.asarray(raw, dtype=float)
+    except (ValueError, TypeError):
+        return None
+    return arr if arr.ndim == 1 else None
+
+
+def _npz_array(path: Path) -> np.ndarray | None:
+    try:
+        with np.load(path, allow_pickle=False) as npz:
+            return npz["result"]
+    except (OSError, KeyError, ValueError, EOFError, zipfile.BadZipFile):
+        return None  # absent, or half-written: savez_compressed is not atomic
+
+
+def npz_names(path: Path) -> list[str] | None:
+    arr = _npz_array(path)
+    if arr is None or arr.dtype.names is None:
+        return None
+    return [n for n in arr.dtype.names if n != "time"]
+
+
+def npz_series(path: Path, names: Collection[str]) -> SeriesByName:
+    arr = _npz_array(path)
+    if arr is None or arr.dtype.names is None or "time" not in arr.dtype.names:
+        return {}
+    time = np.asarray(arr["time"], dtype=float)
+    out: SeriesByName = {}
+    for n in names:
+        if n in arr.dtype.names and n != "time":
+            values = np.asarray(arr[n], dtype=float)
+            if values.shape == time.shape:  # a subarray column is not a series
+                out[n] = (time, values)
+    return out

dstf/backends/common/result_variables.py

@@ -0,0 +1,329 @@
+"""Shared result-extraction helpers for DSresult-MAT backends.
+
+Dymola and OpenModelica write the same DSresult MAT layout and follow the
+same ``<instance>.x[i]`` convention, so variable selection, extraction and the
+diagnostics/timing fold into ``statistics`` are one implementation here rather
+than a copy per backend. Backends keep their own MAT reading and their own
+timing computation — only what is genuinely identical lives here.
+
+Also here: :func:`tracked_results`, which of a read result's variables a test
+TRACKS — the rule the comparator and the authoring Session both ask.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable, Iterable
+from pathlib import Path
+
+import numpy as np
+
+from ...discovery.test_registry import TestModel
+from ...discovery.unit_tests import unit_test_variables
+from ..types import (
+    TestResult,
+    TestRunResult,
+    VariableResult,
+    _pattern_to_regex,
+    is_glob_pattern,
+    resolve_variable_patterns,
+)
+from .mat_reader import list_result_mat_variables, mat_shortfall
+
+logger = logging.getLogger(__name__)
+
+
+def criterion_variables(test: TestModel, diagnostic_vars: Iterable[str]) -> list[str]:
+    """The variables ``test``'s criteria name (`tree_variables`): what every
+    backend records and extracts AFTER the UnitTests variables and the
+    ``variables`` patterns, so a criterion added later renumbers neither
+    (a stored baseline records each variable's index). Imported here, not at module level: importing
+    ``dstf.comparison`` runs its package init, which imports the comparator,
+    which imports ``dstf.backends`` — a cycle from any backend module."""
+    from ...comparison.tree_spec import tree_variables
+
+    return tree_variables(test.metric_tree_spec, diagnostic_vars)
+
+
+def tracked_results(test: TestModel, result: TestResult) -> list[VariableResult]:
+    """The variables of ``result`` that ``test`` TRACKS: its UnitTests
+    variables and its ``variables`` patterns matched against the result's
+    names, ``"*"`` every one. What the flat path (no tree) scores, what a
+    tree warns of when no leaf covers it, and the Variables drawer's
+    Tracked group.
+
+    Never simply every variable the result holds. A tree names variables
+    too, and a backend records and extracts them beside the tracked ones:
+    a result read while a criterion was staged (a rerun runs with the
+    pending edits) keeps that variable after the criterion is discarded.
+    Scored, with no baseline, it failed the test for a variable the test
+    never asked about; under a saved tree it was named a tracked variable
+    without a criterion. On a result extracted for the test as it stands
+    with no tree this is every variable: extraction is exactly these two
+    groups.
+
+    Matched quietly: the backend that extracted the result already warned
+    about a pattern that matched nothing, and this runs on every rescore. A
+    variable with NO name is a backend bug: no name or pattern tracks it,
+    and leaving it out is said, not done quietly."""
+    if "*" in test.variable_patterns:
+        return list(result.variables)
+    for v in result.variables:
+        if not v.name:
+            logger.warning(
+                "%s: result variable %d has no name and is not tracked",
+                test.model_id,
+                v.index,
+            )
+    tracked = tracks(test)
+    return [v for v in result.variables if tracked(v.name)]
+
+
+def tracks(test: TestModel) -> Callable[[str], bool]:
+    """Whether ``test`` TRACKS a variable of that name: one of its
+    UnitTests variables, a ``variables`` pattern that names it or a glob
+    that matches it (``"*"`` every name). THE one rule, asked of a result's
+    variables (:func:`tracked_results`) and of a baseline's (the
+    comparator: a tracked variable the baseline holds and the run does
+    not)."""
+    wanted = {v.name for v in unit_test_variables(test)}
+    globs = []
+    for pattern in test.variable_patterns:
+        if is_glob_pattern(pattern):
+            globs.append(_pattern_to_regex(pattern))
+        else:
+            wanted.add(pattern)
+    return lambda name: name in wanted or any(g.fullmatch(name) for g in globs)
+
+
+def compute_needed_variables(
+    mat_path: Path,
+    test: TestModel,
+    diagnostic_vars: list[str],
+) -> set[str] | None:
+    """Determine which variables need to be extracted from a .mat file.
+
+    Returns a set of variable names, or None to load everything (fallback when
+    the name matrix cannot be read). This avoids loading all data for large
+    files with thousands of variables.
+    """
+    needed: set[str] = set()
+
+    # UnitTests component variables, under their result-file names
+    needed.update(v.name for v in unit_test_variables(test))
+
+    # Pattern-based variables — need the full name list to resolve globs
+    if test.variable_patterns:
+        all_names = list_result_mat_variables(mat_path)
+        if all_names is None:
+            return None  # fallback: load everything
+        resolved = resolve_variable_patterns(test.variable_patterns, all_names)
+        needed.update(resolved)
+
+    # Variables a criterion names (literal: no name matrix needed)
+    needed.update(criterion_variables(test, diagnostic_vars))
+
+    needed.update(diagnostic_vars)
+
+    return needed if needed else None
+
+
+def extract_variables(
+    mat_data: dict,
+    test: TestModel,
+    diagnostic_vars: list[str],
+) -> tuple[list[VariableResult], list[VariableResult]]:
+    """Extract tracked variables and diagnostic variables from parsed mat data.
+
+    Returns (variables, diagnostics).
+    """
+    results: list[VariableResult] = []
+    seen: set[str] = set()
+    idx = 1
+
+    # 1. UnitTests variables (source = "unit_tests" or "both"): the name is
+    # the result file's, the model's expression rides beside it as a label.
+    # ``seen`` therefore holds result-file names only — a pattern resolving
+    # to a DIFFERENT variable that an expression happens to spell is that
+    # other variable, and is extracted too.
+    for ut in unit_test_variables(test):
+        if ut.name in mat_data:
+            time_arr, values = mat_data[ut.name]
+            results.append(
+                VariableResult(
+                    index=idx,
+                    time=time_arr,
+                    values=values,
+                    name=ut.name,
+                    expression=ut.expression,
+                )
+            )
+            seen.add(ut.name)
+            idx += 1
+        else:
+            # Loud on every backend: a requested variable absent from the
+            # output is a spec/model mismatch, not something to swallow.
+            logger.warning(
+                "Variable %s not found in simulation output for %s",
+                ut.name,
+                test.model_id,
+            )
+
+    # 2. Pattern-based variables (source = "spec" or "both")
+    if test.variable_patterns:
+        available = list(mat_data.keys())
+        resolved = resolve_variable_patterns(test.variable_patterns, available)
+        for var_name in resolved:
+            if var_name in seen:
+                continue
+            if var_name in mat_data:
+                time_arr, values = mat_data[var_name]
+                results.append(
+                    VariableResult(
+                        index=idx, time=time_arr, values=values, name=var_name
+                    )
+                )
+                seen.add(var_name)
+                idx += 1
+
+    # 3. Variables a criterion names, APPENDED: a criterion added later
+    # renumbers neither of the first two groups (a stored baseline records
+    # each variable's index).
+    for var_name in criterion_variables(test, diagnostic_vars):
+        if var_name in seen:
+            continue
+        if var_name in mat_data:
+            time_arr, values = mat_data[var_name]
+            results.append(
+                VariableResult(index=idx, time=time_arr, values=values, name=var_name)
+            )
+            seen.add(var_name)
+            idx += 1
+        else:
+            logger.warning(
+                "Variable %s not found in simulation output for %s",
+                var_name,
+                test.model_id,
+            )
+
+    # 4. Diagnostic variables (auto-captured, not compared — D54–D55)
+    diagnostics: list[VariableResult] = []
+    diag_idx = 1
+    for var_name in diagnostic_vars:
+        if var_name in mat_data:
+            time_arr, values = mat_data[var_name]
+            diagnostics.append(
+                VariableResult(
+                    index=diag_idx,
+                    time=time_arr,
+                    values=values,
+                    name=var_name,
+                )
+            )
+            diag_idx += 1
+
+    return results, diagnostics
+
+
+def unfinished_result(
+    test: TestModel,
+    mat_path: Path,
+    variables: list[VariableResult],
+    diagnostics: list[VariableResult],
+    stats: dict | None,
+) -> TestResult | None:
+    """The FAILED result an unfinished result file reads as — ``None`` for
+    a finished one, which the caller goes on to return as a success.
+
+    A file its writer did not finish (a killed or crashed run, a cut copy:
+    :func:`mat_shortfall`) is read like any other, so the rows it holds can
+    be SHOWN. Being a failure is what keeps them from being scored or
+    offered as a baseline: the reader takes its row count from the file's
+    size, so without this a partial trajectory would read as a result. A
+    file with no time point shows nothing.
+    """
+    shortfall = mat_shortfall(mat_path)
+    if shortfall is None:
+        return None
+    held = any(len(v.time) for v in variables)
+    return TestResult(
+        model_id=test.model_id,
+        success=False,
+        variables=variables if held else [],
+        diagnostics=diagnostics if held else [],
+        error_message=shortfall,
+        statistics=stats,
+    )
+
+
+def fold_diagnostics_into_statistics(
+    stats: dict | None,
+    diagnostics: list[VariableResult],
+) -> dict | None:
+    """Add each diagnostic's final value to ``stats``, returning the dict.
+
+    Creates the dict if there is anything to fold and ``stats`` is None.
+    float32 trajectories are rounded to 7 significant digits (their real
+    precision) so the on-disk reference JSON does not carry binary noise.
+    """
+    if not diagnostics:
+        return stats
+    if stats is None:
+        stats = {}
+    for diag in diagnostics:
+        if len(diag.values) > 0:
+            sig = 7 if diag.values.dtype == np.float32 else 15
+            stats[diag.name] = float(f"%.{sig}g" % diag.values[-1])
+    return stats
+
+
+def merge_timing_stats(stats: dict | None, timing: dict[str, float]) -> dict:
+    """Overlay wall-clock summary keys onto ``stats["timing"]``.
+
+    Non-destructive: whatever raw per-phase seconds a backend's log parser
+    already put under ``timing`` survive.
+    """
+    if stats is None:
+        stats = {}
+    stats.setdefault("timing", {}).update(timing)
+    return stats
+
+
+def run_timing(rr: TestRunResult) -> dict[str, float]:
+    """The run's wall-clock phase summary — the ``statistics["timing"]`` keys
+    every backend's result carries (``translation_wall``, ``sim_wall``,
+    ``other_wall``, ``total_wall``): seconds, rounded to 2, only the keys the
+    run measured.
+
+    All are wall-clock seconds measured on the Python side, distinct from a
+    tool's own CPU-time statistics. ``{}`` when the run measured neither a
+    translation nor a simulation wall (Dymola batch: its ``elapsed`` is a
+    batch average, and a block built from it would show a time no test took).
+    ``other_wall`` — what the run spent outside translation and simulation —
+    only when both walls are known: a missing wall is not a 0.
+    """
+    if rr.translation_wall is None and rr.sim_wall is None:
+        return {}
+    timing: dict[str, float] = {}
+    if rr.translation_wall is not None:
+        timing["translation_wall"] = round(rr.translation_wall, 2)
+    if rr.sim_wall is not None:
+        timing["sim_wall"] = round(rr.sim_wall, 2)
+    if rr.elapsed:
+        if rr.translation_wall is not None and rr.sim_wall is not None:
+            other = rr.elapsed - rr.translation_wall - rr.sim_wall
+            timing["other_wall"] = round(max(0.0, other), 2)
+        timing["total_wall"] = round(rr.elapsed, 2)
+    return timing
+
+
+__all__ = [
+    "compute_needed_variables",
+    "criterion_variables",
+    "extract_variables",
+    "fold_diagnostics_into_statistics",
+    "merge_timing_stats",
+    "run_timing",
+    "tracked_results",
+    "tracks",
+]