fmu-manipulation-toolbox 1.9rc1__py3-none-any.whl → 1.9rc3__py3-none-any.whl

fmu_manipulation_toolbox/__init__.py

@@ -1 +0,0 @@
-

fmu_manipulation_toolbox/__main__.py

@@ -10,7 +10,7 @@ def gui():
 
 
 def cli():
-    from .cli import fmutool
+    from .cli.fmutool import fmutool
     fmutool()
 
 

fmu_manipulation_toolbox/__version__.py

@@ -1 +1 @@
-'V1.9-pre1'
+'V1.9-rc3'

fmu_manipulation_toolbox/assembly.py

@@ -103,7 +103,7 @@ class AssemblyNode:
 
     def make_fmu(self, fmu_directory: Path, debug=False, description_pathname=None, fmi_version=2):
         for node in self.children.values():
-            node.make_fmu(fmu_directory, debug=debug)
+            node.make_fmu(fmu_directory, debug=debug, fmi_version=fmi_version)
 
         identifier = str(Path(self.name).stem)
         container = FMUContainer(identifier, fmu_directory, description_pathname=description_pathname,

fmu_manipulation_toolbox/checker.py

@@ -1,10 +1,13 @@
 import importlib.util
 import inspect
+import logging
 import os
 import xmlschema
 from xmlschema.validators.exceptions import XMLSchemaValidationError
 from .operations import OperationAbstract
 
+logger = logging.getLogger("fmu_manipulation_toolbox")
+
 
 class OperationGenericCheck(OperationAbstract):
     SUPPORTED_FMI_VERSIONS = ('2.0', '3.0')
@@ -17,7 +20,7 @@ class OperationGenericCheck(OperationAbstract):
 
     def fmi_attrs(self, attrs):
         if attrs['fmiVersion'] not in self.SUPPORTED_FMI_VERSIONS:
-            print(f"ERROR: Expected FMI {','.join(self.SUPPORTED_FMI_VERSIONS)} versions.")
+            logger.error(f"Expected FMI {','.join(self.SUPPORTED_FMI_VERSIONS)} versions.")
             return
 
         fmi_name = f"fmi{attrs['fmiVersion'][0]}"
@@ -27,15 +30,15 @@ class OperationGenericCheck(OperationAbstract):
         try:
             xmlschema.validate(self.fmu.descriptor_filename, schema=xsd_filename)
         except XMLSchemaValidationError as error:
-            print(error.reason, error.msg)
+            logger.error(error.reason, error.msg)
         else:
             self.compliant_with_version = attrs['fmiVersion']
 
     def closure(self):
         if self.compliant_with_version:
-            print(f"INFO: This FMU seems to be compliant with FMI-{self.compliant_with_version}.")
+            logger.info(f"This FMU seems to be compliant with FMI-{self.compliant_with_version}.")
         else:
-            print(f"ERROR: This FMU does not validate with FMI standard.")
+            logger.error(f"This FMU does not validate with FMI standard.")
 
 
 checker_list = [OperationGenericCheck]
@@ -44,20 +47,20 @@ checker_list = [OperationGenericCheck]
 def add_from_file(checker_filename: str):
     spec = importlib.util.spec_from_file_location(checker_filename, checker_filename)
     if not spec:
-        print(f"ERROR: Cannot load {checker_filename}. Is this a python file?")
+        logger.error(f"Cannot load '{checker_filename}'. Is this a python file?")
         return
     try:
         checker_module = importlib.util.module_from_spec(spec)
         try:
             spec.loader.exec_module(checker_module)
         except (ModuleNotFoundError, SyntaxError) as error:
-            print(f"ERROR: Cannot load {checker_filename}: {error})")
+            logger.error(f"Cannot load '{checker_filename}': {error})")
             return
 
         for checker_name, checker_class in inspect.getmembers(checker_module, inspect.isclass):
             if OperationAbstract in checker_class.__bases__:
                 checker_list.append(checker_class)
-                print(f"Adding checker: {checker_filename}|{checker_name}")
+                logger.info(f"Adding checker: {checker_filename}|{checker_name}")
 
     except AttributeError:
-        print(f"ERROR: {checker_filename} should implement class 'OperationCheck'")
+        logger.error(f"'{checker_filename}' should implement class 'OperationCheck'")

fmu_manipulation_toolbox/container.py

@@ -40,29 +40,6 @@ class EmbeddedFMUPort:
         }
     }
 
-    FMI_TO_CONTAINER = {
-        2: {
-            'Real': 'real64',
-            'Integer': 'integer32',
-            'String': 'string',
-            'Boolean': 'boolean'
-        },
-        3: {
-            'Float64': 'real64',
-            'Float32': 'real32',
-            'Int8': 'integer8',
-            'UInt8': 'uinteger8',
-            'Int16': 'integer16',
-            'UInt16': 'uinteger16',
-            'Int32': 'integer32',
-            'UInt32': 'uinteger32',
-            'Int64': 'integer64',
-            'UInt64': 'uinteger64',
-            'String': 'string',
-            'Boolean': 'boolean1'
-        }
-    }
-
     CONTAINER_TO_FMI = {
         2: {
             'real64': 'Real',
@@ -90,7 +67,7 @@ class EmbeddedFMUPort:
         "real64", "real32",
         "integer8", "uinteger8", "integer16", "uinteger16", "integer32", "uinteger32", "integer64", "uinteger64",
         "boolean", "boolean1",
-        "strings"
+        "string"
     )
 
 
@@ -112,7 +89,7 @@ class EmbeddedFMUPort:
 
 
 
-    def xml(self, vr: int, name=None, causality=None, start=None, fmi_version=2):
+    def xml(self, vr: int, name=None, causality=None, start=None, fmi_version=2) -> str:
         if name is None:
             name = self.name
         if causality is None:
@@ -122,7 +99,12 @@ class EmbeddedFMUPort:
         if self.variability is None:
             self.variability = "continuous" if "real" in self.type_name else "discrete"
 
-        fmi_type = self.CONTAINER_TO_FMI[fmi_version][self.type_name]
+        try:
+            fmi_type = self.CONTAINER_TO_FMI[fmi_version][self.type_name]
+        except KeyError:
+            logger.error(f"Cannot expose '{name}' because type '{self.type_name}' is not compatible "
+                         f"with FMI-{fmi_version}.0")
+            return ""
 
         if fmi_version == 2:
             child_attrs =  {
@@ -146,19 +128,36 @@ class EmbeddedFMUPort:
             scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in filtered_attrs.items()])
             return f'<ScalarVariable {scalar_attrs_str}>{child_str}</ScalarVariable>'
         else:
-            scalar_attrs = {
-                "name": name,
-                "valueReference": vr,
-                "causality": causality,
-                "variability": self.variability,
-                "initial": self.initial,
-                "description": self.description,
-                "start": start
-            }
-            filtered_attrs = {key: value for key, value in scalar_attrs.items() if value is not None}
-            scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in filtered_attrs.items()])
+            if fmi_type in ('String', 'Binary'):
+                if start:
+                    child_str = f'<Start value="{start}"/>'
+                else:
+                    child_str = ''
+                scalar_attrs = {
+                    "name": name,
+                    "valueReference": vr,
+                    "causality": causality,
+                    "variability": self.variability,
+                    "initial": self.initial,
+                    "description": self.description,
+                }
+                filtered_attrs = {key: value for key, value in scalar_attrs.items() if value is not None}
+                scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in filtered_attrs.items()])
+                return f'<{fmi_type} {scalar_attrs_str}>{child_str}</{fmi_type}>'
+            else:
+                scalar_attrs = {
+                    "name": name,
+                    "valueReference": vr,
+                    "causality": causality,
+                    "variability": self.variability,
+                    "initial": self.initial,
+                    "description": self.description,
+                    "start": start
+                }
+                filtered_attrs = {key: value for key, value in scalar_attrs.items() if value is not None}
+                scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in filtered_attrs.items()])
 
-            return f'<{fmi_type} {scalar_attrs_str}/>'
+                return f'<{fmi_type} {scalar_attrs_str}/>'
 
 
 class EmbeddedFMU(OperationAbstract):
@@ -265,12 +264,51 @@ class ContainerInput:
         self.cport_list.append(cport_to)
 
 
-class Local:
+class Link:
+    CONVERSION_FUNCTION = {
+        "real32/real64": "F32_F64",
+
+        "Int8/Int16": "D8_D16",
+        "Int8/UInt16": "D8_U16",
+        "Int8/Int32": "D8_D32",
+        "Int8/UInt32": "D8_U32",
+        "Int8/Int64": "D8_D64",
+        "Int8/UInt64": "D8_U64",
+
+        "UInt8/Int16": "U8_D16",
+        "UInt8/UInt16": "U8_U16",
+        "UInt8/Int32": "U8_D32",
+        "UInt8/UInt32": "U8_U32",
+        "UInt8/Int64": "U8_D64",
+        "UInt8/UInt64": "U8_U64",
+
+        "Int16/Int32": "D16_D32",
+        "Int16/UInt32": "D16_U32",
+        "Int16/Int64": "D16_D64",
+        "Int16/UInt64": "D16_U64",
+
+        "UInt16/Int32": "U16_D32",
+        "UInt16/UInt32": "U16_U32",
+        "UInt16/Int64": "U16_D64",
+        "UInt16/UInt64": "U16_U64",
+
+        "Int32/Int64": "D32_D64",
+        "Int32/UInt64": "D32_U64",
+
+        "UInt32/Int64": "U32_D64",
+        "UInt32/UInt64": "U32_U64",
+
+        "boolean/boolean1": "B_B1",
+        "boolean1/boolean": "B1_B",
+    }
+
     def __init__(self, cport_from: ContainerPort):
         self.name = cport_from.fmu.id + "." + cport_from.port.name  # strip .fmu suffix
         self.cport_from = cport_from
         self.cport_to_list: List[ContainerPort] = []
-        self.vr = None
+
+        self.vr: Optional[int] = None
+        self.vr_converted: Dict[str, Optional[int]] = {}
 
         if not cport_from.port.causality == "output":
             raise FMUContainerError(f"{cport_from} is  {cport_from.port.causality} instead of OUTPUT")
@@ -281,30 +319,54 @@ class Local:
 
         if cport_to.port.type_name == self.cport_from.port.type_name:
             self.cport_to_list.append(cport_to)
+        elif self.get_conversion(cport_to):
+            self.cport_to_list.append(cport_to)
+            self.vr_converted[cport_to.port.type_name] = None
         else:
             raise FMUContainerError(f"failed to connect {self.cport_from} to {cport_to} due to type.")
 
+    def get_conversion(self, cport_to: ContainerPort) -> Optional[str]:
+        try:
+            conversion = f"{self.cport_from.port.type_name}/{cport_to.port.type_name}"
+            return self.CONVERSION_FUNCTION[conversion]
+        except KeyError:
+            return None
+
+    def nb_local(self) -> int:
+        return 1+len(self.vr_converted)
+
 
 class ValueReferenceTable:
     def __init__(self):
-        self.vr_table = {}
-        self.masks = {}
+        self.vr_table:Dict[str, int] = {}
+        self.masks: Dict[str, int] = {}
+        self.nb_local_variable:Dict[str, int] = {}
         for i, type_name in enumerate(EmbeddedFMUPort.ALL_TYPES):
             self.vr_table[type_name] = 0
             self.masks[type_name] = i << 24
+            self.nb_local_variable[type_name] = 0
 
-
-    def add_vr(self, port_or_type_name: Union[ContainerPort, str]) -> int:
+    def add_vr(self, port_or_type_name: Union[ContainerPort, str], local: bool = False) -> int:
         if isinstance(port_or_type_name, ContainerPort):
             type_name = port_or_type_name.port.type_name
         else:
             type_name = port_or_type_name
 
+        if local:
+            self.nb_local_variable[type_name] += 1
+
         vr = self.vr_table[type_name]
         self.vr_table[type_name] += 1
 
         return vr | self.masks[type_name]
 
+    def set_link_vr(self, link: Link):
+        link.vr = self.add_vr(link.cport_from, local=True)
+        for type_name in link.vr_converted.keys():
+            link.vr_converted[type_name] = self.add_vr(type_name, local=True)
+
+    def nb_local(self, type_name: str) -> int:
+        return self.nb_local_variable[type_name]
 
 class AutoWired:
     def __init__(self):
@@ -416,24 +478,12 @@ class FMUContainer:
         # Rules
         self.inputs: Dict[str, ContainerInput] = {}
         self.outputs: Dict[str, ContainerPort] = {}
-        self.locals: Dict[ContainerPort, Local] = {}
+        self.links: Dict[ContainerPort, Link] = {}
 
         self.rules: Dict[ContainerPort, str] = {}
         self.start_values: Dict[ContainerPort, str] = {}
 
-
-    def convert_type_name(self, type_name: str) -> str:
-        if self.fmi_version == 2:
-            table = {}
-        elif self.fmi_version == 3:
-            table = {}
-        else:
-            table = {}
-
-        try:
-            return table[type_name]
-        except KeyError:
-            return type_name
+        self.vr_table = ValueReferenceTable()
 
     def get_fmu(self, fmu_filename: str) -> EmbeddedFMU:
         if fmu_filename in self.involved_fmu:
@@ -442,7 +492,7 @@ class FMUContainer:
         try:
             fmu = EmbeddedFMU(self.fmu_directory / fmu_filename)
             if fmu.fmi_version > self.fmi_version:
-                logger.fatal(f"Try to embed FMU-{fmu.fmi_version} into container FMI-{self.fmi_version}")
+                logger.warning(f"Try to embed FMU-{fmu.fmi_version} into container FMI-{self.fmi_version}")
             self.involved_fmu[fmu.name] = fmu
 
             logger.debug(f"Adding FMU #{len(self.involved_fmu)}: {fmu}")
@@ -506,16 +556,17 @@ class FMUContainer:
     def add_link(self, from_fmu_filename: str, from_port_name: str, to_fmu_filename: str, to_port_name: str):
         cport_from = ContainerPort(self.get_fmu(from_fmu_filename), from_port_name)
         try:
-            local = self.locals[cport_from]
+            local = self.links[cport_from]
         except KeyError:
-            local = Local(cport_from)
+            local = Link(cport_from)
 
         cport_to = ContainerPort(self.get_fmu(to_fmu_filename), to_port_name)
         local.add_target(cport_to)  # Causality is check in the add() function
 
