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

fmu_manipulation_toolbox/__version__.py

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

fmu_manipulation_toolbox/assembly.py

@@ -7,7 +7,7 @@ import uuid
 import xml.parsers.expat
 import zipfile
 
-from .fmu_container import FMUContainer, FMUContainerError
+from .fmu_container import FMUContainer
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
@@ -31,18 +31,26 @@ class Connection:
 
 
 class AssemblyNode:
-    def __init__(self, name: str, step_size: float = None, mt=False, profiling=False,
+    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
-        self.step_size = step_size
+        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.children: List[AssemblyNode] = []
 
-        self.fmu_names_list: Set[str] = set()
+        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] = {}
@@ -53,9 +61,14 @@ class AssemblyNode:
         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)
 
@@ -135,9 +148,10 @@ class Assembly:
         self.transient_dirnames: Set[Path] = set()
 
         if not fmu_directory.is_dir():
-            raise FMUContainerError(f"FMU directory is not valid: '{fmu_directory}'")
+            raise AssemblyError(f"FMU directory is not valid: '{fmu_directory}'")
 
-        self.description_pathname = fmu_directory / self.filename  # For inclusion in FMU
+        self.input_pathname = fmu_directory / self.filename
+        self.description_pathname = self.input_pathname   # For inclusion in FMU
         self.root = None
         self.read()
 
@@ -169,7 +183,7 @@ class Assembly:
         elif self.filename.suffix == ".csv":
             self.read_csv()
         else:
-            raise FMUContainerError(f"Not supported file format '{self.filename}")
+            raise AssemblyError(f"Not supported file format '{self.filename}")
 
     def write(self, filename: str):
         if filename.endswith(".csv"):
@@ -185,9 +199,9 @@ class Assembly:
                                  mt=self.default_mt, profiling=self.default_profiling,
                                  auto_input=self.default_auto_input, auto_output=self.default_auto_output)
 
-        with open(self.description_pathname) as file:
+        with open(self.input_pathname) as file:
             reader = csv.reader(file, delimiter=';')
-            self.check_csv_headers(reader)
+            self._check_csv_headers(reader)
             for i, row in enumerate(reader):
                 if not row or row[0][0] == '#':  # skip blank line of comment
                     continue
@@ -198,36 +212,19 @@ class Assembly:
                     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(self.root, rule,
-                                            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
-                else:
-                    logger.error(f"Line #{i+2}: 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.")
+                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
 
-        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")
+    @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,
@@ -264,114 +261,145 @@ class Assembly:
                 raise AssemblyError("Missing START ports information.")
 
             node.add_start_value(from_fmu_filename, from_port_name, to_fmu_filename)
-        # no else: check on rule is already done in read_description()
+        else:
+            raise AssemblyError(f"unexpected rule '{rule}'. Line skipped.")
 
-    @staticmethod
-    def check_csv_headers(reader):
-        headers = next(reader)
-        if not headers == ["rule", "from_fmu", "from_port", "to_fmu", "to_port"]:
-            raise AssemblyError("Header (1st line of the file) is not well formatted.")
+    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.description_pathname) as file:
+        with open(self.input_pathname) as file:
             try:
                 data = json.load(file)
             except json.decoder.JSONDecodeError as e:
-                raise FMUContainerError(f"Cannot read json: {e}")
-        self.root = self.json_decode_node(data)
+                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)
+            data = self._json_encode_node(self.root)
             json.dump(data, file, indent=2)
 
-    def json_encode_node(self, node: AssemblyNode) -> Dict[str, Any]:
+    def _json_encode_node(self, node: AssemblyNode) -> Dict[str, Any]:
         json_node = dict()
-        json_node["name"] = node.name
-        json_node["mt"] = node.mt
-        json_node["profiling"] = node.profiling
-        json_node["auto_link"] = node.auto_link
+        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
+            json_node["step_size"] = node.step_size # 7
 
         if node.children:
-            json_node["container"] = [self.json_encode_node(child) for child in 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)]
+            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}"]
+            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}"]
+            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}",
+            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]
+            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]
+            json_node["drop"] = [[f"{port.fmu_name}", f"{port.port_name}"] for port in node.drop_ports] # 14
 
         return json_node
 
