fmu-manipulation-toolbox 1.8.3__tar.gz → 1.8.4__tar.gz

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.8.3
-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
+Version: 1.8.4
+Summary: FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) without recompilation or bundling them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com
+License: BSD-2-Clause
+Requires-Python: >=3.8
 License-File: LICENSE.txt
 Requires-Dist: PySide6>=6.8.0
 Requires-Dist: xmlschema>=3.3.1
@@ -12,11 +14,13 @@ Requires-Dist: colorama>=0.4.6
 Dynamic: author
 Dynamic: description
 Dynamic: home-page
+Dynamic: license
 Dynamic: license-file
 Dynamic: requires-dist
+Dynamic: requires-python
 Dynamic: summary
 
-FMU Manipulation Toolbox is a python application which help to modify a Functional Mock-up Units (FMUs) 
+FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) 
 without recompilation. It mainly modifies the `modelDescription.xml` file. It is highly customizable.
 
 Manipulating the `modelDescription.xml` can be a dangerous thing! Communicating with the FMU-developer and adapting

fmu_manipulation_toolbox-1.8.4/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.8.4'

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/fmu_manipulation_toolbox/assembly.py

@@ -7,7 +7,7 @@ import uuid
 import xml.parsers.expat
 import zipfile
 
-from .fmu_container import FMUContainer
+from .fmu_container import FMUContainer, AutoWired
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
@@ -126,11 +126,17 @@ class AssemblyNode:
         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,
-                                    auto_parameter=self.auto_parameter,
-                                    auto_local=self.auto_local)
+        wired = container.add_implicit_rule(auto_input=self.auto_input,
+                                            auto_output=self.auto_output,
+                                            auto_link=self.auto_link,
+                                            auto_parameter=self.auto_parameter,
+                                            auto_local=self.auto_local)
+        for input_rule in wired.rule_input:
+            self.add_input(input_rule[0], input_rule[1], input_rule[2])
+        for output_rule in wired.rule_output:
+            self.add_output(output_rule[0], output_rule[1], output_rule[2])
+        for link_rule in wired.rule_link:
+            self.add_link(link_rule[0], link_rule[1], link_rule[2], link_rule[3])
 
         container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, debug=debug)
 
@@ -498,18 +504,18 @@ class Assembly:
 
         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,
+            sdd = SSDParser(step_size=self.default_step_size, auto_link=False,
                             mt=self.default_mt, profiling=self.default_profiling,
-                            auto_input=self.default_auto_input, auto_output=self.default_auto_output)
+                            auto_input=False, auto_output=False)
             self.root = sdd.parse(self.description_pathname)
             self.root.name = str(self.filename.with_suffix(".fmu"))
 
     def make_fmu(self, dump_json=False):
+        self.root.make_fmu(self.fmu_directory, debug=self.debug, description_pathname=self.description_pathname)
         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:

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/fmu_manipulation_toolbox/fmu_container.py

@@ -146,12 +146,35 @@ class ContainerPort:
         return f"Port {self.fmu.name}/{self.port.name}"
 
     def __hash__(self):
-        return hash("{self.fmu.name}/{self.port.name}")
+        return hash(f"{self}")
 
     def __eq__(self, other):
         return str(self) == str(other)
 
 
+class ContainerInput:
+    def __init__(self, name: str, cport_to: ContainerPort):
+        self.name = name
+        self.type_name = cport_to.port.type_name
+        self.causality = cport_to.port.causality
+        self.cport_list = [cport_to]
+        self.vr = None
+
+    def add_cport(self, cport_to: ContainerPort):
+        if cport_to in self.cport_list: # Cannot be reached ! (Assembly prevent this to happen)
+            raise FMUContainerError(f"Duplicate INPUT {cport_to} already connected to {self.name}")
+
+        if cport_to.port.type_name != self.type_name:
+            raise FMUContainerError(f"Cannot connect {self.name} of type {self.type_name} to "
+                                    f"{cport_to} of type {cport_to.port.type_name}")
+
+        if cport_to.port.causality != self.causality:
+            raise FMUContainerError(f"Cannot connect {self.causality.upper()} {self.name} to "
+                                    f"{cport_to.port.causality.upper()} {cport_to}")
+
+        self.cport_list.append(cport_to)
+
+
 class Local:
     def __init__(self, cport_from: ContainerPort):
         self.name = cport_from.fmu.id + "." + cport_from.port.name  # strip .fmu suffix
