pySimBlocks 0.1.0__py3-none-any.whl

pySimBlocks/project/generate_run_script.py

@@ -0,0 +1,109 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pathlib import Path
+
+
+RUN_TEMPLATE = """\
+from pathlib import Path
+from pySimBlocks.project import load_simulator_from_project
+from pySimBlocks.project.plot_from_config import plot_from_config
+
+try:
+    BASE_DIR = Path(__file__).parent.resolve()
+except Exception:
+    BASE_DIR = Path("")
+
+sim, plot_cfg = load_simulator_from_project(BASE_DIR / {project_path!r})
+
+logs = sim.run()
+if {enable_plots} and plot_cfg is not None:
+    plot_from_config(logs, plot_cfg)
+"""
+
+def generate_python_content(
+    project_yaml_path: str,
+    enable_plots: bool = True,
+) -> str:
+    return RUN_TEMPLATE.format(
+        project_path=project_yaml_path,
+        enable_plots=enable_plots,
+    )
+
+
+
+def generate_run_script(
+    *,
+    project_dir: Path | None = None,
+    project_yaml: Path | None = None,
+    output: Path | None = None,
+) -> None:
+    """
+    Generate a canonical run.py script for a pySimBlocks project.
+
+    Exactly one of the following modes must be used:
+      - project_dir (project.yaml expected)
+      - project_yaml
+
+    Parameters
+    ----------
+    project_dir : Path, optional
+        Path to a project folder containing project.yaml.
+
+    project_yaml : Path, optional
+        Path to project.yaml (explicit unified mode).
+
+    output : Path, optional
+        Output run.py path (default: <project_dir>/run.py).
+    """
+
+    has_project_yaml_mode = project_yaml is not None
+
+    if project_dir and has_project_yaml_mode:
+        raise ValueError(
+            "Cannot use project_dir with project_yaml."
+        )
+
+    if not project_dir and not has_project_yaml_mode:
+        raise ValueError(
+            "You must specify one mode: project_dir or project_yaml."
+        )
+
+    # Unified project_dir mode
+    if project_dir:
+        project_dir = Path(project_dir)
+        project_yaml = project_dir / "project.yaml"
+        output = output or (project_dir / "run.py")
+        if not project_yaml.exists():
+            raise FileNotFoundError(f"project.yaml not found: {project_yaml}")
+
+        content = generate_python_content(project_yaml_path=project_yaml.name)
+
+    # Unified explicit project_yaml mode
+    elif has_project_yaml_mode:
+        project_yaml = Path(project_yaml)
+        output = Path(output or "run.py")
+        if not project_yaml.exists():
+            raise FileNotFoundError(f"project.yaml not found: {project_yaml}")
+
+        content = generate_python_content(project_yaml_path=str(project_yaml))
+
+    output.write_text(content)
+    print(f"[pySimBlocks] run script generated: {output}")

pySimBlocks/project/generate_sofa_controller.py