+        logger.debug(f"LINK: {cport_from} -> {cport_to}")
         self.mark_ruled(cport_from, 'LINK')
         self.mark_ruled(cport_to, 'LINK')
-        self.locals[cport_from] = local
+        self.links[cport_from] = local
 
     def add_start_value(self, fmu_filename: str, port_name: str, value: str):
         cport = ContainerPort(self.get_fmu(fmu_filename), port_name)
@@ -649,8 +700,6 @@ class FMUContainer:
             self.make_fmu_cleanup(base_directory)
 
     def make_fmu_xml(self, xml_file, step_size: float, profiling: bool):
-        vr_table = ValueReferenceTable()
-
         timestamp = datetime.now().strftime('%Y-%m-%dT%H:%M:%SZ')
         guid = str(uuid.uuid4())
         embedded_fmu = ", ".join([fmu_name for fmu_name in self.involved_fmu])
@@ -696,61 +745,86 @@ class FMUContainer:
                                                     start_time=self.start_time, stop_time=self.stop_time,
                                                     step_size=step_size))
 
-        vr_time = vr_table.add_vr("real64")
+        vr_time = self.vr_table.add_vr("real64", local=True)
         logger.debug(f"Time vr = {vr_time}")
+
         if profiling:
             for fmu in self.involved_fmu.values():
-                vr = vr_table.add_vr("real64")
+                vr = self.vr_table.add_vr("real64", local=True)
                 port = EmbeddedFMUPort("real64", {"valueReference": vr,
                                         "name": f"container.{fmu.id}.rt_ratio",
                                         "description": f"RT ratio for embedded FMU '{fmu.name}'"})
                 print(f"    {port.xml(vr, fmi_version=self.fmi_version)}", file=xml_file)
 
+        index_offset = 2    # index of output ports. Start at 2 to skip "time" port
+
         # Local variable should be first to ensure to attribute them the lowest VR.
-        for local in self.locals.values():
-            vr = vr_table.add_vr(local.cport_from)
-            try:
-                print(f"    {local.cport_from.port.xml(vr, name=local.name, causality='local', fmi_version=self.fmi_version)}", file=xml_file)
-            except KeyError:
-                logger.error(f"Cannot expose '{local.name}' because type '{local.cport_from.port.type_name}' is not compatible with FMI-{self.fmi_version}.0")
-            local.vr = vr
+        for link in self.links.values():
+            self.vr_table.set_link_vr(link)
+            port_local_def = link.cport_from.port.xml(link.vr, name=link.name, causality='local',
+                                                      fmi_version=self.fmi_version)
+            if port_local_def:
+                print(f"    {port_local_def}", file=xml_file)
+                index_offset += 1
 
         for input_port_name, input_port in self.inputs.items():
-            vr = vr_table.add_vr(input_port.type_name)
+            input_port.vr = self.vr_table.add_vr(input_port.type_name)
             # Get Start and XML from first connected input
             start = self.start_values.get(input_port.cport_list[0], None)
-            print(f"    {input_port.cport_list[0].port.xml(vr, name=input_port_name, start=start, fmi_version=self.fmi_version)}", file=xml_file)
-            input_port.vr = vr
-
-        for output_port_name, cport in self.outputs.items():
-            vr = vr_table.add_vr(cport)
-            print(f"    {cport.port.xml(vr, name=output_port_name, fmi_version=self.fmi_version)}", file=xml_file)
-            cport.vr = vr
+            port_input_def = input_port.cport_list[0].port.xml(input_port.vr, name=input_port_name,
+                                                               start=start, fmi_version=self.fmi_version)
+            if port_input_def:
+                print(f"    {port_input_def}", file=xml_file)
+                index_offset += 1
+
+        for output_port_name, output_port in self.outputs.items():
+            output_port.vr = self.vr_table.add_vr(output_port)
+            port_output_def = output_port.port.xml(output_port.vr, name=output_port_name,
+                                                   fmi_version=self.fmi_version)
+            if port_output_def:
+                print(f"    {port_output_def}", file=xml_file)
 
         if self.fmi_version == 2:
-            self.make_fmu_xml_epilog_2(xml_file)
+            self.make_fmu_xml_epilog_2(xml_file, index_offset)
         elif self.fmi_version == 3:
             self.make_fmu_xml_epilog_3(xml_file)
 
-    def make_fmu_xml_epilog_2(self, xml_file):
-        xml_file.write(f"  </ModelVariables>\n\n  <ModelStructure>\n    <Outputs>\n")
-        index_offset = len(self.locals) + len(self.inputs) + 1
-        for i, _ in enumerate(self.outputs.keys()):
-            print(f'      <Unknown index="{index_offset+i}"/>', file=xml_file)
-
-        xml_file.write("    </Outputs>\n    <InitialUnknowns>\n")
-
-        for i, _ in enumerate(self.outputs.keys()):
-            print(f'      <Unknown index="{index_offset+i}"/>', file=xml_file)
+    def make_fmu_xml_epilog_2(self, xml_file, index_offset):
+        xml_file.write("  </ModelVariables>\n"
+                       "\n"
+                       "  <ModelStructure>\n"
+                       "    <Outputs>\n")
 
-        xml_file.write("    </InitialUnknowns>\n  </ModelStructure>\n\n</fmiModelDescription>")
+        index = index_offset
+        for output in self.outputs.values():
+            if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[2]:
+                print(f'      <Unknown index="{index}"/>', file=xml_file)
+                index += 1
+        xml_file.write("    </Outputs>\n"
+                       "    <InitialUnknowns>\n")
+        index = index_offset
+        for output in self.outputs.values():
+            if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[2]:
+                print(f'      <Unknown index="{index}"/>', file=xml_file)
+                index += 1
+        xml_file.write("    </InitialUnknowns>\n"
+                       "  </ModelStructure>\n"
+                       "\n"
+                       "</fmiModelDescription>")
 
     def make_fmu_xml_epilog_3(self, xml_file):
-        xml_file.write(f"  </ModelVariables>\n\n  <ModelStructure>\n")
+        xml_file.write("  </ModelVariables>\n"
+                       "\n"
+                       "  <ModelStructure>\n")
         for output in self.outputs.values():
-            print(f'      <Output valueReference="{output.vr}"/>', file=xml_file)
-
-        xml_file.write("  </ModelStructure>\n\n</fmiModelDescription>\n""")
+            if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[3]:
+                print(f'      <Output valueReference="{output.vr}"/>', file=xml_file)
+        for output in self.outputs.values():
+            if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[3]:
+                print(f'      <InitialUnknown valueReference="{output.vr}"/>', file=xml_file)
+        xml_file.write("  </ModelStructure>\n"
+                       "\n"
+                       "</fmiModelDescription>")
 
     def make_fmu_txt(self, txt_file, step_size: float, mt: bool, profiling: bool, sequential: bool):
         print("# Container flags <MT> <Profiling> <Sequential>", file=txt_file)
@@ -775,12 +849,13 @@ class FMUContainer:
         inputs_fmu_per_type: Dict[str, Dict[str, Dict[ContainerPort, int]]] = {}      # [type][fmu]
         start_values_fmu_per_type = {}
         outputs_fmu_per_type = {}
-        locals_per_type: Dict[str, List[Local]] = {}
+        local_per_type: Dict[str, List[int]] = {}
+        links_per_fmu: Dict[str, List[Link]] = {}
 
         for type_name in EmbeddedFMUPort.ALL_TYPES:
             inputs_per_type[type_name] = []
             outputs_per_type[type_name] = []
-            locals_per_type[type_name] = []
+            local_per_type[type_name] = []
 
             inputs_fmu_per_type[type_name] = {}
             start_values_fmu_per_type[type_name] = {}
@@ -795,78 +870,88 @@ class FMUContainer:
         # Inputs
         for input_port_name, input_port in self.inputs.items():
             inputs_per_type[input_port.type_name].append(input_port)
-        for cport, value in self.start_values.items():
-            start_values_fmu_per_type[cport.port.type_name][cport.fmu.name][cport] = value
+        for input_port, value in self.start_values.items():
+            start_values_fmu_per_type[input_port.port.type_name][input_port.fmu.name][input_port] = value
         # Outputs
-        for output_port_name, cport in self.outputs.items():
-            outputs_per_type[cport.port.type_name].append(cport)
-        # Locals
-        for local in self.locals.values():
-            vr = local.vr
-            locals_per_type[local.cport_from.port.type_name].append(local)
-            outputs_fmu_per_type[local.cport_from.port.type_name][local.cport_from.fmu.name][local.cport_from] = vr
-            for cport_to in local.cport_to_list:
-                inputs_fmu_per_type[cport_to.port.type_name][cport_to.fmu.name][cport_to] = vr
+        for output_port_name, output_port in self.outputs.items():
+            outputs_per_type[output_port.port.type_name].append(output_port)
+        # Links
+        for link in self.links.values():
+            local_per_type[link.cport_from.port.type_name].append(link.vr)
+            outputs_fmu_per_type[link.cport_from.port.type_name][link.cport_from.fmu.name][link.cport_from] = link.vr
+            for cport_to in link.cport_to_list:
+                if cport_to.port.type_name == link.cport_from.port.type_name:
+                    inputs_fmu_per_type[cport_to.port.type_name][cport_to.fmu.name][cport_to] = link.vr
+                else:
+                    local_per_type[cport_to.port.type_name].append(link.vr_converted[cport_to.port.type_name])
+                    links_per_fmu.setdefault(link.cport_from.fmu.name, []).append(link)
+                    inputs_fmu_per_type[cport_to.port.type_name][cport_to.fmu.name][cport_to] = link.vr_converted[cport_to.port.type_name]
+
 
         print(f"# NB local variables:", ", ".join(EmbeddedFMUPort.ALL_TYPES), file=txt_file)
-        nb_local = []
-        for type_name in EmbeddedFMUPort.ALL_TYPES:
-            nb = len(locals_per_type[type_name])
-            if type_name == "real64":
-                nb += 1  # reserver a slot for "time"
-                if profiling:
-                    nb += len(self.involved_fmu)
-            nb_local.append(str(nb))
+        nb_local = [f"{self.vr_table.nb_local(type_name)}" for type_name in EmbeddedFMUPort.ALL_TYPES]
         print(" ".join(nb_local), file=txt_file, end='')
         print("", file=txt_file)
 
         print("# CONTAINER I/O: <VR> <NB> <FMU_INDEX> <FMU_VR> [<FMU_INDEX> <FMU_VR>]", file=txt_file)
         for type_name in EmbeddedFMUPort.ALL_TYPES:
-            print(f"# {type_name}", file=txt_file)
-            nb = len(inputs_per_type[type_name]) + len(outputs_per_type[type_name]) + len(locals_per_type[type_name])
+            print(f"# {type_name}" , file=txt_file)
+            nb_local = (len(inputs_per_type[type_name]) +
+                        len(outputs_per_type[type_name]) +
+                        self.vr_table.nb_local(type_name))
             nb_input_link = 0
             for input_port in inputs_per_type[type_name]:
                 nb_input_link += len(input_port.cport_list) - 1
-
+            print(f"{nb_local} {nb_local + nb_input_link}", file=txt_file)
             if type_name == "real64":
-                nb += 1  # reserver a slot for "time"
-                if profiling:
-                    nb += len(self.involved_fmu)
-                print(f"{nb} {nb + nb_input_link}", file=txt_file)
                 print(f"0 1 -1 0", file=txt_file)  # Time slot
                 if profiling:
                     for profiling_port, _ in enumerate(self.involved_fmu.values()):
-                        print(f"{profiling_port+1} 1 -2 {profiling_port+1}", file=txt_file)
-            else:
-                print(f"{nb} {nb+nb_input_link}", file=txt_file)
+                        print(f"{profiling_port + 1} 1 -2 {profiling_port + 1}", file=txt_file)
+
             for input_port in inputs_per_type[type_name]:
                 cport_string = [f"{fmu_rank[cport.fmu.name]} {cport.port.vr}" for cport in input_port.cport_list]
                 print(f"{input_port.vr} {len(input_port.cport_list)}", " ".join(cport_string), file=txt_file)
-            for cport in outputs_per_type[type_name]:
-                print(f"{cport.vr} 1 {fmu_rank[cport.fmu.name]} {cport.port.vr}", file=txt_file)
-            for local in locals_per_type[type_name]:
-                print(f"{local.vr} 1 -1 {local.vr & 0xFFFFFF}", file=txt_file)
+            for output_port in outputs_per_type[type_name]:
+                print(f"{output_port.vr} 1 {fmu_rank[output_port.fmu.name]} {output_port.port.vr}", file=txt_file)
+            for local_vr in local_per_type[type_name]:
+                print(f"{local_vr} 1 -1 {local_vr & 0xFFFFFF}", file=txt_file)
 
         # LINKS
         for fmu in self.involved_fmu.values():
             for type_name in EmbeddedFMUPort.ALL_TYPES:
                 print(f"# Inputs of {fmu.name} - {type_name}: <VR> <FMU_VR>", file=txt_file)
                 print(len(inputs_fmu_per_type[type_name][fmu.name]), file=txt_file)
-                for cport, vr in inputs_fmu_per_type[type_name][fmu.name].items():
-                    print(f"{vr} {cport.port.vr}", file=txt_file)
+                for input_port, vr in inputs_fmu_per_type[type_name][fmu.name].items():
+                    print(f"{vr} {input_port.port.vr}", file=txt_file)
 
             for type_name in EmbeddedFMUPort.ALL_TYPES:
                 print(f"# Start values of {fmu.name} - {type_name}: <FMU_VR> <RESET> <VALUE>", file=txt_file)
                 print(len(start_values_fmu_per_type[type_name][fmu.name]), file=txt_file)
-                for cport, value in start_values_fmu_per_type[type_name][fmu.name].items():
-                    reset = 1 if cport.port.causality == "input" else 0
-                    print(f"{cport.port.vr} {reset} {value}", file=txt_file)
+                for input_port, value in start_values_fmu_per_type[type_name][fmu.name].items():
+                    reset = 1 if input_port.port.causality == "input" else 0
+                    print(f"{input_port.port.vr} {reset} {value}", file=txt_file)
 
             for type_name in EmbeddedFMUPort.ALL_TYPES:
                 print(f"# Outputs of {fmu.name} - {type_name}: <VR> <FMU_VR>", file=txt_file)
                 print(len(outputs_fmu_per_type[type_name][fmu.name]), file=txt_file)