@@ -190,6 +213,31 @@ class ValueReferenceTable:
         return vr
 
 
+class AutoWired:
+    def __init__(self):
+        self.rule_input = []
+        self.rule_output = []
+        self.rule_link = []
+        self.nb_param = 0
+
+    def __repr__(self):
+        return (f"{self.nb_param} parameters, {len(self.rule_input) - self.nb_param} inputs,"
+                f" {len(self.rule_output)} outputs, {len(self.rule_link)} links.")
+
+    def add_input(self, from_port, to_fmu, to_port):
+        self.rule_input.append([from_port, to_fmu, to_port])
+
+    def add_parameter(self, from_port, to_fmu, to_port):
+        self.rule_input.append([from_port, to_fmu, to_port])
+        self.nb_param += 1
+
+    def add_output(self, from_fmu, from_port, to_port):
+        self.rule_output.append([from_fmu, from_port, to_port])
+
+    def add_link(self, from_fmu, from_port, to_fmu, to_port):
+        self.rule_link.append([from_fmu, from_port, to_fmu, to_port])
+
+
 class FMUContainer:
     def __init__(self, identifier: str, fmu_directory: Union[str, Path], description_pathname=None):
         self.fmu_directory = Path(fmu_directory)
@@ -205,7 +253,7 @@ class FMUContainer:
         self.stop_time = None
 
         # Rules
-        self.inputs: Dict[str, ContainerPort] = {}
+        self.inputs: Dict[str, ContainerInput] = {}
         self.outputs: Dict[str, ContainerPort] = {}
         self.locals: Dict[ContainerPort, Local] = {}
 
@@ -236,17 +284,25 @@ class FMUContainer:
 
         self.rules[cport] = rule
 
+    def get_all_cports(self):
+        return [ContainerPort(fmu, port_name) for fmu in self.execution_order for port_name in fmu.ports]
+
     def add_input(self, container_port_name: str, to_fmu_filename: str, to_port_name: str):
         if not container_port_name:
             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
+        if cport_to.port.causality not in ("input", "parameter"):  # check causality
             raise FMUContainerError(f"Tried to use '{cport_to}' as INPUT of the container but FMU causality is "
                                     f"'{cport_to.port.causality}'.")
 
+        try:
+            input_port = self.inputs[container_port_name]
+            input_port.add_cport(cport_to)
+        except KeyError:
+            self.inputs[container_port_name] = ContainerInput(container_port_name, cport_to)
+
         logger.debug(f"INPUT: {to_fmu_filename}:{to_port_name}")
         self.mark_ruled(cport_to, 'INPUT')
-        self.inputs[container_port_name] = cport_to
 
     def add_output(self, from_fmu_filename: str, from_port_name: str, container_port_name: str):
         if not container_port_name:  # empty is allowed
@@ -254,9 +310,12 @@ 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 FMUContainerError(f"Tried to use '{cport_from}' as INPUT of the container but FMU causality is "
+            raise FMUContainerError(f"Tried to use '{cport_from}' as OUTPUT of the container but FMU causality is "
                                     f"'{cport_from.port.causality}'.")
 
+        if container_port_name in self.outputs:
+            raise FMUContainerError(f"Duplicate OUTPUT {container_port_name} already connected to {cport_from}")
+
         logger.debug(f"OUTPUT: {from_fmu_filename}:{from_port_name}")
         self.mark_ruled(cport_from, 'OUTPUT')
         self.outputs[container_port_name] = cport_from
@@ -302,60 +361,60 @@ class FMUContainer:
 
     def find_inputs(self, port_to_connect: FMUPort) -> List[ContainerPort]:
         candidates = []
-        for fmu in self.execution_order:
-            for port in fmu.ports.values():
-                if (port.causality == 'input' and port.name == port_to_connect.name
-                        and port.type_name == port_to_connect.type_name):
-                    candidates.append(ContainerPort(fmu, port.name))
+        for cport in self.get_all_cports():
+            if (cport.port.causality == 'input' and cport not in self.rules and cport.port.name == port_to_connect.name
+                    and cport.port.type_name == port_to_connect.type_name):
+                candidates.append(cport)
         return candidates
 
     def add_implicit_rule(self, auto_input=True, auto_output=True, auto_link=True, auto_parameter=False,
-                          auto_local=False):
+                          auto_local=False) -> AutoWired:
+
+        auto_wired = AutoWired()
         # Auto Link outputs
-        for fmu in self.execution_order:
-            for port_name in fmu.ports:
-                cport = ContainerPort(fmu, port_name)
+        for cport in self.get_all_cports():
+            if cport.port.causality == 'output':
+                candidates_cport_list = self.find_inputs(cport.port)
+                if auto_link and candidates_cport_list:
+                    for candidate_cport in candidates_cport_list:
+                        logger.info(f"AUTO LINK: {cport} -> {candidate_cport}")
+                        self.add_link(cport.fmu.name, cport.port.name,
+                                      candidate_cport.fmu.name, candidate_cport.port.name)
+                        auto_wired.add_link(cport.fmu.name, cport.port.name,
+                                            candidate_cport.fmu.name, candidate_cport.port.name)
+                elif auto_output and cport not in self.rules:
+                    logger.info(f"AUTO OUTPUT: Expose {cport}")
+                    self.add_output(cport.fmu.name, cport.port.name, cport.port.name)
+                    auto_wired.add_output(cport.fmu.name, cport.port.name, cport.port.name)
+            elif cport.port.causality == 'local':
+                local_portname = None
+                if cport.port.name.startswith("container."):
+                    local_portname = "container." + cport.fmu.id + "." + cport.port.name[10:]
+                    logger.info(f"PROFILING: Expose {cport}")
+                elif auto_local:
+                    local_portname = cport.fmu.id + "." + cport.port.name
+                    logger.info(f"AUTO LOCAL: Expose {cport}")
+                if local_portname:
+                    self.add_output(cport.fmu.name, cport.port.name, local_portname)
+                    auto_wired.add_output(cport.fmu.name, cport.port.name, local_portname)
+
+        if auto_input:
+            # Auto link inputs
+            for cport in self.get_all_cports():
                 if cport not in self.rules:
                     if cport.port.causality == 'parameter' and auto_parameter:
                         parameter_name = cport.fmu.id + "." + cport.port.name
                         logger.info(f"AUTO PARAMETER: {cport} as {parameter_name}")
-                        self.inputs[parameter_name] = cport
-                        self.mark_ruled(cport, 'PARAMETER')
-                    elif cport.port.causality == 'output':
-                        candidates_cport_list = self.find_inputs(cport.port)
-                        if auto_link and candidates_cport_list:
-                            self.locals[cport] = Local(cport)
-                            self.mark_ruled(cport, 'LINK')
-                            for candidate_cport in candidates_cport_list:
-                                self.locals[cport].add_target(candidate_cport)
-                                self.mark_ruled(candidate_cport, 'LINK')
-                                logger.info(f"AUTO LINK: {cport} -> {candidate_cport}")
-                        elif auto_output:
-                            self.mark_ruled(cport, 'OUTPUT')
-                            self.outputs[port_name] = cport
-                            logger.info(f"AUTO OUTPUT: Expose {cport}")
-                    elif cport.port.causality == 'local':
-                        local_portname = None
-                        if port_name.startswith("container."):
-                            local_portname = "container." + cport.fmu.id + "." + port_name[10:]
-                            logger.info(f"PROFILING: Expose {cport}")
-                        elif auto_local:
-                            local_portname = cport.fmu.id + "." + port_name
-                            logger.info(f"AUTO LOCAL: Expose {cport}")
-                        if local_portname:
-                            self.mark_ruled(cport, 'OUTPUT')
-                            self.outputs[local_portname] = cport
+                        self.add_input(parameter_name, cport.fmu.name, cport.port.name)
+                        auto_wired.add_parameter(parameter_name, cport.fmu.name, cport.port.name)
+                    elif cport.port.causality == 'input':
+                        logger.info(f"AUTO INPUT: Expose {cport}")
+                        self.add_input(cport.port.name, cport.fmu.name, cport.port.name)
+                        auto_wired.add_input(cport.port.name, cport.fmu.name, cport.port.name)
 
-        if auto_input:
-            # Auto link inputs
-            for fmu in self.execution_order:
-                for port_name in fmu.ports:
-                    cport = ContainerPort(fmu, port_name)
-                    if cport not in self.rules:
-                        if cport.port.causality == 'input':
-                            self.mark_ruled(cport, 'INPUT')
-                            self.inputs[port_name] = cport
-                            logger.info(f"AUTO INPUT: Expose {cport}")
+        logger.info(f"Auto-wiring: {auto_wired}")
+
+        return auto_wired
 
     def minimum_step_size(self) -> float:
         step_size = None