-    def json_decode_node(self, data) -> AssemblyNode:
-        name = data.get("name", None)
-        step_size = data.get("step_size", self.default_step_size)
-        auto_link = data.get("auto_link", self.default_auto_link)
-        auto_input = data.get("auto_input", self.default_auto_input)
-        auto_output = data.get("auto_output", self.default_auto_output)
-        mt = data.get("mt", self.default_mt)
-        profiling = data.get("profiling", self.default_profiling)
-
-        node = AssemblyNode(name, step_size=step_size, auto_link=auto_link, mt=mt, profiling=profiling,
-                            auto_input=auto_input, auto_output=auto_output)
-
-        if "container" in data:
-            if not isinstance(data["container"], list):
-                raise FMUContainerError("JSON: 'container' keyword should define a list.")
-            for sub_data in data["container"]:
-                node.add_sub_node(self.json_decode_node(sub_data))
-
-        if "fmu" in data:
-            if not isinstance(data["fmu"], list):
-                raise FMUContainerError("JSON: 'fmu' keyword should define a list.")
-            for fmu in data["fmu"]:
-                node.add_fmu(fmu)
-
-        if "input" in data:
-            if not isinstance(data["input"], list):
-                raise FMUContainerError("JSON: 'input' keyword should define a list.")
-            for line in data["input"]:
-                node.add_input(line[1], line[2], line[0])
-
-        if "output" in data:
-            if not isinstance(data["output"], list):
-                raise FMUContainerError("JSON: 'output' keyword should define a list.")
-            for line in data["output"]:
-                node.add_output(line[0], line[1], line[2])
-
-        if "start" in data:
-            if not isinstance(data["start"], list):
-                raise FMUContainerError("JSON: 'start' keyword should define a list.")
-            for line in data["start"]:
-                node.add_start_value(line[0], line[1], line[2])
-
-        if "drop" in data:
-            for line in data["drop"]:
-                node.add_drop_port(line[0], line[1])
-
-        return node
-
     def read_ssp(self):
         logger.warning("This feature is ALPHA stage.")
 
@@ -388,11 +416,11 @@ class Assembly:
                             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 = (self.description_pathname.with_stem(self.description_pathname.stem + "-dump")
-                         .with_suffix(".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)

fmu_manipulation_toolbox/cli.py

@@ -5,7 +5,7 @@ from colorama import Fore, Style, init
 
 from .fmu_operations import *
 from .fmu_container import FMUContainerError
-from .assembly import Assembly
+from .assembly import Assembly, AssemblyError
 from .checker import checker_list
 from .version import __version__ as version
 from .help import Help
@@ -211,7 +211,7 @@ def fmucontainer():
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
             continue
-        except FMUContainerError as e:
+        except (FMUContainerError, AssemblyError) as e:
             logger.fatal(f"{filename}: {e}")
             continue
 

fmu_manipulation_toolbox/fmu_container.py

@@ -291,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
@@ -346,31 +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)

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))
@@ -216,6 +216,9 @@ class FMUManipulationToolboxlMainWindow(QWidget):
 
         # 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()
@@ -265,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"]
@@ -414,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>")
@@ -437,8 +440,8 @@ 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, *args, **kwargs):
@@ -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;}
@@ -481,7 +484,6 @@ QMenu::indicator:unchecked:disabled {width: 35px; image: url(images:checkbox-unc
 
         self.setStyleSheet(css_dark)
 
-
         if os.name == 'nt':
             self.setWindowIcon(QIcon(os.path.join(os.path.dirname(__file__), 'resources', 'icon-round.png')))
 

{fmu_manipulation_toolbox-1.8.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.8
+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.8.dist-info → fmu_manipulation_toolbox-1.8.1.dist-info}/RECORD

@@ -1,12 +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=wgnOv0C5Ic8_OmpPXk8qES2otG4lRxHybApfWS9AX58,7
-fmu_manipulation_toolbox/assembly.py,sha256=3YGVBUMjTNwzU-GxUCT-uER3DkX_r4V44ekfzwTmT8I,19364
+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=bIfQAGMyTmsx8HQSvu0Ic_UqDRvvm_Op3RCwHpjfqVI,10070
-fmu_manipulation_toolbox/fmu_container.py,sha256=cPJ_f0-KrBpF8Ri9D9RhgGIuT9BiqWpus4nPet4a3PU,26488
+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=4gD6D4f1jQm1UlVC0iV4nuFNOT-y-AuJ13_7LBVm944,20269
+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
@@ -15,13 +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=aynTWUw5220BXPZIhNco5AkR-ydCAwibWb5gdhR3cCQ,20077
+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-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
@@ -35,14 +36,14 @@ fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=1TLGqNPyM5UVOrCfzNqW
 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=Xuo3euqlAL1GTEseSN4I3oZgtyazVAtcPIURN1g5MGs,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=BQVRmQlsRCNaPfvutK2HACHsOhM7eC-X7xYs2pdX2hc,15872
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=AEijF7jWf5bvI1V73eU4qOH4HF1ji0OZtnicm3dW5P4,22016
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=6yK5n_2ImVvk3cJJ2Xvmps3OrOUJD_Yf0D_F7oRlK_Y,32768
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=Idy3JQhIkS3gauQVz5iDBgp9hw8nBSMgNExeoDnhJBA,19456
-fmu_manipulation_toolbox-1.8.dist-info/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
-fmu_manipulation_toolbox-1.8.dist-info/METADATA,sha256=dfoN8Q5lNqwgCThHbYBSuD9UoKl8rhBsts_L8z76vSM,965
-fmu_manipulation_toolbox-1.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-fmu_manipulation_toolbox-1.8.dist-info/entry_points.txt,sha256=jCPLMBdS-eOvmRfDv7n0wHZSbJHccHviW03mz5vwO-Q,124
-fmu_manipulation_toolbox-1.8.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.8.dist-info/RECORD,,
+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,,