fmu-manipulation-toolbox 1.7.5__py3-none-any.whl → 1.8.1__py3-none-any.whl

fmu_manipulation_toolbox/__version__.py

@@ -1 +1 @@
-'V1.7.5'
+'V1.8.1'

fmu_manipulation_toolbox/assembly.py

@@ -0,0 +1,484 @@
+import csv
+import json
+import logging
+from typing import *
+from pathlib import Path
+import uuid
+import xml.parsers.expat
+import zipfile
+
+from .fmu_container import FMUContainer
+
+logger = logging.getLogger("fmu_manipulation_toolbox")
+
+
+class Port:
+    def __init__(self, fmu_name: str, port_name: str):
+        self.fmu_name = fmu_name
+        self.port_name = port_name
+
+    def __hash__(self):
+        return hash(f"{self.fmu_name}/{self.port_name}")
+
+    def __eq__(self, other):
+        return str(self) == str(other)
+
+
+class Connection:
+    def __init__(self, from_port: Port, to_port: Port):
+        self.from_port = from_port
+        self.to_port = to_port
+
+
+class AssemblyNode:
+    def __init__(self, name: Optional[str], step_size: float = None, mt=False, profiling=False,
+                 auto_link=True, auto_input=True, auto_output=True):
+        self.name = name
+        if step_size:
+            try:
+                self.step_size = float(step_size)
+            except ValueError:
+                logger.warning(f"Step size '{step_size}' is incorrect format.")
+                self.step_size = None
+        else:
+            self.step_size = None
+        self.mt = mt
+        self.profiling = profiling
+        self.auto_link = auto_link
+        self.auto_input = auto_input
+        self.auto_output = auto_output
+
+        self.parent: Optional[AssemblyNode] = None
+        self.children: List[AssemblyNode] = []          # sub-containers
+        self.fmu_names_list: Set[str] = set()           # FMUs contained at this level
+        self.input_ports: Dict[Port, str] = {}
+        self.output_ports: Dict[Port, str] = {}
+        self.start_values: Dict[Port, str] = {}
+        self.drop_ports: List[Port] = []
+        self.links: List[Connection] = []
+
+    def add_sub_node(self, sub_node):
+        if sub_node.name is None:
+            sub_node.name = str(uuid.uuid4())+".fmu"
+
+        if sub_node.parent is not None:
+            raise AssemblyError(f"Internal Error: AssemblyNode {sub_node.name} is already parented.")
+
+        sub_node.parent = self
+        self.fmu_names_list.add(sub_node.name)
+        self.children.append(sub_node)
+
+
+    def add_fmu(self, fmu_name: str):
+        self.fmu_names_list.add(fmu_name)
+
+    def add_input(self, from_port_name: str, to_fmu_filename: str, to_port_name: str):
+        self.input_ports[Port(to_fmu_filename, to_port_name)] = from_port_name
+
+    def add_output(self, from_fmu_filename: str, from_port_name: str, to_port_name: str):
+        self.output_ports[Port(from_fmu_filename, from_port_name)] = to_port_name
+
+    def add_drop_port(self, fmu_filename: str, port_name: str):
+        self.drop_ports.append(Port(fmu_filename, port_name))
+
+    def add_link(self, from_fmu_filename: str, from_port_name: str, to_fmu_filename: str, to_port_name: str):
+        self.links.append(Connection(Port(from_fmu_filename, from_port_name),
+                          Port(to_fmu_filename, to_port_name)))
+
+    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):
+        for node in self.children:
+            node.make_fmu(fmu_directory, debug=debug)
+
+        container = FMUContainer(self.name, fmu_directory, description_pathname=description_pathname)
+
+        for fmu_name in sorted(self.fmu_names_list):
+            container.get_fmu(fmu_name)
+
+        for port, source in self.input_ports.items():
+            container.add_input(source, port.fmu_name, port.port_name)
+
+        for port, target in self.output_ports.items():
+            container.add_output(port.fmu_name, port.port_name, target)
+
+        for link in self.links:
+            container.add_link(link.from_port.fmu_name, link.from_port.port_name,
+                               link.to_port.fmu_name, link.to_port.port_name)
+
+        for drop in self.drop_ports:
+            container.drop_port(drop.fmu_name, drop.port_name)
+
+        for port, value in self.start_values.items():
+            container.add_start_value(port.fmu_name, port.port_name, value)
+
+        container.add_implicit_rule(auto_input=self.auto_input,
+                                    auto_output=self.auto_output,
+                                    auto_link=self.auto_link)
+
+        container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, debug=debug)
+
+        for node in self.children:
+            logger.info(f"Deleting transient FMU Container '{node.name}'")
+            (fmu_directory / node.name).unlink()
+
+
+class AssemblyError(Exception):
+    def __init__(self, reason: str):
+        self.reason = reason
+
+    def __repr__(self):
+        return f"{self.reason}"
+
+
+class Assembly:
+    def __init__(self, filename: str, step_size=None, auto_link=True,  auto_input=True, debug=False,
+                 auto_output=True, mt=False, profiling=False, fmu_directory: Path = "."):
+        self.filename = Path(filename)
+        self.default_auto_input = auto_input
+        self.debug = debug
+        self.default_auto_output = auto_output
+        self.default_step_size = step_size
+        self.default_auto_link = auto_link
+        self.default_mt = mt
+        self.default_profiling = profiling
+        self.fmu_directory = fmu_directory
+        self.transient_filenames: List[Path] = []
+        self.transient_dirnames: Set[Path] = set()
+
+        if not fmu_directory.is_dir():
+            raise AssemblyError(f"FMU directory is not valid: '{fmu_directory}'")
+
+        self.input_pathname = fmu_directory / self.filename
+        self.description_pathname = self.input_pathname   # For inclusion in FMU
+        self.root = None
+        self.read()
+
+    def add_transient_file(self, filename: str):
+        self.transient_filenames.append(self.fmu_directory / filename)
+        self.transient_dirnames.add(Path(filename).parent)
+
+    def __del__(self):
+        if not self.debug:
+            for filename in self.transient_filenames:
+                try:
+                    filename.unlink()
+                except FileNotFoundError:
+                    pass
+            for dirname in self.transient_dirnames:
+                while not str(dirname) == ".":
+                    try:
+                        (self.fmu_directory / dirname).rmdir()
+                    except FileNotFoundError:
+                        pass
+                    dirname = dirname.parent
+
+    def read(self):
+        logger.info(f"Reading '{self.filename}'")
+        if self.filename.suffix == ".json":
+            self.read_json()
+        elif self.filename.suffix == ".ssp":
+            self.read_ssp()
+        elif self.filename.suffix == ".csv":
+            self.read_csv()
+        else:
+            raise AssemblyError(f"Not supported file format '{self.filename}")
+
+    def write(self, filename: str):
+        if filename.endswith(".csv"):
+            return self.write_csv(filename)
+        elif filename.endswith(".json"):
+            return self.write_json(filename)
+        else:
+            logger.critical(f"Unable to write to '{filename}': format unsupported.")
+
+    def read_csv(self):
+        name = str(self.filename.with_suffix(".fmu"))
+        self.root = AssemblyNode(name, step_size=self.default_step_size, auto_link=self.default_auto_link,
+                                 mt=self.default_mt, profiling=self.default_profiling,
+                                 auto_input=self.default_auto_input, auto_output=self.default_auto_output)
+
+        with open(self.input_pathname) as file:
+            reader = csv.reader(file, delimiter=';')
+            self._check_csv_headers(reader)
+            for i, row in enumerate(reader):
+                if not row or row[0][0] == '#':  # skip blank line of comment
+                    continue
+
+                try:
+                    rule, from_fmu_filename, from_port_name, to_fmu_filename, to_port_name = row
+                except ValueError:
+                    logger.error(f"Line #{i+2}: expecting 5 columns. Line skipped.")
+                    continue
+
+                try:
+                    self._read_csv_rule(self.root, rule.upper(),
+                                        from_fmu_filename, from_port_name, to_fmu_filename, to_port_name)
+                except AssemblyError as e:
+                    logger.error(f"Line #{i+2}: {e}. Line skipped.")
+                    continue
+
+    @staticmethod
+    def _check_csv_headers(reader):
+        headers = next(reader)
+        headers_lowered = [h.lower() for h in headers]
+        if not headers_lowered == ["rule", "from_fmu", "from_port", "to_fmu", "to_port"]:
+            raise AssemblyError("Header (1st line of the file) is not well formatted.")
+
+    @staticmethod
+    def _read_csv_rule(node: AssemblyNode, rule: str, from_fmu_filename: str, from_port_name: str,
+                       to_fmu_filename: str, to_port_name: str):
+        if rule == "FMU":
+            if not from_fmu_filename:
+                raise AssemblyError("Missing FMU information.")
+            node.add_fmu(from_fmu_filename)
+
+        elif rule == "INPUT":
+            if not to_fmu_filename or not to_port_name:
+                raise AssemblyError("Missing INPUT ports information.")
+            if not from_port_name:
+                from_port_name = to_port_name
+            node.add_input(from_port_name, to_fmu_filename, to_port_name)
+
+        elif rule == "OUTPUT":
+            if not from_fmu_filename or not from_port_name:
+                raise AssemblyError("Missing OUTPUT ports information.")
+            if not to_port_name:
+                to_port_name = from_port_name
+            node.add_output(from_fmu_filename, from_port_name, to_port_name)
+
+        elif rule == "DROP":
+            if not from_fmu_filename or not from_port_name:
+                raise AssemblyError("Missing DROP ports information.")
+            node.add_drop_port(from_fmu_filename, from_port_name)
+
+        elif rule == "LINK":
+            node.add_link(from_fmu_filename, from_port_name, to_fmu_filename, to_port_name)
+
+        elif rule == "START":
+            if not from_fmu_filename or not from_port_name or not to_fmu_filename:
+                raise AssemblyError("Missing START ports information.")
+
+            node.add_start_value(from_fmu_filename, from_port_name, to_fmu_filename)
+        else:
+            raise AssemblyError(f"unexpected rule '{rule}'. Line skipped.")
+
+    def write_csv(self, filename: Union[str, Path]):
+        if self.root.children:
+            raise AssemblyError("This assembly is not flat. Cannot export to CSV file.")
+
+        with open(self.fmu_directory / filename, "wt") as outfile:
+            outfile.write("rule;from_fmu;from_port;to_fmu;to_port\n")
+            for fmu in self.root.fmu_names_list:
+                outfile.write(f"FMU;{fmu};;;\n")
+            for port, source in self.root.input_ports.items():
+                outfile.write(f"INPUT;;{source};{port.fmu_name};{port.port_name}\n")
+            for port, target in self.root.output_ports.items():
+                outfile.write(f"OUTPUT;{port.fmu_name};{port.port_name};;{target}\n")
+            for link in self.root.links:
+                outfile.write(f"LINK;{link.from_port.fmu_name};{link.from_port.port_name};"
+                              f"{link.to_port.fmu_name};{link.to_port.port_name}\n")
+            for port, value in self.root.start_values.items():
+                outfile.write(f"START;{port.fmu_name};{port.port_name};{value};\n")
+            for port in self.root.drop_ports:
+                outfile.write(f"DROP;{port.fmu_name};{port.port_name};;\n")
+
+    def read_json(self):
+        with open(self.input_pathname) as file:
+            try:
+                data = json.load(file)
+            except json.decoder.JSONDecodeError as e:
+                raise AssemblyError(f"Cannot read json: {e}")
+        self.root = self._json_decode_node(data)
+        if not self.root.name:
+            self.root.name = str(self.filename.with_suffix(".fmu"))
+
+    def _json_decode_node(self, data:Dict) -> AssemblyNode:
+        name = data.get("name", None)                                                       # 1
+        step_size = data.get("step_size", self.default_step_size)                           # 7
+        auto_link = data.get("auto_link", self.default_auto_link)                           # 4
+        auto_input = data.get("auto_input", self.default_auto_input)                        # 5
+        auto_output = data.get("auto_output", self.default_auto_output)                     # 6
+        mt = data.get("mt", self.default_mt)                                                # 2
+        profiling = data.get("profiling", self.default_profiling)                           # 3
+
+        node = AssemblyNode(name, step_size=step_size, auto_link=auto_link, mt=mt, profiling=profiling,
+                            auto_input=auto_input, auto_output=auto_output)
+
+        for key, value in data.items():
+            if key in ('name', 'step_size', 'auto_link', 'auto_input', 'auto_output', 'mt', 'profiling'):
+                continue  # Already read
+
+            elif key == "container": # 8
+                if not isinstance(value, list):
+                    raise AssemblyError("JSON: 'container' keyword should define a list.")
+                for sub_data in value:
+                    node.add_sub_node(self._json_decode_node(sub_data))
+
+            elif key == "fmu": # 9
+                if not isinstance(value, list):
+                    raise AssemblyError("JSON: 'fmu' keyword should define a list.")
+                for fmu in value:
+                    node.add_fmu(fmu)
+
+            elif key == "input": # 10
+                self._json_decode_keyword('input', value, node.add_input)
+
+            elif key == "output": # 11
+                self._json_decode_keyword('output', value, node.add_output)
+
+            elif key == "link": # 12
+                self._json_decode_keyword('link', value, node.add_link)
+
+            elif key == "start": # 13
+                self._json_decode_keyword('start', value, node.add_start_value)
+
+            elif key == "drop": #14
+                self._json_decode_keyword('drop', value, node.add_drop_port)
+
+            else:
+                logger.error(f"JSON: unexpected keyword {key}. Skipped.")
+
+        return node
+
+    @staticmethod
+    def _json_decode_keyword(keyword: str, value, function):
+        if not isinstance(value, list):
+            raise AssemblyError(f"JSON: '{keyword}' keyword should define a list.")
+        for line in value:
+            if not isinstance(line, list):
+                raise AssemblyError(f"JSON: unexpected '{keyword}' value: {line}.")
+            try:
+                function(*line)
+            except TypeError:
+                raise AssemblyError(f"JSON: '{keyword}' value does not contain right number of fields: {line}.")
+
+
+    def write_json(self, filename: Union[str, Path]):
+        with open(self.fmu_directory / filename, "wt") as file:
+            data = self._json_encode_node(self.root)
+            json.dump(data, file, indent=2)
+
+    def _json_encode_node(self, node: AssemblyNode) -> Dict[str, Any]:
+        json_node = dict()
+        json_node["name"] = node.name               # 1
+        json_node["mt"] = node.mt                   # 2
+        json_node["profiling"] = node.profiling     # 3
+        json_node["auto_link"] = node.auto_link     # 4
+        json_node["auto_input"] = node.auto_input   # 5
+        json_node["auto_output"] = node.auto_output # 6
+
+        if node.step_size:
+            json_node["step_size"] = node.step_size # 7
+
+        if node.children:
+            json_node["container"] = [self._json_encode_node(child) for child in node.children]     # 8
+
+        if node.fmu_names_list:
+            json_node["fmu"] = [f"{fmu_name}" for fmu_name in sorted(node.fmu_names_list)]          #9
+
+        if node.input_ports:
+            json_node["input"] = [[f"{source}", f"{port.fmu_name}", f"{port.port_name}"]            # 10
+                                  for port, source in node.input_ports.items()]
+
+        if node.output_ports:
+            json_node["output"] = [[f"{port.fmu_name}", f"{port.port_name}", f"{target}"]           # 11
+                                   for port, target in node.output_ports.items()]
+
+        if node.links:
+            json_node["link"] = [[f"{link.from_port.fmu_name}", f"{link.from_port.port_name}",      # 12
+                                  f"{link.to_port.fmu_name}", f"{link.to_port.port_name}"]
+                                 for link in node.links]
+
+        if node.start_values:
+            json_node["start"] = [[f"{port.fmu_name}", f"{port.port_name}", value]                  # 13
+                                  for port, value in node.start_values.items()]
+
+        if node.drop_ports:
+            json_node["drop"] = [[f"{port.fmu_name}", f"{port.port_name}"] for port in node.drop_ports] # 14
+
+        return json_node
+
+    def read_ssp(self):
+        logger.warning("This feature is ALPHA stage.")
+
+        with zipfile.ZipFile(self.fmu_directory / self.filename) as zin:
+            for file in zin.filelist:
+                if file.filename.endswith(".fmu") or file.filename.endswith(".ssd"):
+                    zin.extract(file, path=self.fmu_directory)
+                    logger.debug(f"Extracted: {file.filename}")
+                    self.add_transient_file(file.filename)
+
+        self.description_pathname = self.fmu_directory / "SystemStructure.ssd"
+        if self.description_pathname.is_file():
+            sdd = SSDParser(step_size=self.default_step_size, auto_link=self.default_auto_link,
+                            mt=self.default_mt, profiling=self.default_profiling,
+                            auto_input=self.default_auto_input, auto_output=self.default_auto_output)
+            self.root = sdd.parse(self.description_pathname)
+            self.root.name = str(self.filename.with_suffix(".fmu"))
+
+    def make_fmu(self, dump_json=False):
+        if dump_json:
+            dump_file = Path(self.input_pathname.stem + "-dump").with_suffix(".json")
+            logger.info(f"Dump Json '{dump_file}'")
+            self.write_json(dump_file)
+        self.root.make_fmu(self.fmu_directory, debug=self.debug, description_pathname=self.description_pathname)
+
+
+class SSDParser:
+    def __init__(self, **kwargs):
+        self.node_stack: List[AssemblyNode] = []
+        self.root = None
+        self.fmu_filenames: Dict[str, str] = {}  # Component name => FMU filename
+        self.node_attrs = kwargs
+
+    def parse(self, ssd_filepath: Path) -> AssemblyNode:
+        logger.debug(f"Analysing {ssd_filepath}")
+        with open(ssd_filepath, "rb") as file:
+            parser = xml.parsers.expat.ParserCreate()
+            parser.StartElementHandler = self.start_element
+            parser.EndElementHandler = self.end_element
+            parser.ParseFile(file)
+
+        return self.root
+
+    def start_element(self, tag_name, attrs):
+        if tag_name == 'ssd:Connection':
+            if 'startElement' in attrs:
+                if 'endElement' in attrs:
+                    fmu_start = self.fmu_filenames[attrs['startElement']]
+                    fmu_end = self.fmu_filenames[attrs['endElement']]
+                    self.node_stack[-1].add_link(fmu_start, attrs['startConnector'],
+                                                 fmu_end, attrs['endConnector'])
+                else:
+                    fmu_start = self.fmu_filenames[attrs['startElement']]
+                    self.node_stack[-1].add_output(fmu_start, attrs['startConnector'],
+                                                   attrs['endConnector'])
+            else:
+                fmu_end = self.fmu_filenames[attrs['endElement']]
+                self.node_stack[-1].add_input(attrs['startConnector'],
+                                              fmu_end, attrs['endConnector'])
+
+        elif tag_name == 'ssd:System':
+            logger.info(f"SSP System: {attrs['name']}")
+            filename = attrs['name'] + ".fmu"
+            self.fmu_filenames[attrs['name']] = filename
+            node = AssemblyNode(filename, **self.node_attrs)
+            if self.node_stack:
+                self.node_stack[-1].add_sub_node(node)
+            else:
+                self.root = node
+
+            self.node_stack.append(node)
+
+        elif tag_name == 'ssd:Component':
+            filename = attrs['source']
+            name = attrs['name']
+            self.fmu_filenames[name] = filename
+            self.node_stack[-1].add_fmu(filename)
+            logger.debug(f"Component {name} => {filename}")
+
+    def end_element(self, tag_name):
+        if tag_name == 'ssd:System':
+            self.node_stack.pop()

