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

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b3}/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.2b3/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: fmu_manipulation_toolbox
+Version: 1.9.2b3
+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)](https://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.2b3}/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.2b3}/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.2b3/fmu_manipulation_toolbox/__version__.py

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

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b3}/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.2b3}/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.2b3/fmu_manipulation_toolbox/cli/datalog2pcap.py

@@ -0,0 +1,143 @@
+import argparse
+import csv
+import logging
+import sys
+
+from pathlib import Path
+from typing import *
+
+from .utils import setup_logger, close_logger, make_wide
+from ..version import __version__ as version
+
+logger = setup_logger()
+
+class DatalogConverter:
+    def __init__(self, cvs_filename: Union[Path, str]):
+        self.csv_filename = Path(cvs_filename)
+        self.pcap_filename = self.csv_filename.with_suffix(".pcap")
+
+    def open_pcap(self):
+        logger.info(f"Creating PCAP file '{self.pcap_filename}'...")
+        file = open(self.pcap_filename, "wb")
+        file.write(int(0xA1B2C3D4).to_bytes(4, byteorder="big"))  # Magic number
+                                                                  # meaning the timestamp are in min seconds and microseconds
+
+        file.write(int(2).to_bytes(2, byteorder="big"))           # Major Version of fileformat
+        file.write(int(4).to_bytes(2, byteorder="big"))           # Minor Version
+        file.write(int(0).to_bytes(4, byteorder="big"))           # Reserved. SHOULD BE 0.
+        file.write(int(0).to_bytes(4, byteorder="big"))           # Reserved. SHOULD BE 0.
+
+        file.write(int(0xFFFF).to_bytes(4, byteorder="big"))      # snaplen indicating the maximum number of octets
+                                                                  # captured from each packet.
+
+        file.write(int(227).to_bytes(4, byteorder="big"))         # link type. his field is defined in the Section
+                                                                  # # 8.1 IANA registry.
+        return file
+
+    def open_csv(self):
+        logger.debug(f"Loading '{self.csv_filename}'")
+        file = open(self.csv_filename, "rt")
+        return file
+
+    def decode_hexstring(self, hex_string: bytes, time_s, time_us):
+        opcode = int.from_bytes(hex_string[0:4], byteorder="little")
+        length = int.from_bytes(hex_string[4:8], byteorder="little")
+        can_id = int.from_bytes(hex_string[8:12], byteorder="little")
+        if opcode == 0x10:  # TRANSMIT
+            rtr = int.from_bytes(hex_string[13:14], byteorder="little")
+            ide = int.from_bytes(hex_string[12:13], byteorder="little")
+            data_length = int.from_bytes(hex_string[14:16], byteorder="little")
+            raw_data = hex_string[16:]
+
+            logger.debug(f"time={time_s}.{time_us:06d} OP=0x{opcode:04X} len={length} {data_length} id={can_id}"
+                         f" ide={ide} rtr={rtr} len={data_length} {raw_data}")
+
+            # TimeStamp
+            self.pcapfile.write(time_s.to_bytes(4, byteorder="big"))
+            self.pcapfile.write(time_us.to_bytes(4, byteorder="big"))
+
+            # Packet length
+            packet_length = data_length + 8
+            self.pcapfile.write(packet_length.to_bytes(4, byteorder="big"))
+            self.pcapfile.write(packet_length.to_bytes(4, byteorder="big"))
+
+            # Control and flags
+            control = (can_id & 0x1FFFFFFF) | ((rtr & 0b1) << 30) | ((ide & 0b1) << 31)
+            self.pcapfile.write(control.to_bytes(4, byteorder="big"))
+
+            # Frame Length
+            self.pcapfile.write(data_length.to_bytes(1, byteorder="big"))
+
+            # Reserved
+            self.pcapfile.write(int(0).to_bytes(2, byteorder="big"))
+
+            # DLC
+            dlc = int(data_length)  # Classic CAN
+            self.pcapfile.write(dlc.to_bytes(1, byteorder="big"))
+
+            # PAYLOAD
+            self.pcapfile.write(raw_data)
+
+    def convert(self):
+        with self.open_csv() as self.csvfile, self.open_pcap() as self.pcapfile:
+            csv_reader = csv.DictReader(self.csvfile)
+
+            data_column_names = [ name for name in csv_reader.fieldnames if "_Data" in name ]
+            clock_column_names = {}
+
+            for column_name in data_column_names:
+                splitted_name = column_name.split(".")
+                splitted_name[-1] = splitted_name[-1].replace("_Data", "_Clock")
+                clock_column_name = ".".join(splitted_name)
+
+                if clock_column_name in csv_reader.fieldnames:
+                    logger.debug(f"{column_name} is clocked by {clock_column_name}")
+                    clock_column_names[column_name] = clock_column_name
+
+            for row in csv_reader:
+                time_s, time_us = divmod(float(row["time"]), 1)
+                time_s = int(time_s)
+                time_us = int(time_us * 1000000)
+
+                for names in data_column_names:
+                    hex_data = row[names]
+                    if hex_data:
+                        try:
+                            clock = row[clock_column_names[names]] == "1"
+                        except KeyError:
+                            clock = True
+                        if clock:
+                            self.decode_hexstring(bytes.fromhex(hex_data), time_s, time_us)
+
+
+def datalog2pcap():
+    logger.info(f"FMUContainer version {version}")
+    logger.warning(f"Datalog2PCAP is still experimental.")
+
+    parser = argparse.ArgumentParser(prog="datalog2pcap", description="Convert datalog from container to PCAP file.",
+                                     formatter_class=make_wide(argparse.ArgumentDefaultsHelpFormatter),
+                                     add_help=False,
+                                     epilog="see: https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/"
+                                            "doc/datalog.md")
+
+    parser.add_argument('-h', '-help', action="help")
+
+    parser.add_argument("-can", action="store", dest="can_filename", default=None,
+                        metavar="can-datalog.csv", required=True,
+                        help="Datalog with CAN data and clocks.")
+
+    parser.add_argument("-debug", action="store_true", dest="debug",
+                        help="Add lot of useful log during the process.")
+
+    config = parser.parse_args(sys.argv[1:])
+
+    if config.debug:
+        logger.setLevel(logging.DEBUG)
+
+    DatalogConverter(config.can_filename).convert()
+
+    close_logger(logger)
+
+
+if __name__ == "__main__":
+    datalog2pcap()

{fmu_manipulation_toolbox-1.9.2b1 → fmu_manipulation_toolbox-1.9.2b3}/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.2b3}/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.2b3}/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.2b3}/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: