fmu-manipulation-toolbox 1.9.2b1__tar.gz → 1.9.2b2__tar.gz

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2024 Renault SAS - Nicolas.LAURENT@Renault.com
+Copyright (c) 2024 Renault SAS
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions

fmu_manipulation_toolbox-1.9.2b2/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: fmu_manipulation_toolbox
+Version: 1.9.2b2
+Summary: FMU Manipulation Toolbox is a python package which helps to analyze, modify or combine Functional Mock-up Units (FMUs) without recompilation.
+Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
+Author: Nicolas.LAURENT@Renault.com
+License: BSD-2-Clause
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: PySide6>=6.8.0
+Requires-Dist: xmlschema>=3.3.1
+Requires-Dist: elementpath>=4.4.0
+Requires-Dist: colorama>=0.4.6
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+FMU Manipulation Toolbox is a python package which helps to analyze, modify or combine
+[Functional Mock-up Units (FMUs)](http://fmi-standard.org/) without recompilation. It is highly customizable and comes with
+a Python API.
+
+FMU Manipulation Toolbox can be used in different ways:
+- Using a Graphical User Interface: suitable for end users
+- Using a Command Line Interface: useful for scripting and automation
+- Using a Python API: the most efficient option for automation (CI/CD, transformation scripts, ...))
+
+Major features:
+- Analyze FMU content: list ports and their attributes, check compliance of `ModelDescription.xml` with XSD, etc.
+- Alter FMU by modifying its `modelDescription.xml` file. NOTE: manipulating this file can be a risky.
+  When possible, it is preferable to communicate with the FMU developer and adapt the FMU generation process.
+- Add binary interfaces. Typical use case is porting a 32-bit FMUs to 64-bit systems (or vice et versa). 
+- Combine FMUs into [FMU Containers](doc/container.md) and allow your favourite FMI tool to orchestrate complex assembly of FMUs.
+
+FMI versions 2.0 and 3.0 are supported.
+    

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/README.md

@@ -1,31 +1,36 @@
 ![](fmu_manipulation_toolbox/resources/fmu_manipulation_toolbox.png)
 
