physioblocks 1.0.0__py3-none-any.whl

physioblocks/launcher/configuration.py

@@ -0,0 +1,231 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks 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, version 3 of the License.
+#
+# PhysioBlocks 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
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+import json
+import logging
+import shutil
+from pathlib import Path
+from typing import Any
+
+import physioblocks.library
+from physioblocks.io.aliases import load_aliases
+from physioblocks.launcher.constants import (
+    LAUNCHER_CONFIGURATION_ALIAS_ID,
+    LAUNCHER_CONFIGURATION_FILE_NAME,
+    LAUNCHER_CONFIGURATION_LIBRARIES_ID,
+    LAUNCHER_GITIGNORE_FILE_NAME,
+    LAUNCHER_LOG_FILE_NAME,
+    LAUNCHER_MODULE_INIT_FILE_NAME,
+    LAUNCHER_SERIES_DIR_NAME,
+    LAUNCHER_USER_ALIASES_DIR_NAME,
+    LAUNCHER_USER_LIBRARY_DIR_NAME,
+    PHYSIOBLOCKS_REFERENCES_PATH,
+)
+from physioblocks.launcher.series import SimulationInfo
+from physioblocks.utils.dynamic_import_utils import import_libraries
+
+_logger = logging.getLogger(__name__)
+
+
+def create_simulation_folder_path(series_path: Path, info: SimulationInfo) -> Path:
+    sim_folder_name = info.reference
+    simulation_folder_path = series_path / sim_folder_name
+    simulation_folder_path.mkdir()
+
+    return simulation_folder_path
+
+
+def check_target_launcher_directory(launcher_dir_path: Path) -> bool:
+    """
+    Check that the given directory is suitable to welcome a new launcher directory.
+
+    It should either not exist (and therefore it will be created) or
+    be an empty dir (to avoid erasing existing files)
+
+    :param launcher_dir_path: the directory path
+    :type launcher_dir_path: Path
+
+    :return: True if the launcher dir can be created at this location,
+      False otherwise
+    :rtype: boolean
+    """
+    return launcher_dir_path.exists() is False or (
+        launcher_dir_path.is_dir() and not any(launcher_dir_path.iterdir())
+    )
+
+
+def check_launcher_directory(launcher_dir_path: Path) -> bool:
+    """
+    Check that the given directory can launch a simulation.
+
+    :param launcher_dir_path: the directory path
+    :type launcher_dir_path: Path
+
+    :return: True if a simulation can be launched at this location, False otherwise
+    :rtype: boolean
+    """
+    return (
+        launcher_dir_path.exists() is True
+        and (
+            (launcher_dir_path / LAUNCHER_SERIES_DIR_NAME).exists() is True
+            and (launcher_dir_path / LAUNCHER_SERIES_DIR_NAME).is_dir()
+        )
+        and (
+            (launcher_dir_path / LAUNCHER_CONFIGURATION_FILE_NAME).exists() is True
+            and (launcher_dir_path / LAUNCHER_CONFIGURATION_FILE_NAME).is_file()
+        )
+        and (
+            (launcher_dir_path / LAUNCHER_LOG_FILE_NAME).exists() is True
+            and (launcher_dir_path / LAUNCHER_LOG_FILE_NAME).is_file()
+        )
+    )
+
+
+def setup_launcher_directory(launcher_dir_path: Path) -> None:
+    """
+    Configure the launcher directory at the given path.
+
+    :param launcher_dir_path:
+    :type launcher_dir_path: Path
+    """
+    # Create the root simulation directory if it doesn't exist
+    if launcher_dir_path.exists() is False:
+        launcher_dir_path.mkdir()
+
+    # Create the series directory if it doesn't exist
+    series_path = launcher_dir_path / LAUNCHER_SERIES_DIR_NAME
+    if series_path.exists() is False:
+        series_path.mkdir()
+
+    # create a empty log file
+    launcher_log_file_path = launcher_dir_path / LAUNCHER_LOG_FILE_NAME
+    launcher_log_file_path.touch()
+
+    # copy simulations references from python package.
+    physioblocks_references_folder_path = (
+        Path(physioblocks.__file__).parent / PHYSIOBLOCKS_REFERENCES_PATH
+    )
+    launcher_references_folder_path = launcher_dir_path / PHYSIOBLOCKS_REFERENCES_PATH
+    if physioblocks_references_folder_path.exists() is True:
+        shutil.copytree(
+            physioblocks_references_folder_path,
+            launcher_references_folder_path,
+            dirs_exist_ok=False,
+        )
+    else:
+        _logger.warning(
+            str.format(
+                "No references configuration folder at: {0}",
+                str(physioblocks_references_folder_path),
+            )
+        )
+
+    # create the user library directory
+    launcher_user_library_dir_path = launcher_dir_path / LAUNCHER_USER_LIBRARY_DIR_NAME
+    if launcher_user_library_dir_path.exists() is False:
+        launcher_user_library_dir_path.mkdir()
+
+    # put an empty __init__.py file in the user library
+    launcher_user_library_init_path = (
+        launcher_user_library_dir_path / LAUNCHER_MODULE_INIT_FILE_NAME
+    )
+    launcher_user_library_init_path.touch()
+
+    # create the user aliases directory
+    launcher_user_aliases_dir_path = launcher_dir_path / LAUNCHER_USER_ALIASES_DIR_NAME
+    if launcher_user_aliases_dir_path.exists() is False:
+        launcher_user_aliases_dir_path.mkdir()
+
+    # create a empty log file
+    launcher_log_file_path = launcher_dir_path / LAUNCHER_LOG_FILE_NAME
+    launcher_log_file_path.touch()
+
+    # create the launcher configuration file
+    base_library_dir_path = Path(physioblocks.library.__file__).parent
+    base_aliases_dir_path = (
+        Path(physioblocks.library.__file__).parent / LAUNCHER_CONFIGURATION_ALIAS_ID
+    )
+    base_configuration = {
+        LAUNCHER_CONFIGURATION_LIBRARIES_ID: [
+            str(base_library_dir_path.absolute()),
+            str(launcher_user_library_dir_path.absolute()),
+        ],
+        LAUNCHER_CONFIGURATION_ALIAS_ID: [
+            str(base_aliases_dir_path.absolute()),
+            str(launcher_user_aliases_dir_path.absolute()),
+        ],
+    }
+    launcher_configuration_file_path = (
+        launcher_dir_path / LAUNCHER_CONFIGURATION_FILE_NAME
+    )
+    launcher_configuration_file_path.write_text(
+        json.dumps(base_configuration, indent=4)
+    )
+
+    # create a gitignore file
+    launcher_gitignore_path = Path(launcher_dir_path / LAUNCHER_GITIGNORE_FILE_NAME)
+    launcher_gitignore_path.write_text("*")
+
+
+def get_launcher_configuration(root_sim_directory: Path) -> Any:
+    """
+    Get the launcher configuration for the given simulation directory.
+
+    :param root_sim_directory: the path to the launcher directory.
+    :type root_sim_directory: Path
+
+    :return: the configuration
+    :rtype: dict
+    """
+    launcher_config_path = root_sim_directory / LAUNCHER_CONFIGURATION_FILE_NAME
+    launcher_configuration = json.load(launcher_config_path.open("r"))
+    return launcher_configuration
+
+
+def import_configured_libraries(launcher_configuration: dict[str, Any]) -> None:
+    """
+    Dynamicaly import libraries in the given configuration
+
+    :param launcher_configuration: the layncher configuration
+    :type launcher_configuration: dict[str, Any]
+    """
+    libraries_paths = [
+        Path(lib_path)
+        for lib_path in launcher_configuration[LAUNCHER_CONFIGURATION_LIBRARIES_ID]
+    ]
+
+    import_libraries(libraries_paths)
+
+
+def import_configured_aliases(launcher_configuration: dict[str, Any]) -> None:
+    """
+    Dynamicaly import all alias at the given paths in configuration
+
+    :param launcher_configuration: the launcher configuration
+    :type launcher_configuration: dict[str, Any]
+    """
+    for alias_path in launcher_configuration[LAUNCHER_CONFIGURATION_ALIAS_ID]:
+        load_aliases(alias_path)