@@ -0,0 +1,215 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+import importlib.util
+import inspect
+import os
+import re
+import sys
+from multiprocessing import Pipe, Process
+from pathlib import Path
+
+import yaml
+
+
+def _load_scene_in_subprocess(scene_path, conn):
+    """
+    Load SOFA scene in subprocess and return controller file path.
+    """
+    try:
+        scene_path = Path(scene_path).resolve()
+        scene_dir = scene_path.parent
+        if str(scene_dir) not in sys.path:
+            sys.path.insert(0, str(scene_dir))
+
+        spec = importlib.util.spec_from_file_location("scene", scene_path)
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+
+        import Sofa
+        root = Sofa.Core.Node("root")
+
+        out = mod.createScene(root)
+        if not isinstance(out, (list, tuple)) or len(out) < 2:
+            conn.send(None)
+            return
+
+        controller = out[1]
+        controller_file = inspect.getsourcefile(controller.__class__)
+        conn.send(controller_file)
+
+    except Exception as e:
+        print(f"Error {e}")
+        conn.send(None)
+
+    finally:
+        conn.close()
+
+
+def detect_controller_file_from_scene(scene_file: Path) -> Path:
+    """
+    Automatically get controller path from scene.
+    """
+    parent_conn, child_conn = Pipe()
+    p = Process(target=_load_scene_in_subprocess, args=(scene_file, child_conn))
+    p.start()
+    try:
+        controller_path = parent_conn.recv()
+    except EOFError:
+        controller_path = None
+    p.join()
+
+    if controller_path is None:
+        raise RuntimeError(
+            f"Unable to determine controller file from scene {scene_file}. "
+            "Ensure createScene(root) returns (root, controller)."
+        )
+    return Path(controller_path)
+
+
+def inject_base_dir(src: str) -> str:
+    if "BASE_DIR = Path(__file__).resolve().parent" in src:
+        return src
+
+    injection = (
+        "from pathlib import Path\n\n"
+        "BASE_DIR = Path(__file__).resolve().parent\n\n"
+    )
+
+    import_block = list(re.finditer(r"^(import|from)\s+.+$", src, re.MULTILINE))
+    if import_block:
+        last = import_block[-1]
+        insert_at = last.end()
+        return src[:insert_at] + "\n\n" + injection + src[insert_at:]
+
+    return injection + src
+
+
+def inject_project_path_into_controller(
+    controller_file: Path,
+    project_yaml: Path,
+) -> None:
+    """
+    Inject or replace project_yaml attribute inside SofaPysimBlocksController __init__.
+    """
+    src = controller_file.read_text()
+    src = inject_base_dir(src)
+
+    controller_dir = controller_file.parent
+    project_yaml = project_yaml.resolve()
+
+    try:
+        rel_project = Path(os.path.relpath(project_yaml, controller_dir))
+        project_expr = f"(BASE_DIR / {rel_project.as_posix()!r}).resolve()"
+    except ValueError:
+        project_expr = f"Path({project_yaml.as_posix()!r}).resolve()"
+
+    expr = f"self.project_yaml = str({project_expr})"
+
+    pattern = r"self\.project_yaml\s*=.*"
+    if re.search(pattern, src):
+        src = re.sub(pattern, expr, src)
+    else:
+        src = src.replace(
+            "super().__init__(name=name)",
+            f"super().__init__(name=name)\n        {expr}",
+        )
+
+    controller_file.write_text(src)
+
+
+def _load_project_yaml(project_yaml: Path) -> dict:
+    if not project_yaml.exists():
+        raise FileNotFoundError(f"project.yaml not found: {project_yaml}")
+
+    raw = yaml.safe_load(project_yaml.read_text()) or {}
+    if not isinstance(raw, dict):
+        raise ValueError("project.yaml must define a YAML mapping")
+    return raw
+
+
+def _find_sofa_block(raw_project: dict) -> dict:
+    diagram = raw_project.get("diagram", {})
+    if not isinstance(diagram, dict):
+        raise ValueError("'diagram' section must be a mapping")
+
+    blocks = diagram.get("blocks", [])
+    if not isinstance(blocks, list):
+        raise ValueError("'diagram.blocks' section must be a list")
+
+    sofa_block = next(
+        (
+            b
+            for b in blocks
+            if isinstance(b, dict)
+            and str(b.get("type", "")).lower() in ("sofa_plant", "sofa_exchange_i_o")
+        ),
+        None,
+    )
+    if sofa_block is None:
+        raise RuntimeError(
+            "No SofaPlant or SofaExchangeIO block found in project.yaml"
+        )
+    return sofa_block
+
+
+def _resolve_scene_file(project_yaml: Path, sofa_block: dict) -> Path:
+    params = sofa_block.get("parameters", {})
+    if not isinstance(params, dict):
+        raise ValueError(
+            f"'diagram.blocks[{sofa_block.get('name', '?')}].parameters' must be a mapping"
+        )
+
+    scene_file = params.get("scene_file", None)
+    if not isinstance(scene_file, str) or not scene_file:
+        raise KeyError(
+            f"'scene_file' must be defined in parameters for block '{sofa_block.get('name', '?')}'"
+        )
+
+    path = Path(scene_file).expanduser()
+    if not path.is_absolute():
+        path = (project_yaml.parent / path).resolve()
+    return path
+
+
+def generate_sofa_controller(
+    project_dir: Path | None = None,
+    project_yaml: Path | None = None,
+) -> None:
+    has_project_path = project_yaml is not None
+
+    if project_dir and has_project_path:
+        raise ValueError("Cannot use project_dir together with project_yaml.")
+
+    if not project_dir and not has_project_path:
+        raise ValueError("You must specify either project_dir or project_yaml.")
+
+    if project_dir:
+        project_yaml = Path(project_dir).resolve() / "project.yaml"
+    else:
+        project_yaml = Path(project_yaml).resolve()
+
+    raw_project = _load_project_yaml(project_yaml)
+    sofa_block = _find_sofa_block(raw_project)
+    scene_file = _resolve_scene_file(project_yaml, sofa_block)
+    controller_file = detect_controller_file_from_scene(scene_file)
+
+    inject_project_path_into_controller(controller_file, project_yaml)
+    print(f"[pySimBlocks] SOFA controller updated: {controller_file}")