-                for cport, vr in outputs_fmu_per_type[type_name][fmu.name].items():
-                    print(f"{vr} {cport.port.vr}", file=txt_file)
+                for output_port, vr in outputs_fmu_per_type[type_name][fmu.name].items():
+                    print(f"{vr} {output_port.port.vr}", file=txt_file)
+
+            print(f"# Conversion table of {fmu.name}: <VR_FROM> <VR_TO> <CONVERSION>", file=txt_file)
+            try:
+                nb = 0
+                for link in links_per_fmu[fmu.name]:
+                    nb += len(link.vr_converted)
+                print(f"{nb}", file=txt_file)
+                for link in links_per_fmu[fmu.name]:
+                    for cport_to in link.cport_to_list:
+                        conversion =  link.get_conversion(cport_to)
+                        if conversion:
+                            print(f"{link.vr} {link.vr_converted[cport_to.port.type_name]} {conversion}",
+                                  file=txt_file)
+            except KeyError:
+                print("0", file=txt_file)
 
     @staticmethod
     def long_path(path: Union[str, Path]) -> str:
@@ -881,7 +966,7 @@ class FMUContainer:
         logger.debug(f"Copying {origin} in {destination}")
         shutil.copy(origin, destination)
 
-    def get_bindir_and_suffixe(self) -> (str, str, str):
+    def get_bindir_and_suffixe(self) -> Tuple[str, str, str]:
         suffixes = {
             "Windows": "dll",
             "Linux": "so",

fmu_manipulation_toolbox/gui.py

@@ -2,22 +2,24 @@ import os.path
 import sys
 import textwrap
 
-from PySide6.QtCore import Qt, QObject, QUrl, QDir, Signal, QPoint, QModelIndex
+from PySide6.QtCore import Qt, QUrl, QDir, Signal, QPoint, QModelIndex
 from PySide6.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel, QLineEdit, QPushButton, QFileDialog,
                                QTextBrowser, QInputDialog, QMenu, QTreeView, QAbstractItemView, QTabWidget, QTableView,
                                QCheckBox)
 from PySide6.QtGui import (QPixmap, QTextCursor, QStandardItem, QIcon, QDesktopServices, QAction,
                            QPainter, QColor, QImage, QStandardItemModel)
 from functools import partial
-from typing import Optional
 
-from .gui_style import gui_style
+
+from .gui_style import gui_style, log_color
 from .operations import *
 from .assembly import Assembly, AssemblyNode
 from .checker import checker_list
 from .help import Help
 from .version import __version__ as version
 
+logger = logging.getLogger("fmu_manipulation_toolbox")
+
 
 class DropZoneWidget(QLabel):
     WIDTH = 150
@@ -51,7 +53,7 @@ class DropZoneWidget(QLabel):
             try:
                 file_path = event.mimeData().urls()[0].toLocalFile()
             except IndexError:
-                print("Please select a regular file.")
+                logger.error("Please select a regular file.")
                 return
             self.set_fmu(file_path)
             event.accept()
@@ -98,54 +100,41 @@ class DropZoneWidget(QLabel):
             self.fmu = FMU(filename)
             self.set_image(os.path.join(self.fmu.tmp_directory, "model.png"))
         except Exception as e:
-            print(f"ERROR: Cannot load this FMU: {e}")
+            logger.error(f"Cannot load this FMU: {e}")
             self.set_image(None)
             self.fmu = None
         self.clicked.emit()
 
 
+class LogHandler(logging.Handler):
+    LOG_COLOR = {
+        logging.DEBUG: QColor(log_color["DEBUG"]),
+        logging.INFO: QColor(log_color["INFO"]),
+        logging.WARNING: QColor(log_color["WARNING"]),
+        logging.ERROR: QColor(log_color["ERROR"]),
+        logging.CRITICAL: QColor(log_color["CRITICAL"]),
+    }
+
+    def __init__(self, text_browser, level):
+        super().__init__(level)
+        self.text_browser: QTextBrowser = text_browser
+        logger.addHandler(self)
+        logger.setLevel(level)
+
+    def emit(self, record) -> None:
+        self.text_browser.setTextColor(self.LOG_COLOR[record.levelno])
+        self.text_browser.insertPlainText(record.msg+"\n")
+
+
 class LogWidget(QTextBrowser):
-    class XStream(QObject):
-        _stdout = None
-        _stderr = None
-        messageWritten = Signal(str)
-
-        def __init__(self):
-            super().__init__()
-
-        def flush(self):
-            pass
-
-        @staticmethod
-        def fileno():
-            return -1
-
-        def write(self, msg):
-            if not self.signalsBlocked():
-                self.messageWritten.emit(msg)
-
-        @staticmethod
-        def stdout():
-            if not LogWidget.XStream._stdout:
-                LogWidget.XStream._stdout = LogWidget.XStream()
-                sys.stdout = LogWidget.XStream._stdout
-            return LogWidget.XStream._stdout
-
-        @staticmethod
-        def stderr():
-            if not LogWidget.XStream._stderr:
-                LogWidget.XStream._stderr = LogWidget.XStream()
-                sys.stderr = LogWidget.XStream._stderr
-            return LogWidget.XStream._stderr
+    def __init__(self, parent=None, level=logging.INFO):
+        super().__init__(parent)
 
-    def __init__(self):
-        super().__init__()
         self.setMinimumWidth(900)
         self.setMinimumHeight(500)
         self.setSearchPaths([os.path.join(os.path.dirname(__file__), "resources")])
         self.insertHtml('<center><img src="fmu_manipulation_toolbox.png"/></center><br/>')
-        LogWidget.XStream.stdout().messageWritten.connect(self.insertPlainText)
-        LogWidget.XStream.stderr().messageWritten.connect(self.insertPlainText)
+        self.log_handler = LogHandler(self, logging.DEBUG)
 
     def loadResource(self, _, name):
         image_path = os.path.join(os.path.dirname(__file__), "resources", name.toString())
@@ -255,10 +244,10 @@ class AssemblyTreeWidget(QTreeView):
 
         def removeRows(self, row, count, parent=QModelIndex()):
             if not self.dnd_target_node:
-                print("NO DROP NODE!?")
+                logger.error("NO DROP NODE!?")
 
             source_index = self.itemFromIndex(parent).child(row, 0).data(role=Qt.ItemDataRole.UserRole+1)
-            print(f"{source_index} ==> {self.dnd_target_node.name}")
+            logger.debug(f"{source_index} ==> {self.dnd_target_node.name}")
 
             self.dnd_target_node = None
             return super().removeRows(row, count, parent)
@@ -289,7 +278,7 @@ class AssemblyTreeWidget(QTreeView):
 
     def setTopIndex(self):
         topIndex = self.model.index(0, 0, self.rootIndex())
-        print(topIndex.isValid(), topIndex.model())
+        logger.debug(topIndex.isValid(), topIndex.model())
         if topIndex.isValid():
             self.setCurrentIndex(topIndex)
             if self.layoutCheck:
@@ -318,9 +307,9 @@ class AssemblyTreeWidget(QTreeView):
             try:
                 file_path = event.mimeData().urls()[0].toLocalFile()
             except IndexError:
-                print("Please select a regular file.")
+                logger.error("Please select a regular file.")
                 return
-            print(f"DROP: {file_path}")
+            logger.debug(f"DROP: {file_path}")
             event.accept()
         else:
             event.ignore()
@@ -518,7 +507,7 @@ class MainWindow(WindowWithLayout):
                                                        "FMU files (*.fmu)")
             if ok and filename:
                 fmu.repack(filename)
-                print(f"Modified version saved as {filename}.")
+                logger.info(f"Modified version saved as {filename}.")
 
     def save_log(self):
         if self.dropped_fmu.fmu:
@@ -533,7 +522,7 @@ class MainWindow(WindowWithLayout):
                 with open(filename, "wt") as file:
                     file.write(str(self.log_widget.toPlainText()))
             except Exception as e:
-                print(f"ERROR: {e}")
+                logger.error(f"{e}")
 
     def add_operation(self, name, usage, severity, operation, x, y, prompt=None, prompt_file=None, arg=None,
                       func=None):
@@ -603,18 +592,18 @@ class MainWindow(WindowWithLayout):
         if self.dropped_fmu.fmu:
             self.log_widget.moveCursor(QTextCursor.MoveOperation.End)
             fmu_filename = os.path.basename(self.dropped_fmu.fmu.fmu_filename)
-            print('-' * 100)
+            logger.info('-' * 100)
             self.log_widget.insertHtml(f"<strong>{fmu_filename}: {operation}</strong><br>")
 
             apply_on = self.filter_list.get()
             if apply_on:
                 self.log_widget.insertHtml(f"<i>Applied only for ports with  causality = " +
                                            ", ".join(apply_on) + "</i><br>")
-            print('-' * 100)
+            logger.info('-' * 100)
             try:
                 self.dropped_fmu.fmu.apply_operation(operation, apply_on=apply_on)
             except Exception as e:
-                print(f"ERROR: {e}")
+                logger.error(f"{e}")
 
             scroll_bar = self.log_widget.verticalScrollBar()
             scroll_bar.setValue(scroll_bar.maximum())
@@ -712,7 +701,7 @@ class ContainerWindow(WindowWithLayout):
                 self.last_directory = os.path.dirname(filename)
                 self.assembly_tree.load_container(filename)
             except Exception as e:
-                print(e)
+                logger.error(e)
 
 
 class Application(QApplication):
@@ -724,8 +713,9 @@ Communicating with the FMU-developer and adapting the way the FMU is generated,
 
     """
     def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
         self.setHighDpiScaleFactorRoundingPolicy(Qt.HighDpiScaleFactorRoundingPolicy.RoundPreferFloor)
+        super().__init__(*args, **kwargs)
+
 
         QDir.addSearchPath('images', os.path.join(os.path.dirname(__file__), "resources"))
         self.setStyleSheet(gui_style)
@@ -747,8 +737,8 @@ Communicating with the FMU-developer and adapting the way the FMU is generated,
 def main():
     application = Application(sys.argv)
 
-    print(" " * 80, f"Version {version}")
-    print(application.__doc__)
+    logger.info(" " * 80 + f"Version {version}")
+    logger.info(application.__doc__)
 
     sys.exit(application.exec())
 

fmu_manipulation_toolbox/gui_style.py

@@ -242,3 +242,11 @@ else:
         margin-left: 0;
     }
     """
+
+log_color = {
+    "DEBUG": "#6E6B6B",
+    "INFO": "#b5bab9",
+    "WARNING": "#F7C61B",
+    "ERROR": "#F54927",
+    "CRITICAL": "#FF00FF",
+}

fmu_manipulation_toolbox/operations.py

@@ -1,5 +1,6 @@
 import csv
 import html
+import logging
 import os
 import re
 import shutil
@@ -10,6 +11,7 @@ import hashlib
 from pathlib import Path
 from typing import *
 
