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

dstf/backends/openmodelica/init_xml.py

@@ -0,0 +1,76 @@
+"""What omc's ``<prefix>_init.xml`` says of a model's SIZE.
+
+OpenModelica prints no translation statistics, so its statistics were
+timing only: a model that gained a state said ``Continuous states: 2 -> 3``
+on Dymola (its translation log) and nothing here. omc does write the
+system's size, as attributes of the root element of the init file it
+generates beside the executable (``fmiModelDescription
+numberOfContinuousStates="3" …``). What that file holds of a quantity
+Dymola's backend records is read into the SAME statistics key — one
+structural check, one Statistics row, on both simulators.
+
+Read from the file, at every read of a result: nothing is kept beside the
+result for it, so a ``compare`` of an earlier run has it too. A baseline
+accepted before this has no such statistic, and a statistic one side lacks
+is no change (``comparator._check_structural_changes``, ``stats_rows.
+changed``): the first accept after it records the number.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+#: omc's attribute → the ``statistics.translation`` key Dymola's translation
+#: log fills with the same quantity. Only what both simulators count the
+#: same way: omc's other counts (event indicators, algebraic variables by
+#: type, parameters by type) have no twin there — Dymola's ``free_parameters``
+#: and ``scalar_unknowns`` are other quantities — and are not read.
+SYSTEM_SIZE = {"numberOfContinuousStates": "continuous_time_states"}
+
+#: A count as omc writes one: ASCII digits and nothing else.
+_COUNT = re.compile(r"[0-9]+")
+
+
+def system_size(init_xml: Path) -> dict[str, int]:
+    """The ``statistics.translation`` entries *init_xml* gives; none for a
+    file that is not there, does not parse, or holds no count under an
+    attribute — an old omc, a build that failed before it wrote the file.
+    ``0`` is a count: a model with no state has one. Only the root element's start tag is read: the file lists every
+    variable of the model, megabytes for a large one."""
+    try:
+        for _event, root in ET.iterparse(init_xml, events=("start",)):
+            attributes = dict(root.attrib)
+            break
+        else:
+            return {}
+    except (OSError, ET.ParseError):
+        logger.debug("no system size from %s", init_xml, exc_info=True)
+        return {}
+    found: dict[str, int] = {}
+    for attribute, key in SYSTEM_SIZE.items():
+        text = attributes.get(attribute)
+        # A count is a non-negative decimal integer, all of it — or it is
+        # not recorded. `int()` also reads `-1`, `+3`, `1_000`, ` 3 ` and
+        # the digits of other scripts, none of which omc writes for one.
+        if text is not None and _COUNT.fullmatch(text):
+            found[key] = int(text)
+    return found
+
+
+def with_system_size(stats: dict | None, init_xml: Path) -> dict | None:
+    """*stats* with what *init_xml* says under ``translation``: a new dict,
+    or *stats* itself — None included — when the file says nothing."""
+    found = system_size(init_xml)
+    if not found:
+        return stats
+    merged = dict(stats or {})
+    merged["translation"] = {**(merged.get("translation") or {}), **found}
+    return merged
+
+
+__all__ = ["SYSTEM_SIZE", "system_size", "with_system_size"]

dstf/backends/openmodelica/log_parser.py

@@ -0,0 +1,119 @@
+"""Parse OpenModelica's ``omc`` stdout for per-test results.
+
+When ``omc`` runs a ``.mos`` that ends with a top-level ``simulate(...)`` call,
+it REPL-echoes the returned record to stdout:
+
+    record SimulationResult
+        resultFile = "/path/to/result_res.mat",
+        simulationOptions = "...",
+        messages = "...",
+        timeFrontend = 0.19,
+        timeBackend = 0.04,
+        ...
+        timeTotal = 1.25
+    end SimulationResult;
+
+This module extracts that block, classifies success/failure, and surfaces any
+Error/Warning/Notification lines that appeared BEFORE it. The return shape is
+a small ``ParsedOmcOutput`` dataclass the backend consumes to populate
+``TestRunResult``.
+
+The parser is total — any shape of input produces a ``ParsedOmcOutput``, with
+``success=False`` and ``timings=None`` on truncation / missing record.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ParsedOmcOutput:
+    """Structured view of what the backend needs from omc stdout."""
+
+    success: bool
+    result_file: str = ""
+    messages: str = ""
+    timings: dict[str, float] | None = None
+    error_notices: list[str] = field(default_factory=list)
+
+
+# Match 'record SimulationResult … end SimulationResult;' lazily across
+# however many lines the record spans.
+_RECORD_RE = re.compile(
+    r"record SimulationResult(?P<body>.*?)end SimulationResult;",
+    re.DOTALL,
+)
+
+# Match a quoted string-valued record field. The value may span multiple
+# lines (OM's 'messages' often does). Handles embedded \" and \\ escapes.
+_STR_FIELD_RE = re.compile(
+    r'\b(\w+)\s*=\s*"((?:\\.|[^"\\])*)"',
+    re.DOTALL,
+)
+
+# Match a numeric-valued record field. Run AFTER stripping string fields from
+# the body (digits in messages would otherwise get misread).
+_NUM_FIELD_RE = re.compile(
+    r"\b(\w+)\s*=\s*([-+]?[0-9]*\.?[0-9]+(?:[eE][-+]?[0-9]+)?)",
+)
+
+# OM field name -> our internal key
+_TIMING_KEYS = {
+    "timeFrontend": "frontend",
+    "timeBackend": "backend",
+    "timeSimCode": "simcode",
+    "timeTemplates": "templates",
+    "timeCompile": "compile",
+    "timeSimulation": "simulation",
+    "timeTotal": "total",
+}
+
+# Lines like 'Error: ...' / 'Warning: ...' / 'Notification: ...'
+_NOTICE_RE = re.compile(
+    r"^\s*(?:Error|Warning|Notification)\b[: ].*$",
+    re.MULTILINE,
+)
+
+
+def parse_omc_stdout(text: str) -> ParsedOmcOutput:
+    """Parse captured omc stdout into a ``ParsedOmcOutput``."""
+    m = _RECORD_RE.search(text)
+    preamble = text if not m else text[: m.start()]
+    error_notices = [mo.group(0).strip() for mo in _NOTICE_RE.finditer(preamble)]
+
+    if not m:
+        return ParsedOmcOutput(success=False, error_notices=error_notices)
+
+    body = m.group("body")
+
+    # Extract string-valued fields first (they may contain digits we don't
+    # want to misinterpret as timings).
+    str_fields: dict[str, str] = {}
+    for fm in _STR_FIELD_RE.finditer(body):
+        str_fields[fm.group(1)] = fm.group(2)
+
+    # Strip strings from the body before pulling numbers.
+    body_no_strings = _STR_FIELD_RE.sub("", body)
+    timings: dict[str, float] = {}
+    for fm in _NUM_FIELD_RE.finditer(body_no_strings):
+        name = fm.group(1)
+        if name in _TIMING_KEYS:
+            try:
+                timings[_TIMING_KEYS[name]] = float(fm.group(2))
+            except ValueError:
+                pass
+
+    result_file = str_fields.get("resultFile", "")
+    messages = str_fields.get("messages", "")
+
+    success = bool(result_file) and "Failed" not in messages
+
+    return ParsedOmcOutput(
+        success=success,
+        result_file=result_file,
+        messages=messages,
+        timings=timings or None,
+        error_notices=error_notices,
+    )