-FMU Manipulation Toolbox is a python package which help to analyse, modify or combine
-[Functional Mock-up Units (FMUs)](http://fmi-standard.org/) without recompilation. It is highly customizable as it comes with
+![](https://raw.githubusercontent.com/grouperenault/fmu_manipulation_toolbox/refs/heads/badges/.github/badges/python-version.svg)
+![](https://raw.githubusercontent.com/grouperenault/fmu_manipulation_toolbox/refs/heads/badges/.github/badges/fmi-version.svg)
+![](https://raw.githubusercontent.com/grouperenault/fmu_manipulation_toolbox/refs/heads/badges/.github/badges/coverage.svg)
+
+# 👀 Overview
+
+FMU Manipulation Toolbox is a python package which helps to analyze, modify or combine
+[Functional Mock-up Units (FMUs)](http://fmi-standard.org/) without recompilation. It is highly customizable and comes with
 a Python API.
 
-FMU Manipulation Toolbox can be used in different ways :
-- Using a Graphical User Interface: suitable for end user
-- Using a Command Line Interface: useful in 
-- Using a python API: the most efficient for automation (CI/CD, transformation scripts, ...)
+FMU Manipulation Toolbox can be used in different ways:
+- Using a Graphical User Interface: suitable for end users
+- Using a Command Line Interface: useful for scripting and automation
+- Using a Python API: the most efficient option for automation (CI/CD, transformation scripts, ...))
 
 Major features:
-- Analyse FMU content: list ports and their attributes, check compliance of `ModelDescription.xml` with XSD, ...
-- Alter FMU by modifying its `modelDescription.xml` file. NOTE: manipulating this file can be a dangerous
-  thing! Communicating with the FMU-developer and adapting the way the FMU is generated is preferable when
-  possible.
-- Add binary interface. Typical use case is porting a 32bits FMUs to 64bits (or vice et versa). 
-- Nest FMUs in a [FMU Container](doc/container.md)
+- Analyze FMU content: list ports and their attributes, check compliance of `ModelDescription.xml` with XSD, etc.
+- Alter FMU by modifying its `modelDescription.xml` file. NOTE: manipulating this file can be a risky.
+  When possible, it is preferable to communicate with the FMU developer and adapt the FMU generation process.
+- Add binary interfaces. Typical use case is porting a 32-bit FMUs to 64-bit systems (or vice et versa). 
+- Combine FMUs into [FMU Containers](doc/container.md) and allow your favourite FMI tool to orchestrate complex assembly of FMUs.
 
 FMI versions 2.0 and 3.0 are supported.
 
-## Installation
+# ⚙️ Installation
 
 Two options available to install FMU Manipulation Toolbox:
 
 - (*Easiest option*) Install with from PyPI: `pip install fmu-manipulation-toolbox`. This will install the latest
   version of FMU Manipulation Toolbox and all its dependencies. See [PyPI page](https://pypi.org/project/fmu-manipulation-toolbox/).
-- Compile and install from [github repository](https://github.com/grouperenault/fmu_manipulation_toolbox). You will need 
+- Compile and install from [GitHub repository](https://github.com/grouperenault/fmu_manipulation_toolbox). You will need 
   - Python required packages. See [`requirements.txt`](requirements.txt).
   - C compiler (C99 or later)
   - CMake (>= 3.20)
@@ -39,7 +44,7 @@ FMU Manipulation Toolbox is packaged for:
 - Darwin
 
 
-## Graphical User Interface
+# 🖥️ Graphical User Interface
 
 FMU Manipulation Toolbox is released with a GUI. You can launch it with the following command `fmutool-gui`
 
@@ -55,7 +60,7 @@ Button colors descriptions:
 **Original FMU is never modified**. Use `Save` button to get modified copy of the original FMU.
 
 
-## Command Line Interface
+# 🔧 Command Line Interface
 
 FMU Manipulation Toolbox comes with 2 commands:
 - `fmutool`: a versatile analysis and manipulation tool for FMU.
@@ -63,7 +68,7 @@ FMU Manipulation Toolbox comes with 2 commands:
 - `fmusplit: to extract FMUs from a FMU Container.
 
 
-### Analysis and Manipulation tool:
+## Analysis and Manipulation tool:
 
 You can use `fmutool -help` to get usage:
 
@@ -149,7 +154,7 @@ optional arguments:
                                     later issues when using the FMU. (default: None)
 ```
 
-### FMU Containers
+## FMU Containers
 
 ```
 usage: fmucontainer [-h] [-fmu-directory FMU_DIRECTORY] [-fmi FMI_VERSION]
@@ -178,7 +183,7 @@ options:
   -dump-json                        Dump a JSON file for each container. (default: False)
 ```
 
-## API
+# 🚀 API
 
 You can write your own FMU Manipulation scripts. Once you downloaded fmutool module, 
 adding the `import` statement lets you access the API :
@@ -188,7 +193,7 @@ from fmu_manipulation_toolbox.operations import ...
 ```
 
 
-### remove toplevel bus (if any)
+## remove toplevel bus (if any)
 
 Given a FMU with the following I/O structure
 ```
@@ -230,9 +235,8 @@ The following code will dump all FMU's Scalars names into a CSV:
 from fmu_manipulation_toolbox.operations import FMU, OperationSaveNamesToCSV
 
 fmu = FMU(r"bouncing_ball.fmu")
-operation = OperationSaveNamesToCSV()
+operation = OperationSaveNamesToCSV(r"bouncing_ball.csv")
 fmu.apply_operation(operation)
-operation.write_csv(r"bouncing_ball.csv")
 ```
 
 The produced CSV contains 2 columns in order to be reused in the next transformation.
@@ -249,7 +253,7 @@ e;e;5;parameter;tunable
 ```
 
 
-### Read CSV and rename FMU ports
+## Read CSV and rename FMU ports
 
 CSV file should contain 2 columns:
 1. the current name

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/__main__.py

@@ -3,7 +3,7 @@ import sys
 
 def gui():
     try:
-        from .gui import main
+        from .gui.gui import main
         main()
     except ModuleNotFoundError as e:
         print(f"FATAL ERROR: {e}. No GUI Available.")
@@ -11,7 +11,7 @@ def gui():
 
 def cli():
     from .cli.fmutool import fmutool
-    fmutool(sys.argv[1:])
+    fmutool()
 
 
 def main():

fmu_manipulation_toolbox-1.9.2b2/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.9.2b2'

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/assembly.py

@@ -7,7 +7,7 @@ import uuid
 import xml.parsers.expat
 import zipfile
 
-from .container import FMUContainer, AutoWired
+from .container import FMUContainer
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
@@ -103,7 +103,8 @@ class AssemblyNode:
     def add_start_value(self, fmu_filename: str, port_name: str, value: str):
         self.start_values[Port(fmu_filename, port_name)] = value
 
-    def make_fmu(self, fmu_directory: Path, debug=False, description_pathname=None, fmi_version=2):
+    def make_fmu(self, fmu_directory: Path, debug=False, description_pathname=None, fmi_version=2, datalog=False,
+                 filename=None):
         for node in self.children.values():
             node.make_fmu(fmu_directory, debug=debug, fmi_version=fmi_version)
 
@@ -142,8 +143,11 @@ class AssemblyNode:
         for link_rule in wired.rule_link:
             self.add_link(link_rule[0], link_rule[1], link_rule[2], link_rule[3])
 
-        container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, sequential=self.sequential,
-                           debug=debug, ts_multiplier=self.ts_multiplier)
+        if filename is None:
+            filename = self.name
+
+        container.make_fmu(filename, self.step_size, mt=self.mt, profiling=self.profiling, sequential=self.sequential,
+                           debug=debug, ts_multiplier=self.ts_multiplier, datalog=datalog)
 
         for node in self.children.values():
             logger.info(f"Deleting transient FMU Container '{node.name}'")
@@ -241,7 +245,7 @@ class Assembly:
         self.transient_dirnames: Set[Path] = set()
 
         if not fmu_directory.is_dir():
-            raise AssemblyError(f"FMU directory is not valid: '{fmu_directory}'")
+            raise AssemblyError(f"FMU directory is not valid: '{fmu_directory.resolve()}'")
 
         self.input_pathname = fmu_directory / self.filename
         self.description_pathname = self.input_pathname   # For inclusion in FMU
@@ -284,7 +288,7 @@ class Assembly:
         elif filename.endswith(".json"):
             return self.write_json(filename)
         else:
-            logger.critical(f"Unable to write to '{filename}': format unsupported.")
+            raise AssemblyError(f"Unable to write to '{filename}': format unsupported.")
 
     def read_csv(self):
         name = str(self.filename.with_suffix(".fmu"))
@@ -525,9 +529,9 @@ class Assembly:
             self.root = sdd.parse(self.description_pathname)
             self.root.name = str(self.filename.with_suffix(".fmu"))
 
-    def make_fmu(self, dump_json=False, fmi_version=2):
+    def make_fmu(self, dump_json=False, fmi_version=2, datalog=False, filename=None):
         self.root.make_fmu(self.fmu_directory, debug=self.debug, description_pathname=self.description_pathname,
-                           fmi_version=fmi_version)
+                           fmi_version=fmi_version, datalog=datalog, filename=filename)
         if dump_json:
             dump_file = Path(self.input_pathname.stem + "-dump").with_suffix(".json")
             logger.info(f"Dump Json '{dump_file}'")

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/checker.py

@@ -27,11 +27,11 @@ class OperationGenericCheck(OperationAbstract):
             return
 
         fmi_name = f"fmi{attrs['fmiVersion'][0]}"
-
         xsd_filename = os.path.join(os.path.dirname(__file__), "resources", "fmi-" + attrs['fmiVersion'],
                                     f"{fmi_name}ModelDescription.xsd")
+        xsd = xmlschema.XMLSchema(xsd_filename)
         try:
-            xmlschema.validate(self.fmu.descriptor_filename, schema=xsd_filename)
+            xsd.validate(self.fmu.descriptor_filename)
         except XMLSchemaValidationError as error:
             logger.error(error.reason, error.msg)
         else:
@@ -43,8 +43,10 @@ class OperationGenericCheck(OperationAbstract):
         else:
             logger.error(f"This FMU does not validate with FMI standard.")
 
+
 _checkers_list: List[type[OperationAbstract]] = [OperationGenericCheck]
 
+
 def get_checkers() -> List[type[OperationAbstract]]:
     if sys.version_info < (3, 10):
         from importlib_metadata import entry_points

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/cli/fmucontainer.py

@@ -4,7 +4,7 @@ import sys
 
 from pathlib import Path
 
-from .utils import setup_logger, make_wide
+from .utils import setup_logger, close_logger, make_wide
 from ..assembly import Assembly, AssemblyError
 from ..container import FMUContainerError
 from ..version import __version__ as version
@@ -22,36 +22,42 @@ def fmucontainer():
 
     parser.add_argument('-h', '-help', action="help")
 
-    parser.add_argument("-fmu-directory", action="store", dest="fmu_directory", required=False, default=".",
-                        help="Directory containing initial FMU’s and used to generate containers. "
-                             "If not defined, current directory is used.")
-
-    parser.add_argument("-fmi", action="store", dest="fmi_version", required=False, default="2",
-                        help="Define version of FMI to be used for container interface."
-                             "Only '2' or '3' is supported.")
-
     parser.add_argument("-container", action="append", dest="container_descriptions_list", default=[],
                         metavar="filename.{csv|json|ssp},[:step_size]", required=True,
                         help="Description of the container to create.")
 
+    parser.add_argument("-datalog", action="store_true", dest="datalog", default=False,
+                        help="Log into log file input, output and local variables of the container")
+
     parser.add_argument("-debug", action="store_true", dest="debug",
                         help="Add lot of useful log during the process.")
 
+    parser.add_argument("-dump-json",  action="store_true", dest="dump", default=False,
+                        help="Dump a JSON file for each container.")
+
+    parser.add_argument("-fmi", action="store", dest="fmi_version", required=False, default="2",
+                        help="Define version of FMI to be used for container interface."
+                             "Only '2' or '3' is supported.")
+
+    parser.add_argument("-fmu-directory", action="store", dest="fmu_directory", required=False, default=".",
+                        help="Directory containing initial FMU’s and used to generate containers. "
+                             "If not defined, current directory is used.")
+
     parser.add_argument("-no-auto-input", action="store_false", dest="auto_input", default=True,
                         help="Create ONLY explicit input.")
 
+    parser.add_argument("-no-auto-link", action="store_false", dest="auto_link", default=True,
+                        help="Create ONLY explicit links.")
+
+    parser.add_argument("-auto-local", action="store_true", dest="auto_local", default=False,
+                        help="Expose local variables of the embedded fmu's.")
+
     parser.add_argument("-no-auto-output", action="store_false", dest="auto_output", default=True,
                         help="Create ONLY explicit output.")
 
     parser.add_argument("-auto-parameter", action="store_true", dest="auto_parameter", default=False,
                         help="Expose parameters of the embedded fmu's.")
 
-    parser.add_argument("-auto-local", action="store_true", dest="auto_local", default=False,
-                        help="Expose local variables of the embedded fmu's.")
-
-    parser.add_argument("-no-auto-link", action="store_false", dest="auto_link", default=True,
-                        help="Create ONLY explicit links.")
-
     parser.add_argument("-mt", action="store_true", dest="mt", default=False,
                         help="Enable Multi-Threaded mode for the generated container.")
 
@@ -61,9 +67,6 @@ def fmucontainer():
     parser.add_argument("-sequential", action="store_true", dest="sequential", default=False,
                         help="Use sequential mode to schedule embedded fmu's.")
 
-    parser.add_argument("-dump-json",  action="store_true", dest="dump", default=False,
-                        help="Dump a JSON file for each container.")
-
     parser.add_argument("-vr", action="store_true", dest="ts_multiplier", default=False,
                         help="Add TS_MULTIPLIER input port to control step_size")
 
@@ -92,16 +95,21 @@ def fmucontainer():
                                 auto_parameter=config.auto_parameter, ts_multiplier=config.ts_multiplier)
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
+            close_logger(logger)
             sys.exit(-1)
         except (FMUContainerError, AssemblyError) as e:
             logger.fatal(f"{filename}: {e}")
+            close_logger(logger)
             sys.exit(-2)
 
         try:
-            assembly.make_fmu(dump_json=config.dump, fmi_version=int(config.fmi_version))
+            assembly.make_fmu(dump_json=config.dump, fmi_version=int(config.fmi_version), datalog=config.datalog)
         except FMUContainerError as e:
             logger.fatal(f"{filename}: {e}")
+            close_logger(logger)
             sys.exit(-3)
 
+        close_logger(logger)
+
 if __name__ == "__main__":
     fmucontainer()

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/cli/fmusplit.py

@@ -2,8 +2,7 @@ import argparse
 import logging
 import sys
 
-
-from .utils import setup_logger, make_wide
+from .utils import setup_logger, close_logger, make_wide
 from ..split import FMUSplitter, FMUSplitterError
 from ..version import __version__ as version
 
@@ -37,11 +36,15 @@ def fmusplit():
             splitter.split_fmu()
         except FMUSplitterError as e:
             logger.fatal(f"{fmu_filename}: {e}")
+            close_logger(logger)
             sys.exit(-1)
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
+            close_logger(logger)
             sys.exit(-2)
 
+    close_logger(logger)
+
 
 if __name__ == "__main__":
     fmusplit()

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/cli/fmutool.py

@@ -1,9 +1,7 @@
 import argparse
 import sys
 
-from typing import *
-
-from .utils import setup_logger, make_wide
+from .utils import setup_logger, close_logger, make_wide
 from ..operations import (OperationSummary, OperationError, OperationRemoveRegexp,
                           OperationRemoveSources, OperationTrimUntil, OperationKeepOnlyRegexp, OperationMergeTopLevel,
                           OperationStripTopLevel, OperationRenameFromCSV, OperationSaveNamesToCSV, FMU, FMUError)
@@ -78,6 +76,7 @@ def fmutool():
 
     if cli_options.fmu_input == cli_options.fmu_output:
         logger.fatal(f"'-input' and '-output' should point to different files.")
+        close_logger(logger)
         sys.exit(-3)
 
     logger.info(f"READING Input='{cli_options.fmu_input}'")
@@ -85,6 +84,7 @@ def fmutool():
         fmu = FMU(cli_options.fmu_input)
     except FMUError as reason:
         logger.fatal(f"{reason}")
+        close_logger(logger)
         sys.exit(-4)
 
     if cli_options.apply_on:
@@ -107,6 +107,7 @@ def fmutool():
             fmu.apply_operation(operation, cli_options.apply_on)
         except OperationError as reason:
             logger.fatal(f"{reason}")
+            close_logger(logger)
             sys.exit(-6)
 
     if cli_options.extract_description:
@@ -119,9 +120,13 @@ def fmutool():
             fmu.repack(cli_options.fmu_output)
         except FMUError as reason:
             logger.fatal(f"FATAL ERROR: {reason}")
+            close_logger(logger)
             sys.exit(-5)
     else:
         logger.info(f"INFO    Modified FMU is not saved. If necessary use '-output' option.")
 
+    close_logger(logger)
+
+
 if __name__ == "__main__":
     fmutool()

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/cli/utils.py

@@ -2,7 +2,8 @@ import logging
 import sys
 from colorama import Fore, Style, init
 
-def setup_logger():
+
+def setup_logger() -> logging.Logger:
     class CustomFormatter(logging.Formatter):
         def format(self, record):
             log_format = "%(levelname)-8s | %(message)s"
@@ -24,6 +25,15 @@ def setup_logger():
 
     return logger
 
+
+def close_logger(logger: logging.Logger):
+    for handler in logger.handlers:
+        logger.removeHandler(handler)
+        handler.close()
+    logger.setLevel(logging.NOTSET)
+    logger.propagate = True
+
+
 def make_wide(formatter, w=120, h=36):
     """Return a wider HelpFormatter, if possible."""
     try:

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/container.py

@@ -484,7 +484,7 @@ class FMUIOList:
 
     def add_start_value(self, cport: ContainerPort, value: str):
         reset = 1 if cport.port.causality == "input" else 0
-        self.start_values[cport.port.type_name][cport.fmu.name].append((cport, reset, value))
+        self.start_values[cport.port.type_name][cport.fmu.name].append((cport.port.vr, reset, value))
 
     def write_txt(self, fmu_name, txt_file):
         for type_name in EmbeddedFMUPort.ALL_TYPES:
@@ -535,7 +535,7 @@ class ClockList:
 
     def write_txt(self, txt_file):
         print(f"# importer CLOCKS: <FMU_INDEX> <NB> <FMU_VR> <VR> [<FMU_VR> <VR>]", file=txt_file)
-        nb_total_clocks = 0;
+        nb_total_clocks = 0
         for clocks in self.clocks_per_fmu.values():
             nb_total_clocks += len(clocks)
 
@@ -756,11 +756,11 @@ class FMUContainer:
         cport = ContainerPort(self.get_fmu(fmu_filename), port_name)
 
         try:
-            if cport.port.type_name in ('Real', 'Float64', 'Float32'):
+            if cport.port.type_name.startswith('real'):
                 value = float(value)
-            elif cport.port.type_name in ('Integer', 'Int8', 'UInt8', 'Int16', 'UInt16', 'Int32', 'UInt32', 'Int64', 'UInt64'):
+            elif cport.port.type_name.startswith('integer') or  cport.port.type_name.startswith('uinteger'):
                 value = int(value)
-            elif cport.port.type_name == 'Boolean':
+            elif cport.port.type_name.startswith('boolean'):
                 value = int(bool(value))
             elif cport.port.type_name == 'String':
                 value = value
@@ -872,7 +872,7 @@ class FMUContainer:
                         logger.warning(f"{cport} is not connected")
 
     def make_fmu(self, fmu_filename: Union[str, Path], step_size: Optional[float] = None, debug=False, mt=False,
-                 profiling=False, sequential=False, ts_multiplier=False):
+                 profiling=False, sequential=False, ts_multiplier=False, datalog=False):
         if isinstance(fmu_filename, str):
             fmu_filename = Path(fmu_filename)
 
@@ -885,11 +885,16 @@ class FMUContainer:
 
         base_directory = self.fmu_directory / fmu_filename.with_suffix('')
         resources_directory = self.make_fmu_skeleton(base_directory)
+
         with open(base_directory / "modelDescription.xml", "wt") as xml_file:
             self.make_fmu_xml(xml_file, step_size, profiling, ts_multiplier)
         with open(resources_directory / "container.txt", "wt") as txt_file:
             self.make_fmu_txt(txt_file, step_size, mt, profiling, sequential)
 
+        if datalog:
+            with open(resources_directory / "datalog.txt", "wt") as datalog_file:
+                self.make_datalog(datalog_file)
+
         self.make_fmu_package(base_directory, fmu_filename)
         if not debug:
             self.make_fmu_cleanup(base_directory)
@@ -1173,6 +1178,24 @@ class FMUContainer:
         # CLOCKS
         clock_list.write_txt(txt_file)
 
+    def make_datalog(self, datalog_file):
+        print(f"# Datalog filename")
+        print(f"{self.identifier}-datalog.csv", file=datalog_file)
+
+        ports = defaultdict(list)
+        for input_port_name, input_port in self.inputs.items():
+            ports[input_port.type_name].append((input_port.vr, input_port_name))
+        for output_port_name, output_port in self.outputs.items():
+            ports[output_port.port.type_name].append((output_port.vr, output_port_name))
+        for link in self.links.values():
+            ports[link.cport_from.port.type_name].append((link.vr, link.name))
+
+        for type_name in EmbeddedFMUPort.ALL_TYPES:
+            print(f"# {type_name}: <VR> <NAME>" , file=datalog_file)
+            print(f"{len(ports[type_name])}", file=datalog_file)
+            for port in ports[type_name]:
+                print(f"{port[0]} {port[1]}", file=datalog_file)
+
     @staticmethod
     def long_path(path: Union[str, Path]) -> str:
         # https://stackoverflow.com/questions/14075465/copy-a-file-with-a-too-long-path-to-another-directory-in-python

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/operations.py

@@ -121,7 +121,8 @@ class Manipulation:
     TAGS_MODEL_STRUCTURE = ("InitialUnknowns", "Derivatives", "Outputs")
 
     def __init__(self, operation, fmu):
-        self.output_filename = tempfile.mktemp()
+        (fd, self.output_filename) = tempfile.mkstemp()
+        os.close(fd)  # File will be re-opened later
         self.out = None
         self.operation = operation
         self.parser = xml.parsers.expat.ParserCreate()

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/split.py

@@ -6,6 +6,15 @@ import xml.parsers.expat
 from typing import *
 from pathlib import Path
 
+from .container import EmbeddedFMUPort
+import logging
+import zipfile
+import json
+import xml.parsers.expat
+
+from typing import *
+from pathlib import Path
+
 from .container import EmbeddedFMUPort
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
@@ -191,7 +200,7 @@ class FMUSplitterDescription:
             self.config["mt"] = flags[0] == "1"
             self.config["profiling"] = self.get_line(file) == "1"
             self.config["sequential"] = False
-        elif len(flags) == 3:
+        elif len(flags) >= 3:
             self.supported_fmi_types = EmbeddedFMUPort.ALL_TYPES
             self.config["mt"] = flags[0] == "1"
             self.config["profiling"] = flags[1] == "1"

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b2}/fmu_manipulation_toolbox/version.py

@@ -4,6 +4,6 @@ except ModuleNotFoundError:
     __version__ = "0.0.dev0"
 
 __author__ = "Nicolas.LAURENT@Renault.com"
-__copyright__ = "Copyright 2023-2024, Renault SAS"
+__copyright__ = "Copyright 2023-2026, Renault SAS"
 __license__ = """This code is released under the 2-Clause BSD license. 
 See https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/LICENSE.txt"""