@@ -489,11 +548,12 @@ class FMUContainer:
             print(f'    {local.cport_from.port.xml(vr, name=local.name, causality="local")}', file=xml_file)
             local.vr = vr
 
-        for input_port_name, cport in self.inputs.items():
-            vr = vr_table.get_vr(cport)
-            start = self.start_values.get(cport, None)
-            print(f"    {cport.port.xml(vr, name=input_port_name, start=start)}", file=xml_file)
-            cport.vr = vr
+        for input_port_name, input_port in self.inputs.items():
+            vr = vr_table.add_vr(input_port.type_name)
+            # Get Start and XML from first connected input
+            start = self.start_values.get(input_port.cport_list[0], None)
+            print(f"    {input_port.cport_list[0].port.xml(vr, name=input_port_name, start=start)}", file=xml_file)
+            input_port.vr = vr
 
         for output_port_name, cport in self.outputs.items():
             vr = vr_table.get_vr(cport)
@@ -544,7 +604,7 @@ class FMUContainer:
 
         # Prepare data structure
         type_names_list = ("Real", "Integer", "Boolean", "String")  # Ordered list
-        inputs_per_type: Dict[str, List[ContainerPort]] = {}        # Container's INPUT
+        inputs_per_type: Dict[str, List[ContainerInput]] = {}        # Container's INPUT
         outputs_per_type: Dict[str, List[ContainerPort]] = {}       # Container's OUTPUT
 
         inputs_fmu_per_type: Dict[str, Dict[str, Dict[ContainerPort, int]]] = {}      # [type][fmu]
@@ -568,8 +628,8 @@ class FMUContainer:
 
         # Fill data structure
         # Inputs
-        for input_port_name, cport in self.inputs.items():
-            inputs_per_type[cport.port.type_name].append(cport)
+        for input_port_name, input_port in self.inputs.items():
+            inputs_per_type[input_port.type_name].append(input_port)
         for cport, value in self.start_values.items():
             start_values_fmu_per_type[cport.port.type_name][cport.fmu.name][cport] = value
         # Outputs
@@ -591,23 +651,28 @@ class FMUContainer:
             print(f"{nb} ", file=txt_file, end='')
         print("", file=txt_file)
 
-        print("# CONTAINER I/O: <VR> <FMU_INDEX> <FMU_VR>", file=txt_file)
+        print("# CONTAINER I/O: <VR> <NB> <FMU_INDEX> <FMU_VR> [<FMU_INDEX> <FMU_VR>]", file=txt_file)
         for type_name in type_names_list:
             print(f"# {type_name}", file=txt_file)
-            nb = len(inputs_per_type[type_name])+len(outputs_per_type[type_name])+len(locals_per_type[type_name])
+            nb = len(inputs_per_type[type_name]) + len(outputs_per_type[type_name]) + len(locals_per_type[type_name])
+            nb_input_link = 0
+            for input_port in inputs_per_type[type_name]:
+                nb_input_link += len(input_port.cport_list) - 1
+
             if profiling and type_name == "Real":
                 nb += len(self.execution_order)
-                print(nb, file=txt_file)
+                print(f"{nb} {nb+nb_input_link}", file=txt_file)
                 for profiling_port, _ in enumerate(self.execution_order):
                     print(f"{profiling_port} -2 {profiling_port}", file=txt_file)
             else:
-                print(nb, file=txt_file)
-            for cport in inputs_per_type[type_name]:
-                print(f"{cport.vr} {fmu_rank[cport.fmu.name]} {cport.port.vr}", file=txt_file)
+                print(f"{nb} {nb+nb_input_link}", file=txt_file)
+            for input_port in inputs_per_type[type_name]:
+                cport_string = [f"{fmu_rank[cport.fmu.name]} {cport.port.vr}" for cport in input_port.cport_list]
+                print(f"{input_port.vr} {len(input_port.cport_list)}", " ".join(cport_string), file=txt_file)
             for cport in outputs_per_type[type_name]:
-                print(f"{cport.vr} {fmu_rank[cport.fmu.name]} {cport.port.vr}", file=txt_file)
+                print(f"{cport.vr} 1 {fmu_rank[cport.fmu.name]} {cport.port.vr}", file=txt_file)
             for local in locals_per_type[type_name]:
-                print(f"{local.vr} -1 {local.vr}", file=txt_file)
+                print(f"{local.vr} 1 -1 {local.vr}", file=txt_file)
 
         # LINKS
         for fmu in self.execution_order:

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/fmu_manipulation_toolbox/fmu_operations.py

@@ -313,10 +313,11 @@ class OperationAddRemotingWinAbstract(OperationAbstract):
         else:
             os.mkdir(fmu_bin[self.bitness_to])
 
-        from_path = Path(__file__).parent / "resources" / self.bitness_to
-        shutil.copyfile(from_path / "client_sm.dll",
+        to_path = Path(__file__).parent / "resources" / self.bitness_to
+        shutil.copyfile(to_path / "client_sm.dll",
                         Path(fmu_bin[self.bitness_to]) / Path(attrs['modelIdentifier']).with_suffix(".dll"))
 
+        from_path = Path(__file__).parent / "resources" / self.bitness_from
         shutil.copyfile(from_path / "server_sm.exe",
                         Path(fmu_bin[self.bitness_from]) / "server_sm.exe")
 

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/fmu_manipulation_toolbox/gui.py

@@ -11,7 +11,7 @@ from PySide6.QtGui import (QPixmap, QTextCursor, QStandardItem, QIcon, QDesktopS
 from functools import partial
 from typing import Optional
 
-from .gui_style import *
+from .gui_style import gui_style
 from .fmu_operations import *
 from .assembly import Assembly, AssemblyNode
 from .checker import checker_list
@@ -728,7 +728,7 @@ Communicating with the FMU-developer and adapting the way the FMU is generated,
         self.setHighDpiScaleFactorRoundingPolicy(Qt.HighDpiScaleFactorRoundingPolicy.RoundPreferFloor)
 
         QDir.addSearchPath('images', os.path.join(os.path.dirname(__file__), "resources"))
-        self.setStyleSheet(gui_style_dark)
+        self.setStyleSheet(gui_style)
 
         if os.name == 'nt':
             import ctypes

fmu_manipulation_toolbox-1.8.4/fmu_manipulation_toolbox/gui_style.py

@@ -0,0 +1,244 @@
+import os
+
+if os.name == 'nt':
+    gui_style = """
+    QWidget {
+        font: 10pt "Verdana";
+        background: #4b4e51;
+        color: #b5bab9;
+    }
+    QPushButton, QComboBox {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        border: 1px solid #282830;
+        border-radius: 5px;
+        color: #dddddd;
+    }
+    QPushButton:pressed {
+        border: 2px solid #282830;
+    }
+    QPushButton.info {
+        background-color: #4e6749;
+    }
+    QPushButton.info:hover {
+        background-color: #5f7850;
+    }
+    QPushButton.modify {
+        background-color: #98763f;
+    }
+    QPushButton.modify:hover {
+        background-color: #a9874f;
+    }
+    QPushButton.removal {
+        background-color: #692e2e;
+    }
+    QPushButton.removal:hover {
+        background-color: #7a3f3f;
+    }
+    QPushButton.save {
+        background-color: #564967;
+    }
+    QPushButton.save:hover {
+        background-color: #675a78;
+    }
+    QPushButton.quit {
+        background-color: #4571a4;
+    }
+    QPushButton.quit:hover {
+        background-color: #5682b5;
+    }
+    QPushButton::disabled {
+        background-color: gray;
+    }
+    QToolTip {
+        color: black
+    }
+    QLabel.dropped_fmu {
+        background-color: #b5bab9
+    }
+    QLabel.title {
+        font: 14pt bold "Verdana";
+    }
+    QLabel.dropped_fmu:hover {
+        background-color: #c6cbca
+    }
+    QTextBrowser, QTreeView {
+        font: 11pt "Consolas";
+        background-color: #282830;
+        color: #b5bab9;
+    }
+    QMenu::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QMenu::item::indicator, QCheckBox::item::indicator {
+        width: 32px;
+        height: 32px;
+    }
+    QMenu::indicator:checked, QCheckBox::indicator:checked {
+        image: url(images:checkbox-checked.png);
+    }
+    QMenu::indicator:checked:hover, QCheckBox::indicator:checked:hover {
+        image: url(images:checkbox-checked-hover.png);
+    }
+    QMenu::indicator:checked:disabled, QCheckBox::indicator:checked:disabled {
+        image: url(images:checkbox-checked-disabled.png);
+    }
+    QMenu::indicator:unchecked, QCheckBox::indicator:unchecked {
+        image: url(images:checkbox-unchecked.png);
+    }
+    QMenu::indicator:unchecked:hover, QCheckBox::indicator:unchecked:hover {
+        image: url(images:checkbox-unchecked-hover.png);
+    }
+    QMenu::indicator:unchecked:disabled, QCheckBox::indicator:unchecked:disabled {
+        image: url(images:checkbox-unchecked-disabled.png);
+    }
+    QCheckBox::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QTabBar::tab {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        color: #dddddd;
+        margin: 2px;
+        margin-bottom: 0px;
+        border: 1px solid #282830;
+        border-top-left-radius: 5px;
+        border-top-right-radius: 5px;
+    } 
+    QTabBar::tab:selected, QTabBar::tab:hover {
+        background-color: #5f7850;
+        margin-bottom:-1px;
+    }
+    QTabBar {
+        border-bottom: 1px solid #282830;
+    }
+    QTabBar::tab:top:last, QTabBar::tab:bottom:last {
+        margin-right: 0;
+    }
+    QTabBar::tab:top:first, QTabBar::tab:bottom:first {
+        margin-left: 0;
+    }
+    """
+else:
+    gui_style = """
+    QWidget {
+        font: 12pt;
+        background: #4b4e51;
+        color: #b5bab9;
+    }
+    QPushButton, QComboBox {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        border: 1px solid #282830;
+        border-radius: 5px;
+        color: #dddddd;
+    }
+    QPushButton:pressed {
+        border: 2px solid #282830;
+    }
+    QPushButton.info {
+        background-color: #4e6749;
+    }
+    QPushButton.info:hover {
+        background-color: #5f7850;
+    }
+    QPushButton.modify {
+        background-color: #98763f;
+    }
+    QPushButton.modify:hover {
+        background-color: #a9874f;
+    }
+    QPushButton.removal {
+        background-color: #692e2e;
+    }
+    QPushButton.removal:hover {
+        background-color: #7a3f3f;
+    }
+    QPushButton.save {
+        background-color: #564967;
+    }
+    QPushButton.save:hover {
+        background-color: #675a78;
+    }
+    QPushButton.quit {
+        background-color: #4571a4;
+    }
+    QPushButton.quit:hover {
+        background-color: #5682b5;
+    }
+    QPushButton::disabled {
+        background-color: gray;
+    }
+    QToolTip {
+        color: black
+    }
+    QLabel.dropped_fmu {
+        background-color: #b5bab9
+    }
+    QLabel.title {
+        font: 14pt bold "Verdana";
+    }
+    QLabel.dropped_fmu:hover {
+        background-color: #c6cbca
+    }
+    QTextBrowser, QTreeView {
+        font: 14pt "Courier New";
+        background-color: #282830;
+        color: #b5bab9;
+    }
+    QMenu::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QMenu::item::indicator, QCheckBox::item::indicator {
+        width: 32px;
+        height: 32px;
+    }
+    QMenu::indicator:checked, QCheckBox::indicator:checked {
+        image: url(images:checkbox-checked.png);
+    }
+    QMenu::indicator:checked:hover, QCheckBox::indicator:checked:hover {
+        image: url(images:checkbox-checked-hover.png);
+    }
+    QMenu::indicator:checked:disabled, QCheckBox::indicator:checked:disabled {
+        image: url(images:checkbox-checked-disabled.png);
+    }
+    QMenu::indicator:unchecked, QCheckBox::indicator:unchecked {
+        image: url(images:checkbox-unchecked.png);
+    }
+    QMenu::indicator:unchecked:hover, QCheckBox::indicator:unchecked:hover {
+        image: url(images:checkbox-unchecked-hover.png);
+    }
+    QMenu::indicator:unchecked:disabled, QCheckBox::indicator:unchecked:disabled {
+        image: url(images:checkbox-unchecked-disabled.png);
+    }
+    QCheckBox::item {
+        padding: 2px 250px 2px 20px;
+        border: 1px solid transparent;
+    }
+    QTabBar::tab {
+        min-height: 30px;
+        padding: 1px 1px 0.2em 0.2em;
+        color: #dddddd;
+        margin: 2px;
+        margin-bottom: 0px;
+        border: 1px solid #282830;
+        border-top-left-radius: 5px;
+        border-top-right-radius: 5px;
+    } 
+    QTabBar::tab:selected, QTabBar::tab:hover {
+        background-color: #5f7850;
+        margin-bottom:-1px;
+    }
+    QTabBar {
+        border-bottom: 1px solid #282830;
+    }
+    QTabBar::tab:top:last, QTabBar::tab:bottom:last {
+        margin-right: 0;
+    }
+    QTabBar::tab:top:first, QTabBar::tab:bottom:first {
+        margin-left: 0;
+    }
+    """

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/fmu_manipulation_toolbox.egg-info/PKG-INFO

@@ -1,9 +1,11 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.8.3
-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
+Version: 1.8.4
+Summary: FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) without recompilation or bundling them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com
+License: BSD-2-Clause
+Requires-Python: >=3.8
 License-File: LICENSE.txt
 Requires-Dist: PySide6>=6.8.0
 Requires-Dist: xmlschema>=3.3.1
@@ -12,11 +14,13 @@ Requires-Dist: colorama>=0.4.6
 Dynamic: author
 Dynamic: description
 Dynamic: home-page
+Dynamic: license
 Dynamic: license-file
 Dynamic: requires-dist
+Dynamic: requires-python
 Dynamic: summary
 
-FMU Manipulation Toolbox is a python application which help to modify a Functional Mock-up Units (FMUs) 
+FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) 
 without recompilation. It mainly modifies the `modelDescription.xml` file. It is highly customizable.
 
 Manipulating the `modelDescription.xml` can be a dangerous thing! Communicating with the FMU-developer and adapting