physioblocks/launcher/configure/__main__.py

@@ -0,0 +1,99 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks 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, version 3 of the License.
+#
+# PhysioBlocks 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
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Configure a directory to be used as a root directory for the PhysioBlocks launcher.
+"""
+
+import argparse
+import logging
+import sys
+from pathlib import Path
+
+from physioblocks.launcher.configuration import (
+    check_target_launcher_directory,
+    setup_launcher_directory,
+)
+from physioblocks.utils import exceptions_utils
+
+_logger = logging.getLogger()
+_logger.setLevel(logging.DEBUG)
+sys.excepthook = exceptions_utils.create_uncaught_exception_logger_handler(_logger)
+
+
+def main(target_dir: Path) -> int:
+    if check_target_launcher_directory(target_dir) is False:
+        raise OSError(
+            str.format(
+                "Launcher directory must either not exist already or be empty. "
+                "Provided directory: {0}",
+                str(target_dir.absolute()),
+            )
+        )
+
+    setup_launcher_directory(target_dir)
+    _logger.info(
+        str.format("Launcher directory created at {0}.", str(target_dir.absolute()))
+    )
+
+    return 0
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.HelpFormatter
+    )
+    parser.add_argument(
+        "-d",
+        "--launcher_directory",
+        dest="launcher_directory",
+        default="./",
+        required=False,
+        help="The directory where to setup the launcher.",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        dest="verbose",
+        action="store_true",
+        default=False,
+        required=False,
+        help="Display logs in console",
+    )
+
+    args = parser.parse_args()
+
+    # Direct the logs to stdout
+    if args.verbose is True:
+        stdout_handler = logging.StreamHandler(sys.stdout)
+        stdout_handler.setFormatter(logging.Formatter(logging.BASIC_FORMAT))
+        stdout_handler.setLevel(logging.DEBUG)
+        _logger.addHandler(stdout_handler)
+
+    # Convert the str path to a Pathlib Path
+    launcher_directory_path = Path(args.launcher_directory)
+    sys.exit(main(launcher_directory_path))

physioblocks/launcher/constants.py

@@ -0,0 +1,105 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks 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, version 3 of the License.
+#
+# PhysioBlocks 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
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""Define constants for the launcher scripts"""
+
+# SIMULATION INFO
+
+LAUNCHER_DATE_TIME_FORMAT = "%Y-%m-%d %H:%M:%S"
+"""Launcher format the represent date and time"""
+
+LAUNCHER_HOSTNAME_SEPARATOR = "."
+"""Launcher format the represent date and time"""
+
+LAUNCHER_REFERENCE_SEPARATOR = "_"
+"""Separator for SimulationInfo reference"""
+
+LAUNCHER_REFERENCE_COLUMN = "reference"
+"""SimulationInfo reference column id"""
+
+LAUNCHER_DATE_COLUMN = "date_time"
+"""SimulationInfo date column id"""
+
+LAUNCHER_MACHINE_COLUMN = "machine"
+"""SimulationInfo machine column id"""
+
+LAUNCHER_VERSION_COLUMN = "version"
+"""SimulationInfo version column id"""
+
+LAUNCHER_NOTES_COLUMN = "notes"
+"""SimulationInfo notes column id"""
+
+LAUNCHER_LOG_COLUMNS = [
+    LAUNCHER_DATE_COLUMN,
+    LAUNCHER_MACHINE_COLUMN,
+    LAUNCHER_REFERENCE_COLUMN,
+    LAUNCHER_VERSION_COLUMN,
+    LAUNCHER_NOTES_COLUMN,
+]
+"""The logged simulation info informations"""
+
+LAUNCHER_LOG_FILE_SEPARATOR = ";"
+"""the launcher log separator"""
+
+# FILES
+
+LAUNCHER_SERIES_DIR_NAME = "simulations"
+"""name of the series directory."""
+
+LAUNCHER_LOG_FILE_NAME = "launcher.log"
+"""name of the log file."""
+
+LAUNCHER_CONFIGURATION_FILE_NAME = "launcher.json"
+"""name of the configuration file."""
+
+LAUNCHER_GITIGNORE_FILE_NAME = ".gitignore"
+"""name of the gitignore file."""
+
+LAUNCHER_USER_LIBRARY_DIR_NAME = "user_library"
+"""name of the user library directory."""
+
+LAUNCHER_USER_ALIASES_DIR_NAME = "user_aliases"
+"""name of the user aliases directory."""
+
+LAUNCHER_CONFIGURATION_FILE_NAME = "launcher.json"
+"""name of the configuration file."""
+
+LAUNCHER_MODULE_INIT_FILE_NAME = "__init__.py"
+"""Init file name"""
+
+LAUNCHER_COMPARE_TRACE_FILE_NAME = "reference_compare.html"
+"""Name of an error file generated with the compare module"""
+
+# CONFIGURATION
+
+LAUNCHER_CONFIGURATION_LIBRARIES_ID = "libraries"
+"""name of the libraries item in the configuration"""
+
+LAUNCHER_CONFIGURATION_ALIAS_ID = "aliases"
+"""name of the aliases item in the configuration"""
+
+PHYSIOBLOCKS_REFERENCES_PATH = "references"
+"""Relative path to the references folder"""