pySimBlocks/project/load_project_config.py

@@ -0,0 +1,197 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+from pathlib import Path
+from typing import Any, Dict, Tuple
+
+from pySimBlocks.core.config import PlotConfig, SimulationConfig
+from pySimBlocks.project.load_simulation_config import (
+    _check_no_external_refs,
+    _load_external_module,
+    _load_yaml,
+    _resolve_external_refs,
+    eval_recursive,
+)
+
+
+def _validate_schema_version(raw: Dict[str, Any]) -> None:
+    schema_version = raw.get("schema_version", None)
+    if schema_version != 1:
+        raise ValueError(
+            f"Unsupported or missing 'schema_version': {schema_version!r}. "
+            "Expected: 1"
+        )
+
+
+def _load_scope(raw: Dict[str, Any], project_yaml: Path) -> Tuple[Any, Dict[str, Any]]:
+    simulation = raw.get("simulation", {})
+    if not isinstance(simulation, dict):
+        raise ValueError("'simulation' section must be a mapping")
+
+    external_module_path = simulation.get("external_module", None)
+    if external_module_path is None:
+        _check_no_external_refs(raw)
+        return None, {}
+
+    if not isinstance(external_module_path, str):
+        raise ValueError("'simulation.external_module' must be a path to a Python file")
+
+    external_path = Path(external_module_path).expanduser()
+    if not external_path.is_absolute():
+        external_path = project_yaml.parent / external_path
+    external_module, scope = _load_external_module(external_path)
+    return external_module, scope
+
+
+def _build_plot_config(sim_data: Dict[str, Any]) -> PlotConfig | None:
+    plots_data = sim_data.get("plots", None)
+    if plots_data is None:
+        return None
+
+    if not isinstance(plots_data, list):
+        raise ValueError("'simulation.plots' section must be a list")
+
+    plot_cfg = PlotConfig(plots=plots_data)
+    plot_cfg.validate()
+    return plot_cfg
+
+
+def _adapt_diagram_to_model_dict(
+    diagram_data: Dict[str, Any],
+    scope: Dict[str, Any],
+) -> Dict[str, Any]:
+    blocks = diagram_data.get("blocks", [])
+    if not isinstance(blocks, list):
+        raise ValueError("'diagram.blocks' section must be a list")
+
+    model_blocks: list[dict[str, Any]] = []
+    for desc in blocks:
+        if not isinstance(desc, dict):
+            raise ValueError("Each block in 'diagram.blocks' must be a mapping")
+
+        name = desc.get("name")
+        category = desc.get("category")
+        block_type = desc.get("type")
+        if not isinstance(name, str) or not isinstance(category, str) or not isinstance(block_type, str):
+            raise ValueError(
+                "Each block in 'diagram.blocks' must define string fields: "
+                "'name', 'category', and 'type'"
+            )
+
+        params_raw = desc.get("parameters", {})
+        if not isinstance(params_raw, dict):
+            raise ValueError(
+                f"'diagram.blocks[{name}].parameters' must be a mapping"
+            )
+
+        model_blocks.append(
+            {
+                "name": name,
+                "category": category,
+                "type": block_type,
+                "parameters": eval_recursive(params_raw, scope),
+            }
+        )
+
+    connections_raw = diagram_data.get("connections", [])
+    if not isinstance(connections_raw, list):
+        raise ValueError("'diagram.connections' section must be a list")
+
+    model_connections: list[list[str]] = []
+    for conn in connections_raw:
+        if not isinstance(conn, dict):
+            raise ValueError("Each connection in 'diagram.connections' must be a mapping")
+
+        ports = conn.get("ports", None)
+        if not isinstance(ports, list) or len(ports) != 2:
+            raise ValueError(
+                "Each connection in 'diagram.connections' must define "
+                "'ports: [src, dst]'"
+            )
+
+        src, dst = ports
+        if not isinstance(src, str) or not isinstance(dst, str):
+            raise ValueError(
+                "Connection ports in 'diagram.connections' must be strings"
+            )
+        model_connections.append([src, dst])
+
+    return {
+        "blocks": model_blocks,
+        "connections": model_connections,
+    }
+
+
+def load_project_config(
+    project_yaml: str | Path,
+) -> Tuple[SimulationConfig, Dict[str, Any], PlotConfig | None, str, Path]:
+    """
+    Load a full pySimBlocks unified project.yaml configuration.
+
+    Returns:
+        (SimulationConfig, model_dict, PlotConfig | None, project_name, params_dir)
+    """
+    project_yaml = Path(project_yaml)
+    raw = _load_yaml(project_yaml)
+
+    _validate_schema_version(raw)
+
+    external_module, scope = _load_scope(raw, project_yaml)
+
+    resolved = _resolve_external_refs(raw, external_module) if external_module else raw
+
+    project_data = resolved.get("project", {})
+    if not isinstance(project_data, dict):
+        raise ValueError("'project' section must be a mapping")
+    project_name = project_data.get("name", "model")
+    if not isinstance(project_name, str) or not project_name.strip():
+        raise ValueError("'project.name' must be a non-empty string")
+
+    sim_data = resolved.get("simulation", {})
+    if not isinstance(sim_data, dict):
+        raise ValueError("'simulation' section must be a mapping")
+
+    required = {"dt", "T"}
+    missing = required - sim_data.keys()
+    if missing:
+        raise ValueError(
+            f"Missing required simulation parameters in 'simulation': {sorted(missing)}"
+        )
+
+    sim_eval_data = eval_recursive(sim_data, scope)
+    sim_cfg = SimulationConfig(
+        dt=sim_eval_data["dt"],
+        T=sim_eval_data["T"],
+        t0=sim_eval_data.get("t0", 0.0),
+        solver=sim_eval_data.get("solver", "fixed"),
+        logging=sim_data.get("logging", []),
+        clock=sim_eval_data.get("clock", "internal"),
+    )
+    sim_cfg.validate()
+
+    plot_cfg = _build_plot_config(sim_data)
+
+    diagram_data = resolved.get("diagram", {})
+    if not isinstance(diagram_data, dict):
+        raise ValueError("'diagram' section must be a mapping")
+
+    model_dict = _adapt_diagram_to_model_dict(diagram_data, scope)
+
+    return sim_cfg, model_dict, plot_cfg, project_name, project_yaml.parent.resolve()