{fmu_manipulation_toolbox-1.8.3 → fmu_manipulation_toolbox-1.8.4}/setup.py

@@ -1,6 +1,6 @@
-from setuptools import setup
 import os
 import re
+from setuptools import setup
 
 from fmu_manipulation_toolbox.version import __author__ as author, __version__ as default_version
 
@@ -25,29 +25,29 @@ setup(
     name="fmu_manipulation_toolbox",
     version=version,
     packages=["fmu_manipulation_toolbox"],
-    package_data={"fmu_manipulation_toolbox": ["resources/win32/client_sm.dll",
-                              "resources/win32/server_sm.exe",
-                              "resources/win64/client_sm.dll",
-                              "resources/win64/server_sm.exe",
-                              "resources/win64/container.dll",
-                              "resources/linux64/client_sm.so",
-                              "resources/linux64/server_sm",
-                              "resources/linux64/container.so",
-                              "resources/linux32/client_sm.so",
-                              "resources/linux32/server_sm",
-                              "resources/license.txt",
-                              "resources/*.png",
-                              "resources/fmi-2.0/*.xsd",
-                              ],
-                  },
+    package_data={"fmu_manipulation_toolbox": [
+        "resources/win32/client_sm.dll",
+        "resources/win32/server_sm.exe",
+        "resources/win64/client_sm.dll",
+        "resources/win64/server_sm.exe",
+        "resources/win64/container.dll",
+        "resources/linux64/client_sm.so",
+        "resources/linux64/server_sm",
+        "resources/linux64/container.so",
+        "resources/linux32/client_sm.so",
+        "resources/linux32/server_sm",
+        "resources/license.txt",
+        "resources/*.png",
+        "resources/fmi-2.0/*.xsd",
+    ]},
     entry_points={"console_scripts": ["fmutool = fmu_manipulation_toolbox.__main__:main",
                                       "fmucontainer = fmu_manipulation_toolbox.cli:fmucontainer"],
                   },
     author=author,
     url="https://github.com/grouperenault/fmu_manipulation_toolbox/",
-    description="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",
-    long_description="""FMU Manipulation Toolbox is a python application which help to modify a Functional Mock-up Units (FMUs) 
+    description="FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units "
+                "(FMUs) without recompilation or bundling them into FMU Containers",
+    long_description="""FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) 
 without recompilation. It mainly modifies the `modelDescription.xml` file. It is highly customizable.
 
 Manipulating the `modelDescription.xml` can be a dangerous thing! Communicating with the FMU-developer and adapting
