fmu-manipulation-toolbox 1.9.2b1__py3-none-any.whl → 1.9.2b3__py3-none-any.whl

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/__version__.py

@@ -1 +1 @@
-'V1.9.2b1'
+'V1.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/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/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/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/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/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/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/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,28 @@ class FMUContainer:
         # CLOCKS
         clock_list.write_txt(txt_file)
 
+    def make_datalog(self, datalog_file):
+        print(f"# Datalog filename", file=datalog_file)
+        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():
+            if link.cport_from is None:
+                # LS-BUS allows to connected to input clocks.
+                ports[link.cport_to_list[0].port.type_name].append((link.vr, link.name))
+            else:
+                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/operations.py

@@ -61,7 +61,7 @@ class FMUPort:
         self.dimension = None
 
     def dict_level(self, nb):
-        return " ".join([f'{key}="{value}"' for key, value in self.attrs_list[nb].items()])
+        return " ".join([f'{key}="{Manipulation.escape(value)}"' for key, value in self.attrs_list[nb].items()])
 
     def write_xml(self, fmi_version: int, file):
         if fmi_version == 2:
@@ -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()
@@ -176,7 +177,7 @@ class Manipulation:
                 self.current_port = FMUPort()
                 self.current_port.push_attrs(attrs)
             elif self.fmu.fmi_version == 2 and name in self.fmu.FMI2_TYPES:
-                if self.current_port: # <Enumeration> can be found before port defition. Ignored.
+                if self.current_port: # <Enumeration> can be found before port definition. Ignored.
                     self.current_port.fmi_type = name
                     self.current_port.push_attrs(attrs)
             elif self.fmu.fmi_version == 3 and name in self.fmu.FMI3_TYPES:

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/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"""