physioblocks/launcher/files.py

@@ -0,0 +1,150 @@
+# SPDX-FileCopyrightText: Copyright INRIA
+#
+# SPDX-License-Identifier: LGPL-3.0-only
+#
+# Copyright INRIA
+#
+# This file is part of PhysioBlocks, a library mostly developed by the
+# [Ananke project-team](https://team.inria.fr/ananke) at INRIA.
+#
+# Authors:
+# - Colin Drieu
+# - Dominique Chapelle
+# - François Kimmig
+# - Philippe Moireau
+#
+# PhysioBlocks 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, version 3 of the License.
+#
+# PhysioBlocks 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
+# PhysioBlocks. If not, see <https://www.gnu.org/licenses/>.
+
+"""
+Describe function to handles the various launcher directory and files
+"""
+
+from pathlib import Path
+
+import pandas as pd
+import plotly
+import plotly.graph_objects as go
+import plotly.subplots
+
+from physioblocks.launcher.constants import (
+    LAUNCHER_DATE_COLUMN,
+    LAUNCHER_LOG_FILE_NAME,
+    LAUNCHER_REFERENCE_COLUMN,
+    LAUNCHER_SERIES_DIR_NAME,
+)
+from physioblocks.launcher.series import SimulationInfo, is_valid_reference_name
+
+
+def write_simulation_log_entry(root_folder_path: Path, info: SimulationInfo) -> None:
+    launcher_log_path = root_folder_path / LAUNCHER_LOG_FILE_NAME
+    if launcher_log_path.exists() and launcher_log_path.is_file():
+        try:
+            data = pd.read_csv(launcher_log_path)
+            data = update_simulations_log(root_folder_path, data)
+            # add the current simulation informations to the log
+            data = pd.concat(
+                [
+                    data.set_index(LAUNCHER_DATE_COLUMN),
+                    info.data_frame.set_index(LAUNCHER_DATE_COLUMN),
+                ]
+            )
+            data.to_csv(launcher_log_path)
+
+        except pd.errors.EmptyDataError:
+            # Only log the current info
+            info.data_frame.set_index(LAUNCHER_DATE_COLUMN).to_csv(launcher_log_path)
+    else:
+        raise FileNotFoundError(
+            str.format(
+                "There is no log for the launcher at {0}",
+                str(launcher_log_path.absolute()),
+            )
+        )
+
+
+def update_simulations_log(
+    root_folder_path: Path, sim_log: pd.DataFrame
+) -> pd.DataFrame:
+    launcher_log_path = root_folder_path / LAUNCHER_LOG_FILE_NAME
+    series_dir_path = root_folder_path / LAUNCHER_SERIES_DIR_NAME
+
+    if launcher_log_path.exists() is True:
+        # remove previous reference from log if it has been deleted
+        all_references_name = [
+            reference_dir_path.name
+            for serie_dir_path in series_dir_path.iterdir()
+            if serie_dir_path.is_dir()
+            for reference_dir_path in serie_dir_path.iterdir()
+            if is_valid_reference_name(reference_dir_path.name)
+        ]
+        following_references_mask = [
+            sim_log.loc[i][LAUNCHER_REFERENCE_COLUMN] not in all_references_name
+            for i in sim_log.index
+        ]
+        following_references_index = sim_log.iloc[following_references_mask].index
+        new_sim_log = sim_log.drop(following_references_index)
+        return new_sim_log
+
+    raise FileNotFoundError(
+        "There is no log for the launcher at {0}", str(launcher_log_path.absolute())
+    )
+
+
+def write_simulation_results(
+    simulation_folder: Path, info: SimulationInfo, data: pd.DataFrame, extension: str
+) -> None:
+    file_path = simulation_folder / str.join(".", [info.reference, extension])
+    match extension:
+        case "csv":
+            data.to_csv(file_path, index=False, sep=";")
+        case "parquet":
+            data.to_parquet(file_path, index=False)
+        case _:
+            raise OSError(str.format("Invalid file extension: {0}", extension))
+
+
+def write_figure(
+    data_frame: pd.DataFrame,
+    folder_path: Path,
+    file_name: str,
+    rows_height: float = 200.0,
+) -> None:
+    init_figure = go.Figure(
+        layout=go.Layout(height=rows_height * len(data_frame.columns))
+    )
+    figure = plotly.subplots.make_subplots(
+        len(data_frame.columns), 1, figure=init_figure, shared_xaxes=True
+    )
+
+    plot_index = 1
+    for data_id in data_frame.columns:
+        # Trace results
+        figure.add_trace(
+            go.Scatter(
+                x=data_frame.index,
+                y=data_frame[data_id],
+                mode="lines",
+                name=data_id,
+            ),
+            plot_index,
+            1,
+        )
+
+        figure.update_xaxes(title="time", row=plot_index, col=1)
+        figure.update_yaxes(
+            title=data_id,
+            row=plot_index,
+            col=1,
+        )
+        plot_index += 1
+
+    figure.write_html(folder_path / file_name)