@@ -61,6 +61,8 @@ FMU Manipulation Toolbox also allows to group FMU's inside FMU Containers.
         "elementpath >= 4.4.0",
         "colorama >= 0.4.6",
     ],
+    license="BSD-2-Clause",
+    python_requires=">=3.8",
 )
 
 os.remove("fmu_manipulation_toolbox/__version__.py")

fmu_manipulation_toolbox-1.8.3/fmu_manipulation_toolbox/__version__.py

@@ -1 +0,0 @@
-'V1.8.3'

fmu_manipulation_toolbox-1.8.3/fmu_manipulation_toolbox/gui_style.py

@@ -1,129 +0,0 @@
-# if os.name == 'nt':
-#    font = QFont('Consolas')
-#    font.setPointSize(11)
-# else:
-#    font = QFont('Courier New')
-#    font.setPointSize(12)
-# self.setFont(font)
-
-
-gui_style_dark = """
-QWidget {
-    font: 10pt "Verdana";
-    background: #4b4e51;
-    color: #b5bab9;
-}
-QPushButton, QComboBox {
-    min-height: 30px;
-    padding: 1px 1px 0.2em 0.2em;
-    border: 1px solid #282830;
-    border-radius: 5px;
-    color: #dddddd;
-}
-QPushButton:pressed {
-    border: 2px solid #282830;
-}
-QPushButton.info {
-    background-color: #4e6749;
-}
-QPushButton.info:hover {
-    background-color: #5f7850;
-}
-QPushButton.modify {
-    background-color: #98763f;
-}
-QPushButton.modify:hover {
-    background-color: #a9874f;
-}
-QPushButton.removal {
-    background-color: #692e2e;
-}
-QPushButton.removal:hover {
-    background-color: #7a3f3f;
-}
-QPushButton.save {
-    background-color: #564967;
-}
-QPushButton.save:hover {
-    background-color: #675a78;
-}
-QPushButton.quit {
-    background-color: #4571a4;
-}
-QPushButton.quit:hover {
-    background-color: #5682b5;
-}
-QPushButton::disabled {
-    background-color: gray;
-}
-QToolTip {
-    color: black
-}
-QLabel.dropped_fmu {
-    background-color: #b5bab9
-}
-QLabel.title {
-    font: 14pt bold "Verdana";
-}
-QLabel.dropped_fmu:hover {
-    background-color: #c6cbca
-}
-QTextBrowser, QTreeView {
-    font: 11pt "Consolas";
-    background-color: #282830;
-    color: #b5bab9;
-}
-QMenu::item {
-    padding: 2px 250px 2px 20px;
-    border: 1px solid transparent;
-}
-QMenu::item::indicator, QCheckBox::item::indicator {
-    width: 32px;
-    height: 32px;
-}
-QMenu::indicator:checked, QCheckBox::indicator:checked {
-    image: url(images:checkbox-checked.png);
-}
-QMenu::indicator:checked:hover, QCheckBox::indicator:checked:hover {
-    image: url(images:checkbox-checked-hover.png);
-}
-QMenu::indicator:checked:disabled, QCheckBox::indicator:checked:disabled {
-    image: url(images:checkbox-checked-disabled.png);
-}
-QMenu::indicator:unchecked, QCheckBox::indicator:unchecked {
-    image: url(images:checkbox-unchecked.png);
-}
-QMenu::indicator:unchecked:hover, QCheckBox::indicator:unchecked:hover {
-    image: url(images:checkbox-unchecked-hover.png);
-}
-QMenu::indicator:unchecked:disabled, QCheckBox::indicator:unchecked:disabled {
-    image: url(images:checkbox-unchecked-disabled.png);
-}
-QCheckBox::item {
-    padding: 2px 250px 2px 20px;
-    border: 1px solid transparent;
-}
-QTabBar::tab {
-    min-height: 30px;
-    padding: 1px 1px 0.2em 0.2em;
-    color: #dddddd;
-    margin: 2px;
-    margin-bottom: 0px;
-    border: 1px solid #282830;
-    border-top-left-radius: 5px;
-    border-top-right-radius: 5px;
-} 
-QTabBar::tab:selected, QTabBar::tab:hover {
-    background-color: #5f7850;
-    margin-bottom:-1px;
-}
-QTabBar {
-    border-bottom: 1px solid #282830;
-}
-QTabBar::tab:top:last, QTabBar::tab:bottom:last {
-    margin-right: 0;
-}
-QTabBar::tab:top:first, QTabBar::tab:bottom:first {
-    margin-left: 0;
-}
-"""