fmu_manipulation_toolbox/cli.py

@@ -4,7 +4,8 @@ import sys
 from colorama import Fore, Style, init
 
 from .fmu_operations import *
-from .fmu_container import FMUContainerSpecReader, FMUContainerError
+from .fmu_container import FMUContainerError
+from .assembly import Assembly, AssemblyError
 from .checker import checker_list
 from .version import __version__ as version
 from .help import Help
@@ -158,11 +159,12 @@ def fmucontainer():
 
     parser.add_argument('-h', '-help', action="help")
 
-    parser.add_argument("-fmu-directory", action="store", dest="fmu_directory", required=True,
-                        help="Directory containing initial FMU’s and used to generate containers.")
+    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("-container", action="append", dest="container_descriptions_list", default=[],
-                        metavar="filename.csv:step_size",
+                        metavar="filename.{csv|json|ssp},[:step_size]", required=True,
                         help="Description of the container to create.")
 
     parser.add_argument("-debug", action="store_true", dest="debug",
@@ -183,34 +185,42 @@ def fmucontainer():
     parser.add_argument("-profile", action="store_true", dest="profiling", default=False,
                         help="Enable Profiling mode for the generated container.")
 
+    parser.add_argument("-dump-json",  action="store_true", dest="dump", default=False,
+                        help="Dump a JSON file for each container.")
+
     config = parser.parse_args()
 
     if config.debug:
         logger.setLevel(logging.DEBUG)
 
+    fmu_directory = Path(config.fmu_directory)
+    logger.info(f"FMU directory: '{fmu_directory}'")
+
     for description in config.container_descriptions_list:
         try:
-            filename_description, step_size = description.split(":")
+            filename, step_size = description.split(":")
             step_size = float(step_size)
         except ValueError:
             step_size = None
-            filename_description = description
+            filename = description
+        try:
+            assembly = Assembly(filename, step_size=step_size, auto_link=config.auto_link,
+                                auto_input=config.auto_input, auto_output=config.auto_output, mt=config.mt,
+                                profiling=config.profiling, fmu_directory=fmu_directory, debug=config.debug)
 
-        container_filename = Path(filename_description).with_suffix(".fmu")
+        except FileNotFoundError as e:
+            logger.fatal(f"Cannot read file: {e}")
+            continue
+        except (FMUContainerError, AssemblyError) as e:
+            logger.fatal(f"{filename}: {e}")
+            continue
 
         try:
-            csv_reader = FMUContainerSpecReader(Path(config.fmu_directory))
-            container = csv_reader.read(filename_description)
-            container.add_implicit_rule(auto_input=config.auto_input,
-                                        auto_output=config.auto_output,
-                                        auto_link=config.auto_link)
-            container.make_fmu(container_filename, step_size=step_size, debug=config.debug, mt=config.mt,
-                               profiling=config.profiling)
-        except (FileNotFoundError, FMUContainerError, FMUException) as e:
-            logger.error(f"Cannot build container from '{filename_description}': {e}")
+            assembly.make_fmu(dump_json=config.dump)
+        except FMUContainerError as e:
+            logger.fatal(f"{filename}: {e}")
             continue
 
 
-# for debug purpose
 if __name__ == "__main__":
     fmucontainer()

fmu_manipulation_toolbox/fmu_container.py

@@ -1,4 +1,3 @@
-import csv
 import logging
 import os
 import shutil
@@ -8,9 +7,10 @@ from datetime import datetime
 from pathlib import Path
 from typing import *
 
-from .fmu_operations import FMU, OperationAbstract, FMUException
+from .fmu_operations import FMU, OperationAbstract
 from .version import __version__ as tool_version
 
+
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
 
@@ -30,15 +30,14 @@ class FMUPort:
     def set_port_type(self, type_name: str, attrs: Dict[str, str]):
         self.type_name = type_name
         self.child = attrs.copy()
-        try:
-            self.child.pop("unit")  # Unit are not supported
-        except KeyError:
-            pass
+        for unsupported in ("unit", "declaredType"):
+            if unsupported in self.child:
+                self.child.pop(unsupported)
 
     def xml(self, vr: int, name=None, causality=None, start=None):
 
         if self.child is None:
-            raise FMUException(f"FMUPort has no child. Bug?")
+            raise FMUContainerError(f"FMUPort has no child. Bug?")
 
         child_str = f"<{self.type_name}"
         if self.child:
@@ -70,7 +69,6 @@ class FMUPort:
 
 class EmbeddedFMU(OperationAbstract):
     capability_list = ("needsExecutionTool",
-                       "canHandleVariableCommunicationStepSize",
                        "canBeInstantiatedOnlyOncePerProcess")
 
     def __init__(self, filename):
@@ -87,6 +85,8 @@ class EmbeddedFMU(OperationAbstract):
         self.current_port = None  # used during apply_operation()
 
         self.fmu.apply_operation(self)  # Should be the last command in constructor!
+        if self.model_identifier is None:
+            raise FMUContainerError(f"FMU '{self.name}' does not implement Co-Simulation mode.")
 
     def fmi_attrs(self, attrs):
         self.guid = attrs['guid']
@@ -104,10 +104,16 @@ class EmbeddedFMU(OperationAbstract):
             self.capabilities[capability] = attrs.get(capability, "false")
 
     def experiment_attrs(self, attrs):
-        self.step_size = float(attrs['stepSize'])
+        try:
+            self.step_size = float(attrs['stepSize'])
+        except KeyError:
+            logger.warning(f"FMU '{self.name}' does not specify preferred step size")
+            pass
 
     def scalar_type(self, type_name, attrs):
-        self.current_port.set_port_type(type_name, attrs)
+        if self.current_port:
+            self.current_port.set_port_type(type_name, attrs)
+        self.current_port = None
 
     def __repr__(self):
         return f"FMU '{self.name}' ({len(self.ports)} variables)"
@@ -172,14 +178,14 @@ class ValueReferenceTable:
     def get_vr(self, cport: ContainerPort) -> int:
         return self.add_vr(cport.port.type_name)
 
-    def add_vr(self, type_name:str) -> int:
+    def add_vr(self, type_name: str) -> int:
         vr = self.vr_table[type_name]
         self.vr_table[type_name] += 1
         return vr
 
 
 class FMUContainer:
-    def __init__(self, identifier: str, fmu_directory: Union[str, Path]):
+    def __init__(self, identifier: str, fmu_directory: Union[str, Path], description_pathname=None):
         self.fmu_directory = Path(fmu_directory)
         self.identifier = identifier
         if not self.fmu_directory.is_dir():
@@ -187,8 +193,7 @@ class FMUContainer:
         self.involved_fmu: Dict[str, EmbeddedFMU] = {}
         self.execution_order: List[EmbeddedFMU] = []
 
-        self.description_pathname = None  # Will be set up by FMUContainerSpecReader
-        self.period = None  # Will be set up by FMUContainerSpecReader
+        self.description_pathname = description_pathname
 
         # Rules
         self.inputs: Dict[str, ContainerPort] = {}
@@ -207,10 +212,10 @@ class FMUContainer:
             self.involved_fmu[fmu_filename] = fmu
             self.execution_order.append(fmu)
             if not fmu.fmi_version == "2.0":
-                raise FMUException("Only FMI-2.0 is supported by FMUContainer")
+                raise FMUContainerError("Only FMI-2.0 is supported by FMUContainer")
             logger.debug(f"Adding FMU #{len(self.execution_order)}: {fmu}")
         except Exception as e:
-            raise FMUException(f"Cannot load '{fmu_filename}': {e}")
+            raise FMUContainerError(f"Cannot load '{fmu_filename}': {e}")
 
         return fmu
 
@@ -227,7 +232,8 @@ class FMUContainer:
             container_port_name = to_port_name
         cport_to = ContainerPort(self.get_fmu(to_fmu_filename), to_port_name)
         if not cport_to.port.causality == "input":  # check causality
-            raise FMUException(f"{cport_to} is {cport_to.port.causality} instead of INPUT.")
+            raise FMUContainerError(f"Tried to use '{cport_to}' as INPUT of the container but FMU causality is "
+                                    f"'{cport_to.port.causality}'.")
 
         logger.debug(f"INPUT: {to_fmu_filename}:{to_port_name}")
         self.mark_ruled(cport_to, 'INPUT')
@@ -239,7 +245,8 @@ class FMUContainer:
 
         cport_from = ContainerPort(self.get_fmu(from_fmu_filename), from_port_name)
         if cport_from.port.causality not in ("output", "local"):  # check causality
-            raise FMUException(f"{cport_from} is {cport_from.port.causality} instead of OUTPUT or LOCAL")
+            raise FMUContainerError(f"Tried to use '{cport_from}' as INPUT of the container but FMU causality is "
+                                    f"'{cport_from.port.causality}'.")
 
         logger.debug(f"OUTPUT: {from_fmu_filename}:{from_port_name}")
         self.mark_ruled(cport_from, 'OUTPUT')
@@ -248,7 +255,7 @@ class FMUContainer:
     def drop_port(self, from_fmu_filename: str, from_port_name: str):
         cport_from = ContainerPort(self.get_fmu(from_fmu_filename), from_port_name)
         if not cport_from.port.causality == "output":  # check causality
-            raise FMUException(f"{cport_from}: trying to DROP {cport_from.port.causality}")
+            raise FMUContainerError(f"{cport_from}: trying to DROP {cport_from.port.causality}")
 
         logger.debug(f"DROP: {from_fmu_filename}:{from_port_name}")
         self.mark_ruled(cport_from, 'DROP')
@@ -284,7 +291,7 @@ class FMUContainer:
 
         self.start_values[cport] = value
 
-    def find_input(self, port_to_connect: FMUPort) -> Union[ContainerPort, None]:
+    def find_input(self, port_to_connect: FMUPort) -> Optional[ContainerPort]:
         for fmu in self.execution_order:
             for port in fmu.ports.values():
                 if (port.causality == 'input' and port.name == port_to_connect.name
@@ -339,29 +346,26 @@ class FMUContainer:
 
         return step_size
 
-    def sanity_check(self, step_size: Union[float, None]):
-        nb_error = 0
+    def sanity_check(self, step_size: Optional[float]):
         for fmu in self.execution_order:
+            if not fmu.step_size:
+                continue
             ts_ratio = step_size / fmu.step_size
             if ts_ratio < 1.0:
-                logger.error(f"Container step_size={step_size}s is lower than FMU '{fmu.name}' "
-                             f"step_size={fmu.step_size}s")
+                logger.warning(f"Container step_size={step_size}s is lower than FMU '{fmu.name}' "
+                               f"step_size={fmu.step_size}s.")
             if ts_ratio != int(ts_ratio):
-                logger.error(f"Container step_size={step_size}s should divisible by FMU '{fmu.name}' "
-                             f"step_size={fmu.step_size}s")
+                logger.warning(f"Container step_size={step_size}s should divisible by FMU '{fmu.name}' "
+                               f"step_size={fmu.step_size}s.")
             for port_name in fmu.ports:
                 cport = ContainerPort(fmu, port_name)
                 if cport not in self.rules:
                     if cport.port.causality == 'input':
                         logger.error(f"{cport} is not connected")
-                        nb_error += 1
                     if cport.port.causality == 'output':
                         logger.warning(f"{cport} is not connected")
 
-        if nb_error:
-            raise FMUContainerError(f"Some ports are not connected.")
-
-    def make_fmu(self, fmu_filename: Union[str, Path], step_size: Union[float, None] = None, debug=False, mt=False,
+    def make_fmu(self, fmu_filename: Union[str, Path], step_size: Optional[float] = None, debug=False, mt=False,
                  profiling=False):
         if isinstance(fmu_filename, str):
             fmu_filename = Path(fmu_filename)
@@ -412,12 +416,12 @@ class FMUContainer:
   description="FMUContainer with {embedded_fmu}"
   author="{author}"
   license="Proprietary"
-  copyright="© Renault S.A.S"
+  copyright="See Embedded FMU's copyrights."
   variableNamingConvention="structured">
 
   <CoSimulation
     modelIdentifier="{self.identifier}"
-    canHandleVariableCommunicationStepSize="{capabilities['canHandleVariableCommunicationStepSize']}"
+    canHandleVariableCommunicationStepSize="true"
     canBeInstantiatedOnlyOncePerProcess="{capabilities['canBeInstantiatedOnlyOncePerProcess']}"
     canNotUseMemoryManagementFunctions="true"
     canGetAndSetFMUstate="false"
@@ -438,7 +442,8 @@ class FMUContainer:
             for fmu in self.execution_order:
                 vr = vr_table.add_vr("Real")
                 name = f"container.{fmu.model_identifier}.rt_ratio"
-                print(f'<ScalarVariable valueReference="{vr}" name="{name}" causality="local"><Real /></ScalarVariable>', file=xml_file)
+                print(f'<ScalarVariable valueReference="{vr}" name="{name}" causality="local">'
+                      f'<Real /></ScalarVariable>', file=xml_file)
 
         # Local variable should be first to ensure to attribute them the lowest VR.
         for local in self.locals.values():
@@ -555,7 +560,7 @@ class FMUContainer:
             if profiling and type_name == "Real":
                 nb += len(self.execution_order)
                 print(nb, file=txt_file)
-                for profiling_port,_ in enumerate(self.execution_order):
+                for profiling_port, _ in enumerate(self.execution_order):
                     print(f"{profiling_port} -2 {profiling_port}", file=txt_file)
             else:
                 print(nb, file=txt_file)
@@ -600,6 +605,7 @@ class FMUContainer:
         documentation_directory.mkdir(exist_ok=True)
 
         if self.description_pathname:
+            logger.debug(f"Copying {self.description_pathname}")
             shutil.copy(self.description_pathname, documentation_directory)
 
         shutil.copy(origin / "model.png", base_directory)
@@ -628,157 +634,3 @@ class FMUContainer:
     def make_fmu_cleanup(base_directory: Path):
         logger.debug(f"Delete directory '{base_directory}'")
         shutil.rmtree(base_directory)
-
-
-class FMUContainerSpecReader:
-    def __init__(self, fmu_directory: Union[Path, str]):
-        self.fmu_directory = Path(fmu_directory)
-
-    def read(self, description_filename: Union[str, Path]) -> FMUContainer:
-        if isinstance(description_filename, str):
-            description_filename = Path(description_filename)
-
-        if description_filename.suffix == ".csv":
-            return self.read_csv(description_filename)
-        else:
-            logger.critical(f"Unable to read from '{description_filename}': format unsupported.")
-
-    def read_csv(self, description_filename: Path) -> FMUContainer:
-        container = FMUContainer(description_filename.stem, self.fmu_directory)
-        container.description_pathname = self.fmu_directory / description_filename
-        logger.info(f"Building FMU Container from '{container.description_pathname}'")
-
-        with open(container.description_pathname) as file:
-            reader = csv.reader(file, delimiter=';')
-            self.check_headers(reader)
-            for i, row in enumerate(reader):
-                if not row or row[0][0] == '#':  # skip blank line of comment
-                    continue
-
-                try:
-                    rule, from_fmu_filename, from_port_name, to_fmu_filename, to_port_name = row
-                except ValueError:
-                    logger.error(f"Line #{i+2}: expecting 5 columns. Line skipped.")
-                    continue
-
-                rule = rule.upper()
-                if rule in ("LINK", "INPUT", "OUTPUT", "DROP", "FMU", "START"):
-                    try:
-                        self._read_csv_rule(container, rule,
-                                            from_fmu_filename, from_port_name,
-                                            to_fmu_filename, to_port_name)
-                    except FMUContainerError as e:
-                        logger.error(f"Line #{i+2}: {e}. Line skipped.")
-                        continue
-                    except FMUException as e:
-                        logger.critical(f"Line #{i + 2}: {e}.")
-                        raise
-                else:
-                    logger.error(f"Line #{i+2}: unexpected rule '{rule}'. Line skipped.")
-
-        return container
-
-    @staticmethod
-    def _read_csv_rule(container: FMUContainer, rule: str, from_fmu_filename: str, from_port_name: str,
-                       to_fmu_filename: str, to_port_name: str):
-        if rule == "FMU":
-            if not from_fmu_filename:
-                raise FMUException("Missing FMU information.")
-            container.get_fmu(from_fmu_filename)
-
-        elif rule == "INPUT":
-            if not to_fmu_filename or not to_port_name:
-                raise FMUException("Missing INPUT ports information.")
-            container.add_input(from_port_name, to_fmu_filename, to_port_name)
-
-        elif rule == "OUTPUT":
-            if not from_fmu_filename or not from_port_name:
-                raise FMUException("Missing OUTPUT ports information.")
-            container.add_output(from_fmu_filename, from_port_name, to_port_name)
-
-        elif rule == "DROP":
-            if not from_fmu_filename or not from_port_name:
-                raise FMUException("Missing DROP ports information.")
-            container.drop_port(from_fmu_filename, from_port_name)
-
-        elif rule == "LINK":
-            container.add_link(from_fmu_filename, from_port_name, to_fmu_filename, to_port_name)
-
-        elif rule == "START":
-            if not from_fmu_filename or not from_port_name or not to_fmu_filename:
-                raise FMUException("Missing START ports information.")
-
-            container.add_start_value(from_fmu_filename, from_port_name, to_fmu_filename)
-        # no else: check on rule is already done in read_description()
-
-    @staticmethod
-    def check_headers(reader):
-        headers = next(reader)
-        if not headers == ["rule", "from_fmu", "from_port", "to_fmu", "to_port"]:
-            raise FMUContainerError("Header (1st line of the file) is not well formatted.")
-
-
-class FMUContainerSpecWriter:
-    def __init__(self, container: FMUContainer):
-        self.container = container
-
-    def write(self, description_filename: Union[str, Path]):
-        if description_filename.endswith(".csv"):
-            return self.write_csv(description_filename)
-        elif description_filename.endswith(".json"):
-            return self.write_json(description_filename)
-        else:
-            logger.critical(f"Unable to write to '{description_filename}': format unsupported.")
-
-    def write_csv(self, description_filename: Union[str, Path]):
-        with open(description_filename, "wt") as outfile:
-            print("rule;from_fmu;from_port;to_fmu;to_port", file=outfile)
-            for fmu in self.container.involved_fmu.keys():
-                print(f"FMU;{fmu};;;", file=outfile)
-            for cport in self.container.inputs.values():
-                print(f"INPUT;;;{cport.fmu.name};{cport.port.name}", file=outfile)
-            for cport in self.container.outputs.values():
-                print(f"OUTPUT;{cport.fmu.name};{cport.port.name};;", file=outfile)
-            for local in self.container.locals.values():
-                for target in local.cport_to_list:
-                    print(f"LINK;{local.cport_from.fmu.name};{local.cport_from.port.name};"
-                          f"{target.fmu.name};{target.port.name}",
-                          file=outfile)
-            for cport, value in self.container.start_values.items():
-                print(f"START;{cport.fmu.name};{cport.port.name};{value};", file=outfile)
-
-    def write_json(self, description_filename: Union[str, Path]):
-        with open(description_filename, "wt") as outfile:
-            print("{", file=outfile)
-
-            print(f'  "fmu":    [', file=outfile)
-            fmus = [f'              "{fmu}"' for fmu in self.container.involved_fmu.keys()]
-            print(",\n".join(fmus), file=outfile)
-            print(f'            ],', file=outfile)
-
-            print(f'  "input":  [', file=outfile)
-            inputs = [f'              [{cport.fmu.name}, {cport.port.name}, {container_name}]'
-                      for container_name, cport in self.container.inputs.items()]
-            print(",\n".join(inputs), file=outfile)
-            print(f'            ],', file=outfile)
-
-            print(f'  "output": [', file=outfile)
-            outputs = [f'              ["{cport.fmu.name}", "{cport.port.name}", "{container_name}"]'
-                       for container_name, cport in self.container.outputs.items()]
-            print(",\n".join(outputs), file=outfile)
-            print(f'            ],', file=outfile)
-
-            print(f'  "link":   [', file=outfile)
-            links = [f'              ["{local.cport_from.fmu.name}", "{local.cport_from.port.name}", '
-                     f'"{target.fmu.name}", "{target.port.name}"]'
-                     for local in self.container.locals.values()
-                     for target in local.cport_to_list]
-            print(",\n".join(links), file=outfile)
-            print(f'            ],', file=outfile)
-            print(f'  "start":  [', file=outfile)
-            start = [f'              ["{cport.fmu.name}", "{cport.port.name}, "{value}"]'
-                     for cport, value in self.container.start_values.items()]
-            print(f'            ],', file=outfile)
-
-            #print(f'  "period": {self.container.})
-            print("}", file=outfile)

fmu_manipulation_toolbox/gui.py

@@ -1,10 +1,10 @@
 import os.path
 import sys
 from .version import __version__ as version
-from PyQt5.QtCore import Qt, QObject, QUrl, pyqtSignal, QDir
-from PyQt5.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel, QLineEdit, QPushButton, QFileDialog,
-                             QTextBrowser, QInputDialog, QMenu, QAction)
-from PyQt5.QtGui import QPixmap, QImage, QFont, QTextCursor, QIcon, QColor, QPainter, QBrush, QDesktopServices
+from PyQt6.QtCore import Qt, QObject, QUrl, pyqtSignal, QDir, QSize, QPoint
+from PyQt6.QtWidgets import (QApplication, QWidget, QGridLayout, QLabel, QLineEdit, QPushButton, QFileDialog,
+                             QTextBrowser, QInputDialog, QMenu)
+from PyQt6.QtGui import (QPixmap, QImage, QFont, QTextCursor, QIcon, QDesktopServices, QAction, QPainter, QColor)
 import textwrap
 from functools import partial
 from typing import Optional
@@ -42,7 +42,7 @@ class DropZoneWidget(QLabel):
 
     def dropEvent(self, event):
         if event.mimeData().hasImage:
-            event.setDropAction(Qt.CopyAction)
+            event.setDropAction(Qt.DropAction.CopyAction)
             try:
                 file_path = event.mimeData().urls()[0].toLocalFile()
             except IndexError:
@@ -59,8 +59,8 @@ class DropZoneWidget(QLabel):
         else:
             default_directory = os.path.expanduser('~')
 
-        fmu_filename, _ = QFileDialog.getOpenFileName(self, 'Select FMU to Manipulate',
-                                                      default_directory, "FMU files (*.fmu)")
+        fmu_filename, _ = QFileDialog.getOpenFileName(parent=self, caption='Select FMU to Manipulate',
+                                                      directory=default_directory, filter="FMU files (*.fmu)")
         if fmu_filename:
             self.set_fmu(fmu_filename)
 
@@ -70,23 +70,23 @@ class DropZoneWidget(QLabel):
         elif not os.path.isfile(filename):
             filename = os.path.join(os.path.dirname(__file__), "resources", "fmu.png")
 
-        image = QImage(filename).scaled(self.WIDTH-4, self.HEIGHT-4, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-        pixmap = QPixmap.fromImage(image)
-        rounded = self.make_pixmap_rounded(pixmap)
-        self.setPixmap(rounded)
+        base_image = QImage(filename).scaled(self.WIDTH, self.HEIGHT, Qt.AspectRatioMode.IgnoreAspectRatio,
+                                       Qt.TransformationMode.SmoothTransformation)
+        mask_filename = os.path.join(os.path.dirname(__file__), "resources", "mask.png")
+        mask_image = QImage(mask_filename).scaled(self.WIDTH, self.HEIGHT, Qt.AspectRatioMode.IgnoreAspectRatio,
+                                                  Qt.TransformationMode.SmoothTransformation)
+        rounded_image = QImage(self.WIDTH, self.HEIGHT, QImage.Format.Format_ARGB32)
+        rounded_image.fill(QColor(0, 0, 0, 0))
+        painter = QPainter()
+        painter.begin(rounded_image)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.drawImage(QPoint(0, 0), base_image)
+        painter.drawImage(QPoint(0, 0), mask_image)
+        painter.end()
+        pixmap = QPixmap.fromImage(rounded_image)
 
-    def make_pixmap_rounded(self, pixmap):
-        rounded = QPixmap(pixmap.size())
-        rounded.fill(QColor("transparent"))
+        self.setPixmap(pixmap)
 
-        painter = QPainter(rounded)
-        painter.setRenderHint(QPainter.Antialiasing)
-        painter.setBrush(QBrush(pixmap))
-        painter.setPen(Qt.NoPen)
-        painter.drawRoundedRect(pixmap.rect(), 20, 20)
-        del painter    # Mandatory to avoid a crash
-        self.update()  # Mandatory to avoid a crash
-        return rounded
 
     def set_fmu(self, filename):
         try:
@@ -147,7 +147,7 @@ class LogWidget(QTextBrowser):
         LogWidget.XStream.stdout().messageWritten.connect(self.insertPlainText)
         LogWidget.XStream.stderr().messageWritten.connect(self.insertPlainText)
 
-    def loadResource(self, type, name):
+    def loadResource(self, _, name):
         image_path = os.path.join(os.path.dirname(__file__), "resources", name.toString())
         return QPixmap(image_path)
 
@@ -162,7 +162,7 @@ class HelpWidget(QLabel):
         filename = os.path.join(os.path.dirname(__file__), "resources", "help.png")
         image = QPixmap(filename)
         self.setPixmap(image)
-        self.setAlignment(Qt.AlignRight)
+        self.setAlignment(Qt.AlignmentFlag.AlignRight)
 
     def mousePressEvent(self, event):
         QDesktopServices.openUrl(QUrl(self.HELP_URL))
@@ -209,14 +209,16 @@ class FilterWidget(QPushButton):
 
 
 class FMUManipulationToolboxlMainWindow(QWidget):
-    def __init__(self, app, *args, **kwargs):
+    def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
 
         self.setWindowTitle('FMU Manipulation Toolbox')
-        self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon.png')))
 
         # set the grid layout
         self.layout = QGridLayout()
+        self.layout.setVerticalSpacing(4)
+        self.layout.setHorizontalSpacing(4)
+        self.layout.setContentsMargins(10, 10, 10, 10)
         self.setLayout(self.layout)
 
         self.dropped_fmu = DropZoneWidget()
@@ -266,7 +268,7 @@ class FMUManipulationToolboxlMainWindow(QWidget):
 
         line += 1
         self.apply_filter_label = QLabel("Apply modification only on: ")
-        self.layout.addWidget(self.apply_filter_label, line, 1, 1, 2, alignment=Qt.AlignRight)
+        self.layout.addWidget(self.apply_filter_label, line, 1, 1, 2, alignment=Qt.AlignmentFlag.AlignRight)
         self.set_tooltip(self.apply_filter_label, 'gui-apply-only')
 
         causality = ["parameter", "calculatedParameter", "input", "output", "local", "independent"]
@@ -289,7 +291,7 @@ class FMUManipulationToolboxlMainWindow(QWidget):
 
         exit_button = QPushButton('Exit')
         self.layout.addWidget(exit_button, line, 0, 1, 2)
-        exit_button.clicked.connect(app.exit)
+        exit_button.clicked.connect(self.close)
         exit_button.setProperty("class", "quit")
 
         save_log_button = QPushButton('Save log as')
@@ -415,7 +417,7 @@ class FMUManipulationToolboxlMainWindow(QWidget):
 
     def apply_operation(self, operation):
         if self.dropped_fmu.fmu:
-            self.log_widget.moveCursor(QTextCursor.End)
+            self.log_widget.moveCursor(QTextCursor.MoveOperation.End)
             fmu_filename = os.path.basename(self.dropped_fmu.fmu.fmu_filename)
             print('-' * 100)
             self.log_widget.insertHtml(f"<strong>{fmu_filename}: {operation}</strong><br>")
@@ -434,20 +436,21 @@ class FMUManipulationToolboxlMainWindow(QWidget):
             scroll_bar.setValue(scroll_bar.maximum())
 
 
-class Application:
+class Application(QApplication):
     """
 Analyse and modify your FMUs.
 
-Note: modifying the modelDescription.xml can damage your FMU ! Communicating with the FMU-developer and adapting the
-way the FMU is generated, is preferable when possible.
+Note: modifying the modelDescription.xml can damage your FMU !
+Communicating with the FMU-developer and adapting the way the FMU is generated, is preferable when possible.
 
     """
-    def __init__(self):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
         QDir.addSearchPath('images', os.path.join(os.path.dirname(__file__), "resources"))
-        self.app = QApplication(sys.argv)
         font = QFont("Verdana")
         font.setPointSize(10)
-        self.app.setFont(font)
+        self.setFont(font)
         css_dark = """
 QWidget                  {background: #4b4e51; color: #b5bab9}
 QPushButton           { min-height: 30px; padding: 1px 1px 0.2em 0.2em; border: 1px solid #282830; border-radius: 5px;}
@@ -465,8 +468,8 @@ QPushButton.save:hover   {background-color: #675a78; color: #dddddd;}
 QPushButton.quit         {background-color: #4571a4; color: #dddddd;}
 QPushButton.quit:hover   {background-color: #5682b5; color: #dddddd;}
 QToolTip                 {color: black}
-QLabel.dropped_fmu       {background-color: #b5bab9; border: 2px dashed #282830; border-radius: dashed 20px;}
-QLabel.dropped_fmu:hover {background-color: #c6cbca; border: 2px dashed #282830; border-radius: dashed 20px;}
+QLabel.dropped_fmu       {background-color: #b5bab9}
+QLabel.dropped_fmu:hover {background-color: #c6cbca}
 QTextBrowser             {background-color: #282830; color: #b5bab9;}
 QMenu                               {font-size: 18px;}
 QMenu::item                         {padding: 2px 250px 2px 20px; border: 1px solid transparent;}
@@ -479,15 +482,25 @@ QMenu::indicator:unchecked:hover    {width: 35px; image: url(images:checkbox-unc
 QMenu::indicator:unchecked:disabled {width: 35px; image: url(images:checkbox-unchecked-disabled.png); }
 """
 
-        self.app.setStyleSheet(css_dark)
-        self.window = FMUManipulationToolboxlMainWindow(self.app)
-        print(" "*80, f"Version {version}")
-        print(self.__doc__)
-        sys.exit(self.app.exec())
+        self.setStyleSheet(css_dark)
+
+        if os.name == 'nt':
+            self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon-round.png')))
+
+            # https://stackoverflow.com/questions/1551605/how-to-set-applications-taskbar-icon-in-windows-7/1552105#1552105
+            import ctypes
+            application_id = 'FMU_Manipulation_Toolbox'  # arbitrary string
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(application_id)
+        else:
+            self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon.png')))
 
-    def exit(self):
-        self.app.exit()
+        self.window = FMUManipulationToolboxlMainWindow()
 
 
 def main():
-    Application()
+    application = Application(sys.argv)
+
+    print(" " * 80, f"Version {version}")
+    print(application.__doc__)
+
+    sys.exit(application.exec())

{fmu_manipulation_toolbox-1.7.5.dist-info → fmu_manipulation_toolbox-1.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fmu_manipulation_toolbox
-Version: 1.7.5
+Version: 1.8.1
 Summary: FMU Manipulation Toobox is a python application which help to modify a Functional Mock-up Units (FMUs) without recompilation or to group them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com

{fmu_manipulation_toolbox-1.7.5.dist-info → fmu_manipulation_toolbox-1.8.1.dist-info}/RECORD

@@ -1,11 +1,12 @@
 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=Wut6SKNbd8Xv-YaWqFSqRdSiynpuD2Qf2Lt-2Or4hcA,9
+fmu_manipulation_toolbox/__version__.py,sha256=UHHZBWWhJrlslwhXubEi_Un0xr55BiMWPTaN6R2jGLM,9
+fmu_manipulation_toolbox/assembly.py,sha256=i0BDfgAca5WgrIYDv1z1mMxaKTiP-tBlPtZJJqMxHgI,20776
 fmu_manipulation_toolbox/checker.py,sha256=lE2MpH4BAKCDjUvbr06N56u7ao8hWXaJgMKaLvmhFTQ,2272
-fmu_manipulation_toolbox/cli.py,sha256=QLBsocu0wRw64GRtZ6irFCyDyigqflQqGW3N3JFYkC4,9806
-fmu_manipulation_toolbox/fmu_container.py,sha256=kAPTNQhhKuw6S_8IZGQzxRHROGfoaLY8qj8USR_Lv50,33447
+fmu_manipulation_toolbox/cli.py,sha256=yAyfpogj_NgGt0mQRFA9dBy0NvN8vFomKUUrAtOIA5c,10102
+fmu_manipulation_toolbox/fmu_container.py,sha256=rbe71nS_kv2QyhcsaW70YlxR3iA_YO2_VX2ihRVxFQs,26338
 fmu_manipulation_toolbox/fmu_operations.py,sha256=Z3LVOnDvwzoBrqfibZPAn_Osw6MIuGrXtaboGFqp0DA,15836
-fmu_manipulation_toolbox/gui.py,sha256=uAluoN_ILEHsjO-6QftwEWQ_5Khp_I3iUuLg4eavbTc,19801
+fmu_manipulation_toolbox/gui.py,sha256=VKhQpIEEilScBSwTSJkDUwSbtsmB_VMuX0QwhZczTq4,20628
 fmu_manipulation_toolbox/help.py,sha256=aklKiLrsE0adSzQ5uoEB1sBDmI6s4l231gavu4XxxzA,5856
 fmu_manipulation_toolbox/version.py,sha256=OhBLkZ1-nhC77kyvffPNAf6m8OZe1bYTnNf_PWs1NvM,392
 fmu_manipulation_toolbox/resources/checkbox-checked-disabled.png,sha256=FWIuyrXlaNLLePHfXj7j9ca5rT8Hgr14KCe1EqTCZyk,2288
@@ -14,12 +15,14 @@ fmu_manipulation_toolbox/resources/checkbox-checked.png,sha256=gzyFqvRFsZixVh6Zl
 fmu_manipulation_toolbox/resources/checkbox-unchecked-disabled.png,sha256=KNdiE8zJ8H-mH81spHL8Ck-V87dj-fPPPrPNZFRv3wA,1783
 fmu_manipulation_toolbox/resources/checkbox-unchecked-hover.png,sha256=7XT54vwzDfSK-i6oJ5BBKGXKz8duRRVtoUzaOlWX0WE,1797
 fmu_manipulation_toolbox/resources/checkbox-unchecked.png,sha256=w3MG3RwFeTwkVOAFi8ZBs6yNlmtVnXxXY5atNyvLw54,1793
-fmu_manipulation_toolbox/resources/drop_fmu.png,sha256=HreQjYhgo-bQXM3sXcY5uDVNLjvCkOWfCfr15LEorVc,10500
+fmu_manipulation_toolbox/resources/drop_fmu.png,sha256=xt2YzoQVcvr95Ix-4kw6wT04yf660sUHGHkskHRE_l0,10365
 fmu_manipulation_toolbox/resources/fmu.png,sha256=7bI_cb3pcqEnwBCCL30v3MXPwOK8OtbhFFouRq9lTj8,12048
 fmu_manipulation_toolbox/resources/fmu_manipulation_toolbox.png,sha256=hUhuGg88BU5j7KkqhnU981wSpzn9ftQuOSu8pMYuP-Y,37997
 fmu_manipulation_toolbox/resources/help.png,sha256=WrIbjmlgIqdo6UWYj6L6gG-BCGWlu4qma8HRgRk8k7o,1822
-fmu_manipulation_toolbox/resources/icon.png,sha256=_AhXOqIu_8rHO9ZLN_qU30UHhyHG9mrNJl0hy1ts7eg,47025
+fmu_manipulation_toolbox/resources/icon-round.png,sha256=j7jk-9NVQQZJMNazjpj8WeC1q6ptXwTaiO38kPoDEnE,83754
+fmu_manipulation_toolbox/resources/icon.png,sha256=Ovui-UDBARqdTlVQwTn5Ud8seSsVh9pdElwLq5s6xKg,69976
 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/fmi-2.0/fmi2Annotation.xsd,sha256=OGfyJtaJntKypX5KDpuZ-nV1oYLZ6HV16pkpKOmYox4,2731
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2AttributeGroups.xsd,sha256=HwyV7LBse-PQSv4z1xjmtzPU3Hjnv4mluq9YdSBNHMQ,3704
@@ -28,19 +31,19 @@ fmu_manipulation_toolbox/resources/fmi-2.0/fmi2ScalarVariable.xsd,sha256=hYZGmhv
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2Type.xsd,sha256=8A0hl2wb1suoxv47xezkmvVTyJM2ZJp5RPQ2xQ_SjlY,3883
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2Unit.xsd,sha256=pB9Pe-yBMGZN-JQAu6VB_lXS99kz23mwiUSY74ONZd4,5403
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2VariableDependency.xsd,sha256=Tc9RWKqvUXpB1qsoU64DAHO4Gfu5DotrQJ3Ece7GnTU,4647
-fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=y9noIe74sHfX26T_9ag6QzB5Q_RScjPhw5vRh8q7sSo,35936
-fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=C9oGkyAw7AY_ogD2vKVUVWg9MLIVkwMdonbHjhWRq9k,22832
-fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=swDZjFxC6LnOUzXGXlpPmhnX9jSVWmEvyWHSMs_rnfU,36992
-fmu_manipulation_toolbox/resources/linux64/container.so,sha256=nJ9TfzQKIclQTzGoMm5xTp0DfzjsG8PpOgmfQjfdENA,45376
-fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=7TepHTwdMjb8nvd4ZFSs7FWjmQ7Zlse5V6NmRSbafdc,22760
-fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=on58hE5TwGHcLNE-4ETASF3PB0J6UM5kjhOPQkJLXK4,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=jS_OgOVIZ8ovbLR00UILQBstbT22kayUeBW_PkJwsh4,15872
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=W7Q1nnTV6XhFU-hUyHDTPTlACecvnpDzkGZOuBZtXS0,22016
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=SG8608-_NRdt6LUCdgAPtSLfHSpGlwUg7rClikhx7kk,32768
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=bkrW_m5g83Hy8gOH3yENRYKAVnVLwz6J48lvBNeE55k,19456
-fmu_manipulation_toolbox-1.7.5.dist-info/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
-fmu_manipulation_toolbox-1.7.5.dist-info/METADATA,sha256=nheD9rxQotMPyvRnhb5yNuoUGEWv9WiYbUR6H7vBiwQ,967
-fmu_manipulation_toolbox-1.7.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fmu_manipulation_toolbox-1.7.5.dist-info/entry_points.txt,sha256=jCPLMBdS-eOvmRfDv7n0wHZSbJHccHviW03mz5vwO-Q,124
-fmu_manipulation_toolbox-1.7.5.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.7.5.dist-info/RECORD,,
+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=_uhkJYZa_z1tV0NBATWC8iAGt7lPY11_VA29a_5hXsM,45384
+fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=ulfoPvmaYe9nInYcVEyj7mD9zDzGk56OUoWx1mPKLiE,22768
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=usY6k86X-Y0De5-SxCvgJ3yRzPpR4KCNTShYzDeec80,17920
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=3570x6uDaKUIYBy9uOmID66ffvy-bxVa8Q2il4m5KZc,15872
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=G6bNin2QuwbTiToJNSsSM1Dil899MHnZ5FNm-4ExH5I,22016
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=RBBo9kBBYhYe_KLPl5MtJJCVuL1Zf1LNT87mT88JCPg,32768
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=Pcx1z-2E7_iHmAzUDEFNTBCf02gfzg5pdYdso5GbP5A,19456
+fmu_manipulation_toolbox-1.8.1.dist-info/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
+fmu_manipulation_toolbox-1.8.1.dist-info/METADATA,sha256=24_m-PSpY9JZqU4LxMHDN3G1IdGydt_8aSXvDU7vm-8,967
+fmu_manipulation_toolbox-1.8.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+fmu_manipulation_toolbox-1.8.1.dist-info/entry_points.txt,sha256=jCPLMBdS-eOvmRfDv7n0wHZSbJHccHviW03mz5vwO-Q,124
+fmu_manipulation_toolbox-1.8.1.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.8.1.dist-info/RECORD,,