dstf/backends/openmodelica/mos_generator.py

@@ -0,0 +1,228 @@
+"""Pure-text builders for OpenModelica .mos scripts.
+
+No I/O beyond string assembly — trivially unit-testable. The backend calls
+:func:`build_simulate_mos` per test, writes the result to
+``<test_dir>/simulate.mos``, then invokes ``omc`` on it.
+
+The .mos does NOT emit explicit timing output. When ``omc`` runs a script
+non-interactively it REPL-echoes the top-level ``simulate(...)`` call as a
+``record SimulationResult ... end SimulationResult;`` block that already
+contains ``resultFile``, ``messages``, and the ``timeFrontend / Backend /
+SimCode / Templates / Compile / Simulation / Total`` fields — everything we
+need. ``log_parser.parse_omc_stdout`` pulls them from that block, so the
+.mos stays small and the print/sentinel dance proved to be silently
+unreliable (``res`` isn't in scope for the follow-up prints).
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable
+from pathlib import Path
+
+from ...discovery.library_state import dependency_file
+from ...discovery.test_registry import TestModel
+from ...discovery.unit_tests import unit_test_variables
+from ..common.result_variables import criterion_variables
+from ..types import _pattern_to_regex
+
+
+def classify_dependency(entry: str) -> tuple[str, str]:
+    """Classify a Config.dependencies entry as loadModel vs loadFile.
+
+    Returns (``"loadModel"``, name) for bare library names (no path
+    separators, doesn't look like a file), or (``"loadFile"``,
+    absolute_path) for path-like entries (resolves to a package.mo).
+
+    Bare names reach this function unresolved because Config's dependency
+    absolutization skips them — review 2026-07-06 finding 17: absolutizing
+    "Modelica" produced ``loadFile()`` on a nonexistent path and suppressed
+    the MSL auto-injection.
+    """
+    # Path-like if it contains a separator, ends in .mo, or starts with a
+    # relative-path/home prefix (mirrors config._dependency_looks_like_path).
+    looks_like_path = (
+        "/" in entry
+        or "\\" in entry
+        or entry.endswith(".mo")
+        or entry.startswith(".")
+        or entry.startswith("~")
+    )
+    if not looks_like_path:
+        return ("loadModel", entry)
+
+    # The file it is loaded by: itself, or its directory's package.mo.
+    return ("loadFile", str(dependency_file(entry)).replace("\\", "/"))
+
+
+def build_variable_filter(
+    patterns: Iterable[str],
+    diagnostic_vars: Iterable[str],
+    extra_names: Iterable[str] = (),
+) -> str:
+    """Build OM's ``variableFilter`` regex for the given tracked-variable set.
+
+    OM's ``variableFilter`` is a regex over variable names. We escape each
+    name literally and join with ``|``. ``time`` is always included; so are
+    the diagnostic variables and any ``extra_names`` the caller passes (the
+    UnitTests component's ``<instance>.x[1..N]`` for unit_tests-sourced
+    tests). Returning a regex (not ``.*``) keeps the .mat small — OM dumps
+    all parameters/aliases/derivatives by default.
+    """
+    alternatives: list[str] = []
+    # Always include time
+    alternatives.append(re.escape("time"))
+    # Tracked variables: expand globs (*, ?) to regex via the framework's
+    # existing glob-to-regex helper, so a pattern like ``pipe.T*`` becomes
+    # ``pipe\.T.*`` and the filter actually matches the runtime variable
+    # names (post-simulation ``resolve_variable_patterns`` still narrows
+    # the set for the pass/fail comparison).
+    for pat in patterns:
+        alternatives.append(_pattern_to_regex(pat).pattern)
+    # Extra literal names (no globs). build_simulate_args uses this for the
+    # UnitTests component's variables (``<instance>.x[i]``), which the spec
+    # doesn't list, and for the variables a criterion names.
+    for n in extra_names:
+        alternatives.append(re.escape(n))
+    # Diagnostic variables (literal names — no globs)
+    for dv in diagnostic_vars:
+        alternatives.append(re.escape(dv))
+    # Dedupe while preserving order
+    seen: set[str] = set()
+    unique: list[str] = []
+    for a in alternatives:
+        if a not in seen:
+            seen.add(a)
+            unique.append(a)
+    # OM's variableFilter is a POSIX ERE applied with partial-match semantics
+    # by default — an unanchored alternation would over-match (e.g. "x" would
+    # hit "phi" or "x_derivative"). Anchor with ^(...)$ to force whole-name
+    # match.
+    return "^(" + "|".join(unique) + ")$"
+
+
+def _format_sim_kwarg(key: str, value) -> str:
+    """Render one key=value for OM's simulate() call."""
+    if isinstance(value, str):
+        # OM escape: double-quote and escape backslashes + quotes
+        escaped = value.replace("\\", "\\\\").replace('"', '\\"')
+        return f'{key}="{escaped}"'
+    if isinstance(value, bool):
+        return f"{key}={'true' if value else 'false'}"
+    if isinstance(value, float):
+        # Avoid scientific notation for integer-valued floats, use repr otherwise.
+        if value == int(value):
+            return f"{key}={value!r}"
+        return f"{key}={value!r}"
+    return f"{key}={value!r}"
+
+
+def build_simulate_args(
+    test: TestModel,
+    diagnostic_vars: Iterable[str],
+    *,
+    mat_sync: bool = False,
+) -> list[str]:
+    """Build the ``key=value`` strings for an OM ``simulate(...)`` call.
+
+    Pure string assembly; used both by :func:`build_simulate_mos` (batch
+    path) and by the persistent-worker backend, which passes the same args
+    to ``session.sendExpression("simulate(<model>, <args>)")``.
+
+    OM's ``simulate()`` has ``numberOfIntervals`` but not ``outputInterval``
+    (Dymola's ``simulateModel`` has the latter), so we convert
+    ``output_interval`` → ``numberOfIntervals`` when that's what the test
+    specified. Solver names are lowercased here so a framework-wide
+    Dymola-style ``"Dassl"`` survives the crossing.
+
+    ``mat_sync`` adds ``simflags="-mat_sync=1"``: the simulation executable
+    then writes each output row to the result file as it is produced, where
+    it otherwise leaves them in a buffer until a block is full. A run that
+    is watched (``Config.live_results``) asks for it; no other run does, so
+    with it off the arguments are exactly what they were before it existed.
+    """
+    diagnostic_vars = list(diagnostic_vars)  # read twice below
+    args: list[str] = []
+    args.append(f"stopTime={float(test.stop_time)!r}")
+    if test.number_of_intervals is not None:
+        args.append(f"numberOfIntervals={int(test.number_of_intervals)}")
+    elif test.output_interval is not None and test.output_interval > 0:
+        n_intervals = max(
+            1, int(round(float(test.stop_time) / float(test.output_interval)))
+        )
+        args.append(f"numberOfIntervals={n_intervals}")
+    args.append(f"tolerance={float(test.tolerance)!r}")
+    args.append(_format_sim_kwarg("method", (test.method or "dassl").lower()))
+    args.append('outputFormat="mat"')
+    args.append('fileNamePrefix="result"')
+    var_filter = build_variable_filter(
+        test.variable_patterns,
+        diagnostic_vars,
+        # The UnitTests component's variables are in no spec pattern: both
+        # OM backends would otherwise filter them out of the .mat. Naming
+        # them here is what keeps the two paths saying the same thing. The
+        # variables a criterion names follow them (tracked because scored).
+        extra_names=[
+            *(v.name for v in unit_test_variables(test)),
+            *criterion_variables(test, diagnostic_vars),
+        ],
+    )
+    args.append(_format_sim_kwarg("variableFilter", var_filter))
+    if mat_sync:
+        args.append(_format_sim_kwarg("simflags", "-mat_sync=1"))
+    return args
+
+
+def build_simulate_mos(
+    *,
+    test: TestModel,
+    test_dir: Path,
+    library_package_mo: Path,
+    dependencies: list[str],
+    backend_setup: list[str],
+    diagnostic_vars: list[str],
+    std_version: str = "latest",
+    mat_sync: bool = False,
+) -> str:
+    """Assemble the full per-test .mos script.
+
+    See the module docstring for the shape. All path arguments are emitted
+    with forward slashes (OM accepts them on Windows too, and it sidesteps
+    Modelica string-escaping of backslashes).
+    """
+
+    def fwd(path: Path) -> str:
+        return str(path).replace("\\", "/")
+
+    lines: list[str] = []
+    lines.append(f'setCommandLineOptions("--std={std_version}");')
+
+    for dep in dependencies:
+        kind, arg = classify_dependency(dep)
+        if kind == "loadModel":
+            lines.append(f"loadModel({arg});")
+        else:
+            lines.append(f'loadFile("{arg}");')
+        lines.append("getErrorString();")
+
+    # Main library
+    lines.append(f'loadFile("{fwd(library_package_mo)}");')
+    lines.append("getErrorString();")
+
+    # Setup commands (backend-specific; user owns these)
+    for cmd in backend_setup:
+        c = cmd.strip()
+        if not c.endswith(";"):
+            c = c + ";"
+        lines.append(c)
+
+    lines.append(f'cd("{fwd(test_dir)}");')
+
+    sim_args = build_simulate_args(test, diagnostic_vars, mat_sync=mat_sync)
+    # Bare simulate(...) — omc REPL-echoes the SimulationResult record to
+    # stdout, which log_parser parses. No ``res := ...`` assignment and no
+    # follow-up prints (see module docstring).
+    lines.append(f"simulate({test.model_id}, {', '.join(sim_args)});")
+    lines.append("getErrorString();")
+
+    return "\n".join(lines) + "\n"