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

fmu_manipulation_toolbox/__version__.py

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

fmu_manipulation_toolbox/assembly.py

@@ -0,0 +1,456 @@
+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, FMUContainerError
+
+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: 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
+        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.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"
+
+        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 FMUContainerError(f"FMU directory is not valid: '{fmu_directory}'")
+
+        self.description_pathname = fmu_directory / self.filename  # 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 FMUContainerError(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.description_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
+
+                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.")
+
+        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 _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)
+        # no else: check on rule is already done in read_description()
+
+    @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 read_json(self):
+        with open(self.description_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)
+        if not self.root.name:
+            self.root.name = str(self.filename.with_suffix(".fmu"))
+
+    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
+        json_node["mt"] = node.mt
+        json_node["profiling"] = node.profiling
+        json_node["auto_link"] = node.auto_link
+        if node.step_size:
+            json_node["step_size"] = node.step_size
+
+        if node.children:
+            json_node["container"] = [self.json_encode_node(child) for child in node.children]
+
+        if node.fmu_names_list:
+            json_node["fmu"] = [f"{fmu_name}" for fmu_name in sorted(node.fmu_names_list)]
+
+        if node.input_ports:
+            json_node["input"] = [[f"{source}", f"{port.fmu_name}", f"{port.port_name}"]
+                                  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}"]
+                                   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}",
+                                  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]
+                                  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]
+
+        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.")
+
+        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)
+
+    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"))
+            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
 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 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')
@@ -342,6 +349,8 @@ class FMUContainer:
     def sanity_check(self, step_size: Union[float, None]):
         nb_error = 0
         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}' "
@@ -412,12 +421,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 +447,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 +565,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 +610,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 +639,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

@@ -209,11 +209,10 @@ 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()
@@ -289,7 +288,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')
@@ -434,7 +433,7 @@ class FMUManipulationToolboxlMainWindow(QWidget):
             scroll_bar.setValue(scroll_bar.maximum())
 
 
-class Application:
+class Application(QApplication):
     """
 Analyse and modify your FMUs.
 
@@ -442,12 +441,13 @@ Note: modifying the modelDescription.xml can damage your FMU ! Communicating wit
 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;}
@@ -479,15 +479,26 @@ 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)
 
-    def exit(self):
-        self.app.exit()
+
+        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')))
+
+        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.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fmu_manipulation_toolbox
-Version: 1.7.5
+Version: 1.8
 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.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=wgnOv0C5Ic8_OmpPXk8qES2otG4lRxHybApfWS9AX58,7
+fmu_manipulation_toolbox/assembly.py,sha256=3YGVBUMjTNwzU-GxUCT-uER3DkX_r4V44ekfzwTmT8I,19364
 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=bIfQAGMyTmsx8HQSvu0Ic_UqDRvvm_Op3RCwHpjfqVI,10070
+fmu_manipulation_toolbox/fmu_container.py,sha256=cPJ_f0-KrBpF8Ri9D9RhgGIuT9BiqWpus4nPet4a3PU,26488
 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=4gD6D4f1jQm1UlVC0iV4nuFNOT-y-AuJ13_7LBVm944,20269
 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,11 +15,12 @@ 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=aynTWUw5220BXPZIhNco5AkR-ydCAwibWb5gdhR3cCQ,20077
 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/model.png,sha256=EAf_HnZJe8zYGZygerG1MMt2U-tMMZlifzXPj4_iORA,208788
 fmu_manipulation_toolbox/resources/fmi-2.0/fmi2Annotation.xsd,sha256=OGfyJtaJntKypX5KDpuZ-nV1oYLZ6HV16pkpKOmYox4,2731
@@ -28,19 +30,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=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,,