pySimBlocks/project/load_simulation_config.py

@@ -0,0 +1,166 @@
+# ******************************************************************************
+#                                  pySimBlocks
+#                     Copyright (c) 2026 Université de Lille & INRIA
+# ******************************************************************************
+#  This program is free software: you can redistribute it and/or modify it
+#  under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  This program is distributed in the hope that it will be useful, but WITHOUT
+#  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+#  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
+#  for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with this program.  If not, see <https://www.gnu.org/licenses/>.
+# ******************************************************************************
+#  Authors: see Authors.txt
+# ******************************************************************************
+
+import importlib.util
+from pathlib import Path
+from typing import Dict, Any, Tuple
+import yaml
+import numpy as np
+import re
+from pySimBlocks.core.config import SimulationConfig
+
+# ---------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------
+def _load_yaml(path: Path) -> Dict[str, Any]:
+    if not path.exists():
+        raise FileNotFoundError(f"Project file not found: {path}")
+
+    with path.open("r") as f:
+        data = yaml.safe_load(f) or {}
+
+    if not isinstance(data, dict):
+        raise ValueError("project.yaml must define a YAML mapping")
+
+    return data
+
+
+
+############################################################
+# External variables
+############################################################
+def _load_external_module(path: Path):
+    if not path.exists():
+        raise FileNotFoundError(f"External parameters module not found: {path}")
+
+    spec = importlib.util.spec_from_file_location(path.stem, path)
+    module = importlib.util.module_from_spec(spec)
+
+    assert spec.loader is not None
+    spec.loader.exec_module(module)
+
+    return module, module.__dict__
+
+
+_EXTERNAL_REF_PATTERN = re.compile(r"#([A-Za-z_][A-Za-z0-9_]*)")
+def extract_external_refs(expr: str) -> set[str]:
+    """
+    Extract all external references (#var) from an expression string.
+    """
+    return set(_EXTERNAL_REF_PATTERN.findall(expr))
+
+
+def _resolve_external_refs(obj: Any, external_module) -> Any:
+    """
+    Recursively validate #var references using the external module.
+    Does NOT replace anything.
+    """
+    if isinstance(obj, str):
+        refs = extract_external_refs(obj)
+        for name in refs:
+            if not hasattr(external_module, name):
+                raise KeyError(
+                    f"External parameter '{name}' not found "
+                    f"in module '{external_module.__file__}'"
+                )
+        return obj
+
+    if isinstance(obj, list):
+        return [_resolve_external_refs(v, external_module) for v in obj]
+
+    if isinstance(obj, dict):
+        return {
+            k: _resolve_external_refs(v, external_module)
+            for k, v in obj.items()
+        }
+
+    return obj
+
+def _check_no_external_refs(obj):
+    if isinstance(obj, str):
+        refs = extract_external_refs(obj)
+        if refs:
+            raise ValueError(
+                f"Found external references {sorted(refs)} "
+                "but no external module is defined"
+            )
+
+    elif isinstance(obj, list):
+        for v in obj:
+            _check_no_external_refs(v)
+
+    elif isinstance(obj, dict):
+        for v in obj.values():
+            _check_no_external_refs(v)
+
+
+
+############################################################
+# EVAL
+############################################################
+def eval_value(value: Any, scope: dict):
+    """
+    Try to evaluate ANY value as a Python expression.
+
+    Rules:
+    - value is first converted to string
+    - '#' is stripped (used as internal keyword)
+    - lists are wrapped into np.array
+    - eval is attempted with a restricted namespace
+    - if eval fails -> return original value
+    """
+
+    try:
+        expr = str(value)
+        expr = expr.replace("#", "")
+        expr = re.sub(r'(?<!np\.array)\[', 'np.array([', expr)
+        expr = re.sub(r'\]', '])', expr)
+        return eval(expr, {"np": np}, scope)
+    except Exception:
+        return value
+
+
+def eval_recursive(obj: Any, scope: dict):
+    if isinstance(obj, dict):
+        return {k: eval_recursive(v, scope) for k, v in obj.items()}
+
+    if isinstance(obj, list):
+        return [eval_recursive(v, scope) for v in obj]
+
+    return eval_value(obj, scope)
+
+# ---------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------
+def load_simulation_config(
+    project_yaml: str | Path,
+) -> Tuple[SimulationConfig, Dict[str, Any], Path]:
+    """
+    Load simulation and diagram configuration from unified project.yaml.
+
+    Returns:
+        (SimulationConfig, model_dict, params_dir)
+    """
+    from pySimBlocks.project.load_project_config import load_project_config
+
+    sim_cfg, model_dict, _plot_cfg, _project_name, params_dir = load_project_config(
+        project_yaml
+    )
+    return sim_cfg, model_dict, params_dir