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

dstf/backends/dymola/interface_loader.py

@@ -0,0 +1,241 @@
+"""Locate and load Dymola's Python interface (DymolaInterface).
+
+Dymola ships its Python integration under
+  <Dymola>/Modelica/Library/python_interface/
+as either `dymola.egg` (older) or `dymola-<version>-py3-none-any.whl` (newer).
+
+Both are zip archives. `.egg` is directly importable via Python's zipimport by
+appending to `sys.path`. `.whl` is not — Python only imports `.whl` content
+after `pip install` extracts it. To avoid a per-Dymola-version install step,
+we extract the wheel once to a user cache dir and add that dir to `sys.path`.
+
+Discovery order:
+  1. Explicit path (CLI flag / config `dymola_interface_path`)
+  2. `DYMOLA_INTERFACE_PATH` env var
+  3. Standard locations per platform (globs all Dymola versions)
+
+The explicit path may be either the archive itself or the directory containing
+it (we look inside).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import sys
+import zipfile
+from pathlib import Path
+
+
+def _dymola_sort_key(path: Path) -> tuple:
+    """Sort Dymola install paths so newer versions come first.
+
+    Extracts the year/refresh from names like 'Dymola 2026x' or
+    'Dymola 2024x Refresh 1' and sorts descending.
+    """
+    name = str(path)
+    m = re.search(
+        r"Dymola[\s_]?(\d{4})x(?:[\s_]+Refresh[\s_]*(\d+))?", name, re.IGNORECASE
+    )
+    if not m:
+        return (0, 0, name)
+    year = int(m.group(1))
+    refresh = int(m.group(2)) if m.group(2) else 0
+    # Negate for descending sort
+    return (-year, -refresh, name)
+
+
+def _platform_glob_bases() -> list[Path]:
+    """Base directories to glob for installed Dymola versions."""
+    if sys.platform.startswith("win"):
+        candidates = [
+            Path(r"C:\Program Files"),
+            Path(r"C:\Program Files (x86)"),
+        ]
+    elif sys.platform == "darwin":
+        candidates = [Path("/Applications")]
+    else:
+        candidates = [Path("/opt"), Path("/usr/local")]
+    return [p for p in candidates if p.exists()]
+
+
+def _find_python_interface_dirs() -> list[Path]:
+    """Return all known python_interface directories, newest-first."""
+    found: list[Path] = []
+    for base in _platform_glob_bases():
+        for p in base.glob("Dymola*/Modelica/Library/python_interface"):
+            if p.is_dir():
+                found.append(p)
+        # Linux convention
+        for p in base.glob("dymola*/Modelica/Library/python_interface"):
+            if p.is_dir():
+                found.append(p)
+    found.sort(key=_dymola_sort_key)
+    return found
+
+
+def _archive_in_dir(d: Path) -> Path | None:
+    """Find a dymola .whl or .egg inside a python_interface directory."""
+    wheels = sorted(d.glob("dymola-*.whl"), reverse=True)
+    if wheels:
+        return wheels[0]
+    egg = d / "dymola.egg"
+    if egg.exists():
+        return egg
+    eggs = sorted(d.glob("dymola*.egg"), reverse=True)
+    if eggs:
+        return eggs[0]
+    return None
+
+
+def find_dymola_interface_archive(
+    override: Path | None = None,
+) -> Path | None:
+    """Find the Dymola Python interface archive. Returns the Path or None.
+
+    Accepts either a direct archive path or a directory containing one.
+    """
+    explicit_candidates: list[Path] = []
+    if override:
+        explicit_candidates.append(Path(override))
+    env = os.environ.get("DYMOLA_INTERFACE_PATH")
+    if env:
+        explicit_candidates.append(Path(env))
+
+    for cand in explicit_candidates:
+        if cand.is_file() and cand.suffix in (".whl", ".egg"):
+            return cand
+        if cand.is_dir():
+            a = _archive_in_dir(cand)
+            if a:
+                return a
+
+    # Auto-discovery
+    for d in _find_python_interface_dirs():
+        a = _archive_in_dir(d)
+        if a:
+            return a
+    return None
+
+
+def _cache_root() -> Path:
+    """User cache directory for extracted wheels."""
+    if sys.platform.startswith("win"):
+        root = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+    else:
+        root = Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache"))
+    return root / "dstf" / "dymola-interface"
+
+
+def _cache_signature(archive: Path) -> str:
+    """Signature stored in the cache marker so we can invalidate stale or
+    corrupt extractions. Pairs source archive size + mtime — cheap to compute,
+    catches both wheel updates (Dymola refresh) and partial/interrupted
+    extractions that left bogus content (a 32-byte stub `dymola_interface.py`
+    actually shipped in our cache once; the touch-only marker happily reused
+    it). If the wheel is replaced byte-for-byte the mtime still changes, so
+    this is conservative-correct without needing a hash.
+    """
+    st = archive.stat()
+    return f"{archive}|{st.st_size}|{st.st_mtime_ns}"
+
+
+def _prepare_sys_path(archive: Path) -> Path:
+    """Make `import dymola` work. Returns the path added to sys.path."""
+    if archive.suffix == ".egg":
+        # zipimport supports .egg directly
+        entry = str(archive)
+    else:
+        # Extract .whl to cache once, then add the extract dir.
+        extract_dir = _cache_root() / archive.stem
+        marker = extract_dir / ".extracted"
+        signature = _cache_signature(archive)
+        cached_signature = marker.read_text() if marker.exists() else None
+        if cached_signature != signature:
+            # Wipe and re-extract on first use OR on signature drift (wheel
+            # updated, mtime changed, prior extraction corrupted).
+            if extract_dir.exists():
+                shutil.rmtree(extract_dir)
+            extract_dir.mkdir(parents=True, exist_ok=True)
+            with zipfile.ZipFile(archive) as z:
+                z.extractall(extract_dir)
+            marker.write_text(signature)
+        entry = str(extract_dir)
+    if entry not in sys.path:
+        sys.path.insert(0, entry)
+    return Path(entry)
+
+
+_NOT_FOUND_MESSAGE = """\
+Could not find Dymola's Python interface (dymola.egg or dymola-*.whl).
+
+Searched:
+  - Explicit --dymola-interface / dymola_interface_path
+  - DYMOLA_INTERFACE_PATH env var
+  - Auto-discovery under platform install roots:
+    {bases}
+
+Typical location (Windows):
+  C:\\Program Files\\Dymola 2026x\\Modelica\\Library\\python_interface\\dymola-2026.0-py3-none-any.whl
+
+Fix one of:
+  1. Pass --dymola-interface <path-to-archive-or-dir>
+  2. Set environment variable DYMOLA_INTERFACE_PATH
+"""
+
+
+_cached_class = None
+_cached_path: Path | None = None
+
+
+def load_dymola_interface(override_path: Path | None = None):
+    """Load and return the DymolaInterface class. Cached after first call."""
+    global _cached_class, _cached_path
+    if _cached_class is not None:
+        return _cached_class
+    archive = find_dymola_interface_archive(override_path)
+    if archive is None:
+        bases = "\n    ".join(str(b) for b in _platform_glob_bases())
+        raise RuntimeError(_NOT_FOUND_MESSAGE.format(bases=bases or "(none)"))
+    _cached_path = _prepare_sys_path(archive)
+    try:
+        from dymola.dymola_interface import (
+            DymolaInterface,  # type: ignore[import-not-found]
+        )
+    except ImportError as e:
+        raise RuntimeError(
+            f"Found Dymola interface archive at {archive}, but `import dymola` failed: {e}\n"
+            f"The archive may be incomplete or incompatible with this Python "
+            f"({sys.version.split()[0]})."
+        ) from e
+    _cached_class = DymolaInterface
+    return DymolaInterface
+
+
+def describe_dymola_interface(override_path: Path | None = None) -> dict:
+    """Run the loader in a reporting mode — no raises. Useful for diagnostics."""
+    archive = find_dymola_interface_archive(override_path)
+    info: dict = {
+        "archive": str(archive) if archive else None,
+        "format": archive.suffix.lstrip(".") if archive else None,
+        "search_roots": [str(b) for b in _platform_glob_bases()],
+        "discovered_dirs": [str(p) for p in _find_python_interface_dirs()],
+        "sys_path_entry": None,
+        "import_ok": False,
+        "error": None,
+    }
+    if archive is None:
+        info["error"] = "No archive found"
+        return info
+    try:
+        info["sys_path_entry"] = str(_prepare_sys_path(archive))
+        from dymola.dymola_interface import (
+            DymolaInterface,  # type: ignore[import-not-found]
+        )
+
+        info["import_ok"] = True
+        info["dymola_interface_module"] = DymolaInterface.__module__
+    except Exception as e:  # pragma: no cover — diagnostic helper
+        info["error"] = f"{type(e).__name__}: {e}"
+    return info

dstf/backends/dymola/log_parser.py

@@ -0,0 +1,396 @@
+"""Parse Dymola's dslog.txt and translation_log.txt for statistics."""
+
+import re
+import sys
+from pathlib import Path
+
+from ..common.statistics import summaries
+
+
+def parse_dslog(path: Path) -> dict | None:
+    """Parse a Dymola log file and extract all available statistics.
+
+    Works with both dslog.txt (simulation runtime stats) and
+    translation_log.txt (translation/structural stats).
+
+    Returns a dict with sub-dicts for different stat categories,
+    or None if the file cannot be read or has no stats.
+    """
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return None
+
+    stats = {}
+
+    # --- Translation statistics (from translation_log.txt) ---
+    _parse_translation_stats(text, stats)
+
+    # --- Simulation runtime statistics (from dslog.txt) ---
+    _parse_simulation_stats(text, stats)
+
+    return stats if stats else None
+
+
+def parse_test_logs(test_dir: Path) -> dict | None:
+    """The statistics of the two logs Dymola leaves in a test's directory,
+    merged: ``dslog.txt`` (``simulation.*``) and ``translation_log.txt``
+    (``translation.*``). ``None`` when neither holds any.
+
+    The one reader of both — the batch run, the persistent worker's disk
+    read and :meth:`DymolaBackend.read_result`'s fallback all call it, so
+    the merge cannot differ between a run and a later reload.
+
+    A log that does not parse costs this test that log's statistics and
+    one ``# WARN:`` line naming the file: its number that is no number
+    (``1.2.3 s``) must not abort the read of the suite.
+    """
+    statistics = _parse_or_warn(test_dir / "dslog.txt")
+    translation_stats = _parse_or_warn(test_dir / "translation_log.txt")
+    if not translation_stats:
+        return statistics
+    if statistics is None:
+        return translation_stats
+    # Each log produces different top-level keys (dslog -> "simulation",
+    # translation -> "translation"); a shared category merges key by key.
+    for key, value in translation_stats.items():
+        if isinstance(value, dict) and isinstance(statistics.get(key), dict):
+            statistics[key].update(value)
+        else:
+            statistics[key] = value
+    return statistics
+
+
+def _parse_or_warn(path: Path) -> dict | None:
+    """:func:`parse_dslog`, or None with a warning when the log's text
+    breaks the parse. A log is data a simulator wrote, so an error its text
+    raises is that file's, not the read's — and the only one it can raise
+    is a ValueError (``int`` / ``float`` over a matched number: ``1.2.3``,
+    or past ``int``'s digit limit on 3.11+). Anything else is the parser's
+    own bug, and propagates."""
+    try:
+        return parse_dslog(path)
+    except ValueError as exc:
+        print(
+            f"# WARN: could not parse {path}: {type(exc).__name__}: {exc}",
+            file=sys.stderr,
+        )
+        return None
+
+
+def _parse_translation_stats(text: str, stats: dict) -> None:
+    """Extract translation statistics from a Dymola log."""
+
+    # DAE size
+    m = re.search(r"The DAE has (\d+) scalar unknowns and (\d+) scalar equations", text)
+    if m:
+        stats.setdefault("translation", {})
+        stats["translation"]["scalar_unknowns"] = int(m.group(1))
+        stats["translation"]["scalar_equations"] = int(m.group(2))
+
+    # Original Model section
+    orig = re.search(r"Original Model\s*\n((?:\s+.+\n)+)", text)
+    if orig:
+        orig_text = orig.group(1)
+        _extract_int(
+            orig_text,
+            r"Number of components:\s*(\d+)",
+            stats,
+            "translation",
+            "original_components",
+        )
+        _extract_int(
+            orig_text, r"Variables:\s*(\d+)", stats, "translation", "original_variables"
+        )
+        _extract_int(
+            orig_text,
+            r"Unknowns:.*?(\d+)\s+scalars",
+            stats,
+            "translation",
+            "original_unknowns_scalars",
+        )
+        _extract_int(
+            orig_text,
+            r"Differentiated variables:\s*(\d+)",
+            stats,
+            "translation",
+            "differentiated_variables",
+        )
+        _extract_int(
+            orig_text, r"Equations:\s*(\d+)", stats, "translation", "original_equations"
+        )
+        _extract_int(
+            orig_text,
+            r"Nontrivial:\s*(\d+)",
+            stats,
+            "translation",
+            "nontrivial_equations",
+        )
+
+    # Translated Model section — need to separate simulation vs initialization
+    # The section structure is:
+    #   Translated Model
+    #     <simulation-level stats>
+    #     Initialization problem
+    #       <initialization-level stats>
+    trans_match = re.search(r"Translated Model\s*\n((?:\s+.+\n)+)", text)
+    if trans_match:
+        full_trans_text = trans_match.group(1)
+
+        # Split at "Initialization problem" if present
+        init_split = re.split(
+            r"^\s+Initialization problem\s*$", full_trans_text, flags=re.MULTILINE
+        )
+        sim_text = init_split[0]
+        init_text = init_split[1] if len(init_split) > 1 else ""
+
+        # --- Simulation-level translated model stats ---
+        _extract_int(sim_text, r"Constants:\s*(\d+)", stats, "translation", "constants")
+        _extract_int(
+            sim_text,
+            r"Free parameters:\s*(\d+)",
+            stats,
+            "translation",
+            "free_parameters",
+        )
+        _extract_int(
+            sim_text,
+            r"Parameter depending:\s*(\d+)",
+            stats,
+            "translation",
+            "parameter_depending",
+        )
+        _extract_int(sim_text, r"Outputs:\s*(\d+)", stats, "translation", "outputs")
+        _extract_int(
+            sim_text,
+            r"Continuous time states:\s*(\d+)",
+            stats,
+            "translation",
+            "continuous_time_states",
+        )
+        _extract_int(
+            sim_text,
+            r"Time-varying variables:\s*(\d+)",
+            stats,
+            "translation",
+            "time_varying_variables",
+        )
+        _extract_int(
+            sim_text,
+            r"Alias variables:\s*(\d+)",
+            stats,
+            "translation",
+            "alias_variables",
+        )
+        _extract_int(
+            sim_text,
+            r"Number of mixed real/discrete systems of equations:\s*(\d+)",
+            stats,
+            "translation",
+            "mixed_systems",
+        )
+        _extract_int(
+            sim_text,
+            r"Number of numerical Jacobians:\s*(\d+)",
+            stats,
+            "translation",
+            "numerical_jacobians",
+        )
+
+        # Simulation-level equation system sizes
+        _extract_system_sizes(sim_text, stats, "translation", prefix="")
+
+        # --- Initialization problem stats ---
+        if init_text:
+            _extract_int(
+                init_text,
+                r"Number of mixed real/discrete systems of equations:\s*(\d+)",
+                stats,
+                "translation",
+                "init_mixed_systems",
+            )
+            _extract_int(
+                init_text,
+                r"Number of numerical Jacobians:\s*(\d+)",
+                stats,
+                "translation",
+                "init_numerical_jacobians",
+            )
+
+            _extract_system_sizes(init_text, stats, "translation", prefix="init_")
+
+            # Homotopy nonlinear systems (initialization only)
+            _extract_system_pair(
+                init_text,
+                r"Sizes of simplified homotopy nonlinear systems of equations",
+                r"Sizes after manipulation of the simplified homotopy nonlinear systems",
+                stats,
+                "translation",
+                "init_homotopy_nonlinear",
+            )
+
+    # Continuous time states — fallback if not found in Translated Model section
+    if "translation" not in stats or "continuous_time_states" not in stats.get(
+        "translation", {}
+    ):
+        m = re.search(r"Continuous time states:\s*(\d+)", text)
+        if not m:
+            m = re.search(r"(\d+)\s+continuous time states", text)
+        if m:
+            stats.setdefault("translation", {})
+            stats["translation"]["continuous_time_states"] = int(m.group(1))
+
+    # Selected continuous time states (list of state variable names)
+    # Capture lines after "Statically selected continuous time states" that look
+    # like Modelica variable names (start with a letter, contain dots/brackets).
+    # Stop at "Dynamically selected", "Warning:", blank lines, or non-variable lines.
+    states_match = re.search(
+        r"Statically selected continuous time states\s*\n((?:(?!Dynamically|Warning|There are|From set|=)[a-zA-Z][\w.\[\], ]*\n)+)",
+        text,
+    )
+    if states_match:
+        state_names = [
+            line.strip()
+            for line in states_match.group(1).strip().split("\n")
+            if line.strip()
+        ]
+        if state_names:
+            stats.setdefault("translation", {})
+            stats["translation"]["state_names"] = state_names
+
+
+def _extract_system_sizes(
+    text: str,
+    stats: dict,
+    category: str,
+    prefix: str,
+) -> None:
+    """Extract nonlinear and linear system sizes from a log section.
+
+    Parses both original sizes and after-manipulation sizes, stores as
+    integer lists with summary fields (count, total, max).
+    """
+    for sys_type in ("nonlinear", "linear"):
+        # Original sizes
+        _extract_system_pair_simple(
+            text,
+            sys_type,
+            stats,
+            category,
+            f"{prefix}{sys_type}",
+        )
+
+
+def _extract_system_pair_simple(
+    text: str,
+    sys_type: str,
+    stats: dict,
+    category: str,
+    key_base: str,
+) -> None:
+    """Extract original + after-manipulation sizes for a system type."""
+    # Original sizes: "Sizes of <type> systems of equations: {N, N, ...}"
+    m = re.search(
+        rf"Sizes of {sys_type} systems of equations\s*:\s*\{{([^}}]*)\}}", text
+    )
+    if m:
+        values = _parse_int_list(m.group(1))
+        stats.setdefault(category, {})
+        stats[category][key_base] = values
+        stats[category].update(summaries(key_base, values))
+
+    # After manipulation: "Sizes after manipulation of the <type> systems: {N, N, ...}"
+    m = re.search(
+        rf"Sizes after manipulation of the {sys_type} systems\s*:\s*\{{([^}}]*)\}}",
+        text,
+    )
+    if m:
+        values = _parse_int_list(m.group(1))
+        key = f"{key_base}_after_manipulation"
+        stats.setdefault(category, {})
+        stats[category][key] = values
+        stats[category].update(summaries(key, values))
+
+
+def _extract_system_pair(
+    text: str,
+    original_pattern: str,
+    manipulation_pattern: str,
+    stats: dict,
+    category: str,
+    key_base: str,
+) -> None:
+    """Extract a pair of system size lists (original + after manipulation)."""
+    m = re.search(rf"{original_pattern}\s*:\s*\{{([^}}]*)\}}", text)
+    if m:
+        values = _parse_int_list(m.group(1))
+        stats.setdefault(category, {})
+        stats[category][key_base] = values
+        stats[category].update(summaries(key_base, values))
+
+    m = re.search(rf"{manipulation_pattern}\s*:\s*\{{([^}}]*)\}}", text)
+    if m:
+        values = _parse_int_list(m.group(1))
+        key = f"{key_base}_after_manipulation"
+        stats.setdefault(category, {})
+        stats[category][key] = values
+        stats[category].update(summaries(key, values))
+
+
+def _parse_simulation_stats(text: str, stats: dict) -> None:
+    """Extract simulation runtime statistics from a Dymola log."""
+
+    # CPU time for integration (from dslog — just the integration step,
+    # excludes init / output writing. Distinct from the `CPUtime` diagnostic
+    # variable's final value which covers the full simulation.)
+    m = re.search(
+        r"CPU-time for (?:integration|simulation)\s*[=:]\s*([\d.eE+\-]+)\s*s",
+        text,
+        re.IGNORECASE,
+    )
+    if m:
+        stats.setdefault("simulation", {})
+        stats["simulation"]["cpu_time_integration"] = float(m.group(1))
+
+    # All other simulation stats use the same pattern: label with possible
+    # whitespace padding before the colon
+    _SIM_PATTERNS = [
+        (r"Number of result points\s*:\s*(\d+)", "result_points"),
+        (r"Number of accepted steps\s*:\s*(\d+)", "accepted_steps"),
+        (r"Number of f-evaluations.*?:\s*(\d+)", "f_evaluations"),
+        (r"Number of Jacobian-evaluations\s*:\s*(\d+)", "jacobian_evaluations"),
+        (r"Number of state\s+events\s*:\s*(\d+)", "state_events"),
+        (r"Number of step\s+events\s*:\s*(\d+)", "step_events"),
+        (r"Number of model time events\s*:\s*(\d+)", "model_time_events"),
+        (r"Number of input time events\s*:\s*(\d+)", "input_time_events"),
+    ]
+
+    for pattern, key in _SIM_PATTERNS:
+        m = re.search(pattern, text)
+        if m:
+            stats.setdefault("simulation", {})
+            stats["simulation"][key] = int(m.group(1))
+
+
+def _extract_int(text: str, pattern: str, stats: dict, category: str, key: str) -> None:
+    """Extract an integer value and store it in stats[category][key]."""
+    m = re.search(pattern, text)
+    if m:
+        stats.setdefault(category, {})
+        stats[category][key] = int(m.group(1))
+
+
+def _parse_int_list(text: str) -> list[int]:
+    """Parse a comma-separated integer list from Dymola log.
+
+    Dymola formats these as e.g. '{7, 3, 1}' — we parse to a list of ints.
+    Returns empty list for empty/whitespace-only content (e.g., '{ }').
+    """
+    parts = [p.strip() for p in text.split(",") if p.strip()]
+    result = []
+    for p in parts:
+        try:
+            result.append(int(p))
+        except ValueError:
+            pass
+    return result