+logger = logging.getLogger("fmu_manipulation_toolbox")
 
 class FMU:
     """Unpack and Repack facilities for FMU package. Once unpacked, we can process Operation on
@@ -57,6 +59,7 @@ class FMUPort:
     def __init__(self):
         self.fmi_type = None
         self.attrs_list: List[Dict] = []
+        self.dimension = None
 
     def dict_level(self, nb):
         return " ".join([f'{key}="{value}"' for key, value in self.attrs_list[nb].items()])
@@ -99,9 +102,6 @@ class FMUPort:
     def push_attrs(self, attrs):
         self.attrs_list.append(attrs)
 
-    def is_ready(self):
-        return self.fmi_type is not None
-
 
 class FMUError(Exception):
     def __init__(self, reason):
@@ -130,6 +130,7 @@ class Manipulation:
         self.current_port_number: int = 0
         self.port_translation: List[Optional[int]] = []
         self.port_names_list: List[str] = []
+        self.port_removed_vr: Set[str] = set()
         self.apply_on = None
 
     @staticmethod
@@ -142,9 +143,11 @@ class Manipulation:
     def handle_port(self):
         causality = self.current_port.get('causality', 'local')
         port_name = self.current_port['name']
+        vr = self.current_port['valueReference']
         if not self.apply_on or causality in self.apply_on:
             if self.operation.port_attrs(self.current_port):
-                self.remove_port(port_name)
+                self.remove_port(port_name, vr)
+                # Exception is raised by remove port !
             else:
                 self.keep_port(port_name)
         else:  # Keep ScalarVariable as it is.
@@ -171,21 +174,16 @@ class Manipulation:
             elif name == 'fmiModelDescription':
                 self.fmu.fmi_version = int(float(attrs["fmiVersion"]))
                 self.operation.fmi_attrs(attrs)
-            elif name == 'Unknown':
+            elif name == 'Unknown': # FMI-2.0 only
                 self.unknown_attrs(attrs)
-
-            if self.current_port and self.current_port.is_ready():
-                self.handle_port()
+            elif name == 'Output' or name == "ContinuousStateDerivative" or "InitialUnknown":
+                self.handle_structure(attrs)
 
         except ManipulationSkipTag:
             self.skip_until = name
             return
 
-        if self.current_port:
-            if self.current_port.is_ready():
-                self.current_port.write_xml(self.fmu.fmi_version, self.out)
-                self.current_port = None
-        else: # re-copy tags
+        if self.current_port is None:
             if attrs:
                 attrs_list = [f'{key}="{self.escape(value)}"' for (key, value) in attrs.items()]
                 print(f"<{name}", " ".join(attrs_list), ">", end='', file=self.out)
@@ -198,16 +196,25 @@ class Manipulation:
                 self.skip_until = None
             return
         else:
-            if name not in FMU.FMI3_TYPES and name not in FMU.FMI2_TYPES and not name == "ScalarVariable":
+            if name == "ScalarVariable" or (self.fmu.fmi_version == 3 and name in FMU.FMI3_TYPES):
+                try:
+                    self.handle_port()
+                    self.current_port.write_xml(self.fmu.fmi_version, self.out)
+                except ManipulationSkipTag:
+                    logger.info(f"Port '{self.current_port['name']}' is removed.")
+                self.current_port = None
+
+            elif self.current_port is None:
                 print(f"</{name}>", end='', file=self.out)
 
     def char_data(self, data):
         if not self.skip_until:
             print(data, end='', file=self.out)
 
-    def remove_port(self, name):
+    def remove_port(self, name, vr):
         self.port_names_list.append(name)
         self.port_translation.append(None)
+        self.port_removed_vr.add(vr)
         raise ManipulationSkipTag
 
     def keep_port(self, name):
@@ -221,9 +228,29 @@ class Manipulation:
         if new_index:
             attrs['index'] = self.port_translation[int(attrs['index']) - 1]
         else:
-            print(f"WARNING: Removed port '{self.port_names_list[index]}' is involved in dependencies tree.")
+            logger.warning(f"Removed port '{self.port_names_list[index]}' is involved in dependencies tree.")
             raise ManipulationSkipTag
 
+    def handle_structure(self, attrs):
+        try:
+            vr = attrs['valueReference']
+            if vr in self.port_removed_vr:
+                raise ManipulationSkipTag
+        except KeyError:
+            return
+
+        try:
+            dependencies = attrs['dependencies']
+            new_dependencies = []
+            for dependency in dependencies.split(" "):
+                if dependency in self.port_removed_vr:
+                    logger.warning(f"Removed port 'vr={dependency}' was involved in dependencies tree.")
+                else:
+                    new_dependencies.append(dependency)
+            attrs['dependencies'] = " ".join(new_dependencies)
+        except KeyError:
+            return
+
     def manipulate(self, descriptor_filename, apply_on=None):
         self.apply_on = apply_on
         with open(self.output_filename, "w", encoding="utf-8") as self.out, open(descriptor_filename, "rb") as file:
@@ -347,7 +374,7 @@ class OperationAddRemotingWinAbstract(OperationAbstract):
         return f"Add '{self.bitness_to}' remoting on '{self.bitness_from}' FMU"
 
     def fmi_attrs(self, attrs):
-        if not attrs["fmi_version"] == "2.0":
+        if not attrs["fmiVersion"] == "2.0":
             raise OperationError(f"Adding remoting is only available for FMI-2.0")
 
     def cosimulation_attrs(self, attrs):
@@ -360,7 +387,7 @@ class OperationAddRemotingWinAbstract(OperationAbstract):
             raise OperationError(f"{self.bitness_from} interface does not exist")
 
         if os.path.isdir(fmu_bin[self.bitness_to]):
-            print(f"INFO: {self.bitness_to} already exists. Add front-end.")
+            logger.info(f"{self.bitness_to} already exists. Add front-end.")
             shutil.move(os.path.join(fmu_bin[self.bitness_to], attrs['modelIdentifier'] + ".dll"),
                         os.path.join(fmu_bin[self.bitness_to], attrs['modelIdentifier'] + "-remoted.dll"))
         else:
@@ -440,31 +467,31 @@ class OperationSummary(OperationAbstract):
         return f"FMU Summary"
 
     def fmi_attrs(self, attrs):
-        print(f"| fmu filename = {self.fmu.fmu_filename}")
-        print(f"| temporary directory = {self.fmu.tmp_directory}")
+        logger.info(f"| fmu filename = {self.fmu.fmu_filename}")
+        logger.info(f"| temporary directory = {self.fmu.tmp_directory}")
         hash_md5 = hashlib.md5()
         with open(self.fmu.fmu_filename, "rb") as f:
             for chunk in iter(lambda: f.read(4096), b""):
                 hash_md5.update(chunk)
         digest = hash_md5.hexdigest()
-        print(f"| MD5Sum = {digest}")
+        logger.info(f"| MD5Sum = {digest}")
 
-        print(f"|\n| FMI properties: ")
+        logger.info(f"|\n| FMI properties: ")
         for (k, v) in attrs.items():
-            print(f"|  - {k} = {v}")
-        print(f"|")
+            logger.info(f"|  - {k} = {v}")
+        logger.info(f"|")
 
     def cosimulation_attrs(self, attrs):
-        print("| Co-Simulation capabilities: ")
+        logger.info("| Co-Simulation capabilities: ")
         for (k, v) in attrs.items():
-            print(f"|  - {k} = {v}")
-        print(f"|")
+            logger.info(f"|  - {k} = {v}")
+        logger.info(f"|")
 
     def experiment_attrs(self, attrs):
-        print("| Default Experiment values: ")
+        logger.info("| Default Experiment values: ")
         for (k, v) in attrs.items():
-            print(f"|  - {k} = {v}")
-        print(f"|")
+            logger.info(f"|  - {k} = {v}")
+        logger.info(f"|")
 
     def port_attrs(self, fmu_port) -> int:
         causality = fmu_port.get("causality", "local")
@@ -477,33 +504,33 @@ class OperationSummary(OperationAbstract):
         return 0
 
     def closure(self):
-        print("| Supported platforms: ")
+        logger.info("| Supported platforms: ")
         try:
             for platform in os.listdir(os.path.join(self.fmu.tmp_directory, "binaries")):
-                print(f"|  - {platform}")
+                logger.info(f"|  - {platform}")
         except FileNotFoundError:
             pass  # no binaries
 
         if os.path.isdir(os.path.join(self.fmu.tmp_directory, "sources")):
-            print(f"|  - RT (sources available)")
+            logger.info(f"|  - RT (sources available)")
 
         resource_dir = os.path.join(self.fmu.tmp_directory, "resources")
         if os.path.isdir(resource_dir):
-            print("|\n| Embedded resources:")
+            logger.info("|\n| Embedded resources:")
             for resource in os.listdir(resource_dir):
-                print(f"|  - {resource}")
+                logger.info(f"|  - {resource}")
 
         extra_dir = os.path.join(self.fmu.tmp_directory, "extra")
         if os.path.isdir(extra_dir):
-            print("|\n| Additional (meta-)data:")
+            logger.info("|\n| Additional (meta-)data:")
             for extra in os.listdir(extra_dir):
-                print(f"|  - {extra}")
+                logger.info(f"|  - {extra}")
 
-        print("|\n| Number of signals")
+        logger.info("|\n| Number of ports")
         for causality, nb_ports in self.nb_port_per_causality.items():
-            print(f"|  {causality} : {nb_ports}")
+            logger.info(f"|  {causality} : {nb_ports}")
 
-        print("|\n| [End of report]")
+        logger.info("|\n| [End of report]")
 
 
 class OperationRemoveSources(OperationAbstract):
@@ -514,7 +541,7 @@ class OperationRemoveSources(OperationAbstract):
         try:
             shutil.rmtree(os.path.join(self.fmu.tmp_directory, "sources"))
         except FileNotFoundError:
-            print("This FMU does not embed sources.")
+            logger.info("This FMU does not embed sources.")
 
 
 class OperationTrimUntil(OperationAbstract):

{fmu_manipulation_toolbox-1.9rc1.dist-info → fmu_manipulation_toolbox-1.9rc3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9rc1
+Version: 1.9rc3
 Summary: FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) without recompilation or bundling them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com

{fmu_manipulation_toolbox-1.9rc1.dist-info → fmu_manipulation_toolbox-1.9rc3.dist-info}/RECORD

@@ -1,13 +1,13 @@
-fmu_manipulation_toolbox/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-fmu_manipulation_toolbox/__main__.py,sha256=mAzrtkil506DS0F3g3CEbHdtZsZotzntcNhIn_lNJkw,344
-fmu_manipulation_toolbox/__version__.py,sha256=hYFpHuopEP58yzpI84myHNi5TvdMTGgMf2b3lGAPyRY,12
-fmu_manipulation_toolbox/assembly.py,sha256=cz8Z6zO3tWfNEj62ZEvU5pMv4byXs-F6Ri21YxLAYFs,26528
-fmu_manipulation_toolbox/checker.py,sha256=836wCri6aEl0M6_xHPZ94JRngFjsy8Ee-_t8bzclxBs,2332
-fmu_manipulation_toolbox/container.py,sha256=M8jL2WhjKqZ8pHSSSplys9eqTjGvubcAz0ggsH8nYpI,40556
-fmu_manipulation_toolbox/gui.py,sha256=tVTPLbGZlD5P0WYqaD5B4crG2nHjBGe73yAJrzRXpYE,29218
-fmu_manipulation_toolbox/gui_style.py,sha256=uzEruJumnC5Vf2cfHXVa_c-SHAQoTvDWemro3-b9Mpc,6492
+fmu_manipulation_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu_manipulation_toolbox/__main__.py,sha256=FpG0ITBz5q-AvIbXplVh_1g1zla5souFGtpiDdECxEw,352
+fmu_manipulation_toolbox/__version__.py,sha256=CGyZIselV5kCL6An0m7aR4m-Y2X2IRQadcj88KEF3Ps,11
+fmu_manipulation_toolbox/assembly.py,sha256=XQ_1sB6K1Dk2mnNe-E3_6Opoeub7F9Qaln0EUDzsop8,26553
+fmu_manipulation_toolbox/checker.py,sha256=jw1omfrMMIMHlIpHXpWBcQgIiS9hnHe5T9CZ5KlbVGs,2422
+fmu_manipulation_toolbox/container.py,sha256=8Wf16sgUPkY-ByWeKt-3TD_4vNRQuLwH9Gs7D2Q6tAk,44959
+fmu_manipulation_toolbox/gui.py,sha256=iOJ3F_zfw3mU34VofZrYdaffljTmYfuy33fJXlLaOwg,29045
+fmu_manipulation_toolbox/gui_style.py,sha256=s6WdrnNd_lCMWhuBf5LKK8wrfLXCU7pFTLUfvqkJVno,6633
 fmu_manipulation_toolbox/help.py,sha256=aklKiLrsE0adSzQ5uoEB1sBDmI6s4l231gavu4XxxzA,5856
-fmu_manipulation_toolbox/operations.py,sha256=-oOHWLm15XbiVgIM8rbOinO2haqyH-5VF6WpFGGVxNg,18174
+fmu_manipulation_toolbox/operations.py,sha256=b7N5AVHLIpQO8od4BYasb9CppHJ-ZmW8mu0ZdhndoHI,19472
 fmu_manipulation_toolbox/split.py,sha256=NVkfdTRR0jj_VOdgtxHQoKptkAg5TFVUA7nUx3_o9Pg,13336
 fmu_manipulation_toolbox/version.py,sha256=OhBLkZ1-nhC77kyvffPNAf6m8OZe1bYTnNf_PWs1NvM,392
 fmu_manipulation_toolbox/resources/checkbox-checked-disabled.png,sha256=FWIuyrXlaNLLePHfXj7j9ca5rT8Hgr14KCe1EqTCZyk,2288
@@ -27,7 +27,7 @@ fmu_manipulation_toolbox/resources/icon_fmu.png,sha256=EuygB2xcoM2WAfKKdyKG_UvTL
 fmu_manipulation_toolbox/resources/license.txt,sha256=5ODuU8g8pIkK-NMWXu_rjZ6k7gM7b-N2rmg87-2Kmqw,1583
 fmu_manipulation_toolbox/resources/mask.png,sha256=px1U4hQGL0AmZ4BQPknOVREpMpTSejbah3ntkpqAzFA,3008
 fmu_manipulation_toolbox/resources/model.png,sha256=EAf_HnZJe8zYGZygerG1MMt2U-tMMZlifzXPj4_iORA,208788
-fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=9L9N8rXVI6sYEDZAQdDymX6Z0GmFwj3_GhrtiBh1pTM,144760
+fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=qYV-5d35a7OmSHjYejuTRG8TurfctN5rkF-YjQua-Zo,161560
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2Annotation.xsd,sha256=OGfyJtaJntKypX5KDpuZ-nV1oYLZ6HV16pkpKOmYox4,2731
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2AttributeGroups.xsd,sha256=HwyV7LBse-PQSv4z1xjmtzPU3Hjnv4mluq9YdSBNHMQ,3704
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2ModelDescription.xsd,sha256=JM4j_9q-pc40XYHb28jfT3iV3aYM5JLqD5aRjO72K1E,18939
@@ -50,16 +50,16 @@ fmu_manipulation_toolbox/resources/fmi-3.0/fmi3VariableDependency.xsd,sha256=YQS
 fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=xVdY2zy13pa2DcvFiweSNpp7E6DiONqeoBdlcJHrW_k,35940
 fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=1TLGqNPyM5UVOrCfzNqWyF6ClLksY3EiY3CSsrnp6c0,22836
 fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=EhY1XHo1YcQn6yqZ7wk5okqtZyp0MrcCsGcudqE-aIM,37000
-fmu_manipulation_toolbox/resources/linux64/container.so,sha256=b1BizAi-7Ag0vHBk_HjiXhBWpMnkV4Cju2FGMYqCQ7w,131144
+fmu_manipulation_toolbox/resources/linux64/container.so,sha256=KT6_GdTc0saR-H6l2-0udaJtEDiHnzlFBIp0FtlOtrw,135520
 fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=ulfoPvmaYe9nInYcVEyj7mD9zDzGk56OUoWx1mPKLiE,22768
-fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=HkGkuf0HTsBQSCWeiTDYb2kANc2CjsjhVo9Qk8KLLl0,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=2vrLiRdBoBUSckrSJhvt9F_hJowYv7_qVo0weKVeXBc,15872
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=df4rfG-SyW0EClifv8PDYqzhKMOvzwZnanaS_8lDxC8,22016
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=TOJIEULG8TF2vdHbfi2Adwt1NnuLsEbMvchZhzO0P6s,93696
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=PFueL3UzAVwSz8QBmysbY4Mr9G2lVcjdrFYEyWuTDRU,19968
-fmu_manipulation_toolbox-1.9rc1.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
-fmu_manipulation_toolbox-1.9rc1.dist-info/METADATA,sha256=595mII6g6nVb5iilo-HAvp95-TSS_8yl-95y_vicFrs,1156
-fmu_manipulation_toolbox-1.9rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_manipulation_toolbox-1.9rc1.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
-fmu_manipulation_toolbox-1.9rc1.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.9rc1.dist-info/RECORD,,
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=q91IE2IFDzchUukNc93c7MkRHgKYA3ll3CnKthPfKB0,17920
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=cTmbVSx_wyD-VcJMXgQWvfmByzrb9lJnTlp9Dzdu9sA,15872
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=RYaQA4l0iOis-QbnCz_T1zRnuDTlWFtt-FzWnEnenag,22016
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=vBslbM-PWm9Dj4zTwhElqm9EPHFwv4BV9obBEb0sx9I,98816
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=oKiRKA1irVkkL-P84bOU1TC7K9h_xrnr_4EGJqoYIfU,19968
+fmu_manipulation_toolbox-1.9rc3.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
+fmu_manipulation_toolbox-1.9rc3.dist-info/METADATA,sha256=4E3iWPeD60EJzvvBjPFnWqMI6cIEMn3wxsaLjmZwkNw,1156
+fmu_manipulation_toolbox-1.9rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_manipulation_toolbox-1.9rc3.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
+fmu_manipulation_toolbox-1.9rc3.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.9rc3.dist-info/RECORD,,