fmu-manipulation-toolbox 1.8.4.2rc1__py3-none-any.whl → 1.9__py3-none-any.whl

fmu_manipulation_toolbox/split.py

@@ -0,0 +1,331 @@
+import logging
+import zipfile
+import json
+import xml.parsers.expat
+
+from typing import *
+from pathlib import Path
+
+from .container import EmbeddedFMUPort
+
+logger = logging.getLogger("fmu_manipulation_toolbox")
+
+
+class FMUSplitterError(Exception):
+    def __init__(self, message: str):
+        self.message = message
+
+    def __str__(self):
+        return str(self.message)
+
+
+class FMUSplitterPort:
+    def __init__(self, fmu_filename: str, port_name):
+        self.fmu_filename = fmu_filename
+        self.port_name = port_name
+
+    def __str__(self):
+        return f"{self.fmu_filename}/{self.port_name}"
+
+
+class FMUSplitterLink:
+    def __init__(self):
+        self.from_port: Optional[FMUSplitterPort] = None
+        self.to_port: List[FMUSplitterPort] = []
+
+    def __str__(self):
+        to_str = ", ".join([f"{port}" for port in self.to_port])
+        return f"{self.from_port} -> {to_str}"
+
+
+class FMUSplitter:
+    def __init__(self, fmu_filename: str):
+        self.fmu_filename = Path(fmu_filename)
+        self.directory = self.fmu_filename.with_suffix(".dir")
+        self.zip = None # to handle error
+        self.zip = zipfile.ZipFile(self.fmu_filename)
+        self.filenames_list = self.zip.namelist()
+        self.dir_set = self.get_dir_set()
+
+        if "resources/container.txt" not in self.filenames_list:
+                raise FMUSplitterError(f"FMU file {self.fmu_filename} is not an FMU Container.")
+
+        self.directory.mkdir(exist_ok=True)
+        logger.info(f"Preparing to split '{self.fmu_filename}' into '{self.directory}'")
+
+    def get_dir_set(self) -> Set[str]:
+        dir_set = set()
+        for filename in self.filenames_list:
+            parent = "/".join(filename.split("/")[:-1])
+            dir_set.add(parent+"/")
+        return dir_set
+
+    def __del__(self):
+        if self.zip is not None:
+            logger.debug("Closing zip file")
+            self.zip.close()
+
+    def split_fmu(self):
+        logger.info(f"Splitting...")
+        config = self._split_fmu(fmu_filename=str(self.fmu_filename), relative_path="")
+        config_filename = self.directory / self.fmu_filename.with_suffix(".json").name
+        with open(config_filename, "w") as file:
+            json.dump(config, file, indent=2)
+        logger.info(f"Container definition saved to '{config_filename}'")
+
+    def _split_fmu(self, fmu_filename: str, relative_path: str) -> Dict[str, Any]:
+        txt_filename = f"{relative_path}resources/container.txt"
+
+        if txt_filename in self.filenames_list:
+            description = FMUSplitterDescription(self.zip)
+            config = description.parse_txt_file(txt_filename)
+            config["name"] = Path(fmu_filename).name
+            for i, fmu_filename in enumerate(config["candidate_fmu"]):
+                directory = f"{relative_path}resources/{i:02x}/"
+                if directory not in self.dir_set:
+                    directory = f"{relative_path}resources/{fmu_filename}/"
+                    if directory not in self.dir_set:
+                        raise FMUSplitterError(f"{directory} not found in FMU")
+                sub_config = self._split_fmu(fmu_filename=fmu_filename, relative_path=directory)
+                if isinstance(sub_config, str):
+                    key = "fmu"
+                else:
+                    key = "container"
+                try:
+                    config[key].append(sub_config)
+                except KeyError:
+                    config[key] = [sub_config]
+            config.pop("candidate_fmu")
+        else:
+            config = fmu_filename
+            self.extract_fmu(relative_path, str(self.directory / fmu_filename))
+
+        return config
+
+    def extract_fmu(self, directory: str, filename: str):
+        logger.debug(f"Extracting {directory} to {filename}")
+        with zipfile.ZipFile(filename, "w", zipfile.ZIP_DEFLATED) as fmu_file:
+            for file in self.zip.namelist():
+                if file.startswith(directory):
+                    data = self.zip.read(file)
+                    fmu_file.writestr(file[len(directory):], data)
+        logger.info(f"FMU Extraction of '{filename}'")
+
+class FMUSplitterDescription:
+    def __init__(self, zip):
+        self.zip = zip
+        self.links: Dict[str, Dict[int, FMUSplitterLink]] = dict((el, {}) for el in EmbeddedFMUPort.ALL_TYPES)
+        self.vr_to_name: Dict[str, Dict[str, Dict[int, Dict[str, str]]]] = {} # name, fmi_type, vr <-> {name, causality}
+        self.config: Dict[str, Any] = {
+            "auto_input": False,
+            "auto_output": False,
+            "auto_parameter": False,
+            "auto_local": False,
+            "auto_link": False,
+        }
+        self.fmu_filename_list = []
+
+        # used for modelDescription.xml parsing
+        self.current_fmu_filename = None
+        self.current_fmi_version = None
+        self.current_vr = None
+        self.current_name = None
+        self.current_causality = None
+        self.supported_fmi_types: Tuple[str] = tuple()
+
+    @staticmethod
+    def get_line(file):
+        for line in file:
+            line = line.decode('utf-8').strip()
+            if line and not line.startswith("#"):
+                return line
+        raise StopIteration
+
+    def start_element(self, tag, attrs):
+        if tag == "fmiModelDescription":
+            self.current_fmi_version = attrs["fmiVersion"]
+        elif tag == "ScalarVariable":
+            self.current_name = attrs["name"]
+            self.current_vr = int(attrs["valueReference"])
+            self.current_causality = attrs["causality"]
+        elif self.current_fmi_version == "2.0" and tag in EmbeddedFMUPort.FMI_TO_CONTAINER[2]:
+            fmi_type = EmbeddedFMUPort.FMI_TO_CONTAINER[2][tag]
+            self.vr_to_name[self.current_fmu_filename][fmi_type][self.current_vr] = {
+                "name": self.current_name,
+                "causality": self.current_causality}
+        elif self.current_fmi_version == "3.0" and tag in EmbeddedFMUPort.FMI_TO_CONTAINER[3]:
+            fmi_type = EmbeddedFMUPort.FMI_TO_CONTAINER[3][tag]
+            self.vr_to_name[self.current_fmu_filename][fmi_type][int(attrs["valueReference"])] = {
+                "name": attrs["name"],
+                "causality": attrs["causality"]}
+        else:
+            self.current_vr = None
+            self.current_name = None
+            self.current_causality = None
+
+    def parse_model_description(self, directory: str, fmu_filename: str):
+
+        if directory == ".":
+            filename = "modelDescription.xml"
+        else:
+            filename = f"{directory}/modelDescription.xml"
+
+        self.vr_to_name[fmu_filename] = dict((el, {}) for el in EmbeddedFMUPort.ALL_TYPES)
+        parser = xml.parsers.expat.ParserCreate()
+        self.current_fmu_filename = fmu_filename
+        self.current_fmi_version = None
+        self.current_vr = None
+        self.current_name = None
+        self.current_causality = None
+        parser.StartElementHandler = self.start_element
+        with (self.zip.open(filename) as file):
+            logger.debug(f"Parsing '{filename}' ({fmu_filename})")
+            parser.ParseFile(file)
+
+    def parse_txt_file_header(self, file, txt_filename):
+        flags = self.get_line(file).split(" ")
+        if len(flags) == 1:
+            self.supported_fmi_types = ("Real", "Integer", "Boolean", "String")
+            self.config["mt"] = flags[0] == "1"
+            self.config["profiling"] = self.get_line(file) == "1"
+            self.config["sequential"] = False
+        elif len(flags) == 3:
+            self.supported_fmi_types = EmbeddedFMUPort.ALL_TYPES
+            self.config["mt"] = flags[0] == "1"
+            self.config["profiling"] = flags[1] == "1"
+            self.config["sequential"] = flags[2] == "1"
+        else:
+            raise FMUSplitterError(f"Cannot interpret flags '{flags}'")
+
+        self.config["step_size"] = float(self.get_line(file))
+        nb_fmu = int(self.get_line(file))
+        logger.debug(f"Number of FMUs: {nb_fmu}")
+        self.config["candidate_fmu"] = []
+
+        for i in range(nb_fmu):
+            # format is
+            #    filename.fmu
+            # or
+            #    filename.fmu fmi_version
+            fmu_filename = self.get_line(file)
+            if ' ' in fmu_filename:
+                fmu_filename = fmu_filename.split(' ')[0]
+                # fmi version is not needed for further operations
+
+            base_directory = "/".join(txt_filename.split("/")[0:-1])
+
+            directory = f"{base_directory}/{fmu_filename}"
+            if f"{directory}/modelDescription.xml" not in self.zip.namelist():
+                directory = f"{base_directory}/{i:02x}"
+                if f"{directory}/modelDescription.xml" not in self.zip.namelist():
+                    print(self.zip.namelist())
+                    raise FMUSplitterError(f"Cannot find in FMU directory in {directory}.")
+
+            self.parse_model_description(directory, fmu_filename)
+            self.config["candidate_fmu"].append(fmu_filename)
+            _library = self.get_line(file)
+            _uuid = self.get_line(file)
+        _nb_local_variables = self.get_line(file)
+
+    def add_port(self, fmi_type: str, fmu_id: int, fmu_vr: int, container_vr: int):
+        if fmu_id >= 0:
+            fmu_filename = self.config["candidate_fmu"][fmu_id]
+            causality = self.vr_to_name[fmu_filename][fmi_type][fmu_vr]["causality"]
+            fmu_port_name = self.vr_to_name[fmu_filename][fmi_type][fmu_vr]["name"]
+            container_port = self.vr_to_name["."][fmi_type][container_vr]["name"]
+            if not causality == "output":
+                causality = "input"
+                definition = [container_port, fmu_filename, fmu_port_name]
+            else:
+                definition = [fmu_filename, fmu_port_name, container_port]
+
+            try:
+                self.config[causality].append(definition)
+            except KeyError:
+                self.config[causality] = [definition]
+
+            logger.debug(f"Adding container port {causality}: {definition}")
+
+    def parse_txt_file_ports(self, file):
+        for fmi_type in self.supported_fmi_types:
+            nb_port_variables = self.get_line(file).split(" ")[0]
+            for i in range(int(nb_port_variables)):
+                tokens = self.get_line(file).split(" ")
+                if len(tokens) > 3:
+                    container_vr = int(tokens[0])
+                    for j in range(int(tokens[1])):
+                        fmu_id = int(tokens[2 + 2 * j])
+                        fmu_vr = int(tokens[2 + 2 * j + 1])
+                        self.add_port(fmi_type, fmu_id, fmu_vr, container_vr)
+                else:  # For FMUContainer <= 1.8.4
+                    container_vr = int(tokens[0])
+                    fmu_id = int(tokens[1])
+                    fmu_vr = int(tokens[2])
+                    self.add_port(fmi_type, fmu_id, fmu_vr, container_vr)
+
+    def parse_txt_file(self, txt_filename: str):
+        self.parse_model_description(str(Path(txt_filename).parent.parent), ".")
+        logger.debug(f"Parsing container file '{txt_filename}'")
+        with (self.zip.open(txt_filename) as file):
+            self.parse_txt_file_header(file, txt_filename)
+            self.parse_txt_file_ports(file)
+
+            for fmu_filename in self.config["candidate_fmu"]:
+                # Inputs per FMUs
+
+                for fmi_type in self.supported_fmi_types:
+                    nb_input = int(self.get_line(file))
+                    for i in range(nb_input):
+                        local, vr = self.get_line(file).split(" ")
+                        try:
+                            link = self.links[fmi_type][local]
+                        except KeyError:
+                            link = FMUSplitterLink()
+                            self.links[fmi_type][local] = link
+                        link.to_port.append(FMUSplitterPort(fmu_filename,
+                                                            self.vr_to_name[fmu_filename][fmi_type][int(vr)]["name"]))
+
+                for fmi_type in self.supported_fmi_types:
+                    nb_start = int(self.get_line(file))
+                    for i in range(nb_start):
+                        tokens = self.get_line(file).split(" ")
+                        vr = int(tokens[0])
+                        value = tokens[-1]
+                        start_definition = [fmu_filename, self.vr_to_name[fmu_filename][fmi_type][vr]["name"],
+                                            value]
+                        try:
+                            self.config["start"].append(start_definition)
+                        except KeyError:
+                            self.config["start"] = [start_definition]
+
+                # Output per FMUs
+                for fmi_type in self.supported_fmi_types:
+                    nb_output = int(self.get_line(file))
+
+                    for i in range(nb_output):
+                        local, vr = self.get_line(file).split(" ")
+                        try:
+                            link = self.links[fmi_type][local]
+                        except KeyError:
+                            link = FMUSplitterLink()
+                            self.links[fmi_type][local] = link
+                        link.from_port = FMUSplitterPort(fmu_filename,
+                                                         self.vr_to_name[fmu_filename][fmi_type][int(vr)]["name"])
+                #conversion
+                nb_conversion = int(self.get_line(file))
+                for i in range(nb_conversion):
+                    self.get_line(file)
+
+            logger.debug("End of parsing.")
+
+        for fmi_type, links in self.links.items():
+            for link in links.values():
+                for to_port in link.to_port:
+                    definition = [ link.from_port.fmu_filename, link.from_port.port_name,
+                                   to_port.fmu_filename, to_port.port_name]
+                    try:
+                        self.config["link"].append(definition)
+                    except KeyError:
+                        self.config["link"] = [definition]
+
+        return self.config

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

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

fmu_manipulation_toolbox-1.9.dist-info/RECORD

@@ -0,0 +1,71 @@
+fmu_manipulation_toolbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu_manipulation_toolbox/__main__.py,sha256=FpG0ITBz5q-AvIbXplVh_1g1zla5souFGtpiDdECxEw,352
+fmu_manipulation_toolbox/__version__.py,sha256=RpjnZ-g4XsDa0uZToxk2ez_E9cmR3N2SrOqy0awR3so,7
+fmu_manipulation_toolbox/assembly.py,sha256=XQ_1sB6K1Dk2mnNe-E3_6Opoeub7F9Qaln0EUDzsop8,26553
+fmu_manipulation_toolbox/checker.py,sha256=jw1omfrMMIMHlIpHXpWBcQgIiS9hnHe5T9CZ5KlbVGs,2422
+fmu_manipulation_toolbox/container.py,sha256=Ed6JsWM2oMs-jyGyKmrHHebNuG4qwiGLYtx0BREIiBE,45710
+fmu_manipulation_toolbox/gui.py,sha256=ax-IbGO7GyBG0Mb5okN588CKQDfMxoF1uZtD1_CYnjc,29199
+fmu_manipulation_toolbox/gui_style.py,sha256=s6WdrnNd_lCMWhuBf5LKK8wrfLXCU7pFTLUfvqkJVno,6633
+fmu_manipulation_toolbox/help.py,sha256=j8xmnCrwQpaW-SZ8hSqA1dlTXgaqzQWc4Yr3RH_oqck,6012
+fmu_manipulation_toolbox/operations.py,sha256=VQvFXRHF48e-ZLqoG8nbz61iB5lX6qAkqZHQ0m0lUPw,20577
+fmu_manipulation_toolbox/remoting.py,sha256=N25MDFkIcEWe9CIT1M4L9kea3j-8E7i2I1VOI6zIAdw,3876
+fmu_manipulation_toolbox/split.py,sha256=yFaW6yhvFjOXpRynWzitR7o7uSrxb-RxeFzmQNxUFHI,14147
+fmu_manipulation_toolbox/version.py,sha256=OhBLkZ1-nhC77kyvffPNAf6m8OZe1bYTnNf_PWs1NvM,392
+fmu_manipulation_toolbox/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fmu_manipulation_toolbox/cli/fmucontainer.py,sha256=6UaSSY6UGGlOfIh_CTG-Gk3ZPSd88Pi2cFCuzb87eks,4839
+fmu_manipulation_toolbox/cli/fmusplit.py,sha256=VMDYjmvIsjPHJINZaOt1Zy8D0so6d99285LbS8v-Tro,1734
+fmu_manipulation_toolbox/cli/fmutool.py,sha256=QRe6xQxQMD8FtEzoT5421Bq0YasgdIwOd9Too5TX5zg,6086
+fmu_manipulation_toolbox/cli/utils.py,sha256=gNhdlFYSSNSb0fovzS0crnxgmqqKXe0KtoZZFhRKhfg,1375
+fmu_manipulation_toolbox/resources/checkbox-checked-disabled.png,sha256=FWIuyrXlaNLLePHfXj7j9ca5rT8Hgr14KCe1EqTCZyk,2288
+fmu_manipulation_toolbox/resources/checkbox-checked-hover.png,sha256=KNlV-d_aJNTTvUVXKGT9DBY30sIs2LwocLJrFKNKv8k,2419
+fmu_manipulation_toolbox/resources/checkbox-checked.png,sha256=gzyFqvRFsZixVh6ZlV4SMWUKzglY1rSn7SvJUKMVvtk,2411
+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/container.png,sha256=DnMSCl4hlZqYuLDJpE4EnKIhYYXRbUZ7C_Q2HmAOaHU,16682
+fmu_manipulation_toolbox/resources/drop_fmu.png,sha256=Q7yWe3hzBYuou2xlPN9Yg9lgQYFSVuYxGnp_SRwkVe0,10344
+fmu_manipulation_toolbox/resources/fmu.png,sha256=QrNZ5PRaana0r-7pbluYf20m8ngzOZEZWi-MPSQG1eU,47050
+fmu_manipulation_toolbox/resources/fmu_manipulation_toolbox.png,sha256=iuztmrW9f3Ayi4fe_WdkYZbI1VXrCa1HVasfIhW5J18,38023
+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/icon_fmu.png,sha256=EuygB2xcoM2WAfKKdyKG_UvTL8coM4CkpHSIsSCe_Ks,5189
+fmu_manipulation_toolbox/resources/license.txt,sha256=5ODuU8g8pIkK-NMWXu_rjZ6k7gM7b-N2rmg87-2Kmqw,1583
+fmu_manipulation_toolbox/resources/mask.png,sha256=px1U4hQGL0AmZ4BQPknOVREpMpTSejbah3ntkpqAzFA,3008
+fmu_manipulation_toolbox/resources/model.png,sha256=EAf_HnZJe8zYGZygerG1MMt2U-tMMZlifzXPj4_iORA,208788
+fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=omGiU38-2Zh6pyvPjySKDQ5TNDRVS2lkNDIf8BjHD8A,161560
+fmu_manipulation_toolbox/resources/fmi-2.0/fmi2Annotation.xsd,sha256=OGfyJtaJntKypX5KDpuZ-nV1oYLZ6HV16pkpKOmYox4,2731
+fmu_manipulation_toolbox/resources/fmi-2.0/fmi2AttributeGroups.xsd,sha256=HwyV7LBse-PQSv4z1xjmtzPU3Hjnv4mluq9YdSBNHMQ,3704
+fmu_manipulation_toolbox/resources/fmi-2.0/fmi2ModelDescription.xsd,sha256=JM4j_9q-pc40XYHb28jfT3iV3aYM5JLqD5aRjO72K1E,18939
+fmu_manipulation_toolbox/resources/fmi-2.0/fmi2ScalarVariable.xsd,sha256=hYZGmhvHBuycWMGe1Gt9xQY82c4Ek_5wAO1P2xu5txQ,9675
+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/fmi-3.0/fmi3Annotation.xsd,sha256=H4OB87z_hK5CSrpbzZjxva9VLpitI94Nbm8lQOlwkp8,2570
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3AttributeGroups.xsd,sha256=g6jtK05vCrlHBKun__QqIUe-S7ja6wDZ3KgpaJpReyY,6141
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3BuildDescription.xsd,sha256=G4clniTvFReBcqoABaU8t16OIeMJVZNzW9q1Qys8c9k,7516
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3InterfaceType.xsd,sha256=2KkVadEBEK1L2aatQ3HOjhl2XIv7V6tWcT9WmvpYyI4,4652
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3LayeredStandardManifest.xsd,sha256=DhSi-eVKFmdUv6tHsjWf8GYEfbymhxQKbGbeJYMtGLs,4474
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3ModelDescription.xsd,sha256=0W02POCyDiqwswx9ST97JXa7ZLpXtuNAh37-MxgWluQ,7249
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Terminal.xsd,sha256=uq14wOMseu7R5m8h5Bsmlo0QoMECpYCyfT1cEUtPa_k,4937
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3TerminalsAndIcons.xsd,sha256=-kFjVGjFhZ6zb_bnAoQsJkLhVSZ7w1l_FodKrFzmrQ4,4581
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Type.xsd,sha256=TaHRoUBIFtmdEwBKBpIOE_TtfQR91D0zVjgD7LHn2CM,10107
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Unit.xsd,sha256=CK_F2t5LfyQ6eSNJ8soTFMVK9DU8vD2WiMi2MQvjB0g,3746
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Variable.xsd,sha256=3YU-3q1-c-namz7sMe5cxnmOVOJsRSmfWR02PKv3xaU,19171
+fmu_manipulation_toolbox/resources/fmi-3.0/fmi3VariableDependency.xsd,sha256=YQSBwXt4IsDlyegY8bX-qQHGSfE5TipTPfo2g2yqq1c,3082
+fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=ad_Fo62_Vt4P3DmROhS3B4N-jBD5jQZHYBq20wTL1_U,34756
+fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=gzKU0BTeaRkvhTMQtHHj3K8uYFyEdyGGn_mZy_jG9xo,21304
+fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=JHMekdWhn2RPUDqfH3U7WB8SM1WyGl-0UbaVE-Fh-Aw,32592
+fmu_manipulation_toolbox/resources/linux64/container.so,sha256=3wwgP8xYumKzmaGH761f3D_mkVbUCntOE_UgGUtahyg,135520
+fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=MZn6vITN2qpBHYt_RaK2VnFFp00hk8fTALBHmXPtLwc,22608
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=WcieLopqhHu3fIXZo_k71FMgroylR5pRWs9qGdoVzCc,17920
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=wqKQrr5m6DsdNk5rKFRKwgyTDOySlPX_jMMhdyywMsQ,15360
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=uOTC5yGOtSheSGcWmBEWXhwyrJMJpoKgtTNEo8WJVC0,21504
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=YG2zagCEmzrtGbbNCYir5N-pm5hxPdZft9cZPVMQuWI,98816
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=SikJSqTwrq7HMKITP3ksFi2j0ZqCIqgOMdPMsHi5L8w,18432
+fmu_manipulation_toolbox-1.9.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
+fmu_manipulation_toolbox-1.9.dist-info/METADATA,sha256=8Ls_kJpVghQrFyyDEGHeyc6aKD0LlHKd7rJDAsWbTxk,1153
+fmu_manipulation_toolbox-1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_manipulation_toolbox-1.9.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
+fmu_manipulation_toolbox-1.9.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.9.dist-info/RECORD,,

fmu_manipulation_toolbox-1.9.dist-info/entry_points.txt

@@ -0,0 +1,7 @@
+[console_scripts]
+fmucontainer = fmu_manipulation_toolbox.cli.fmucontainer:fmucontainer
+fmusplit = fmu_manipulation_toolbox.cli.fmusplit:fmusplit
+fmutool = fmu_manipulation_toolbox.cli.fmutool:fmutool
+
+[gui_scripts]
+fmutool-gui = fmu_manipulation_toolbox.gui:main

fmu_manipulation_toolbox/cli.py

@@ -1,235 +0,0 @@
-import argparse
-import logging
-import sys
-from colorama import Fore, Style, init
-
-from .fmu_operations import *
-from .fmu_container import FMUContainerError
-from .assembly import Assembly, AssemblyError
-from .checker import checker_list
-from .version import __version__ as version
-from .help import Help
-
-
-def setup_logger():
-    class CustomFormatter(logging.Formatter):
-        def format(self, record):
-            log_format = "%(levelname)-8s | %(message)s"
-            format_per_level = {
-                logging.DEBUG: str(Fore.BLUE) + log_format,
-                logging.INFO: str(Fore.CYAN) + log_format,
-                logging.WARNING: str(Fore.YELLOW) + log_format,
-                logging.ERROR: str(Fore.RED) + log_format,
-                logging.CRITICAL: str(Fore.RED + Style.BRIGHT) + log_format,
-            }
-            formatter = logging.Formatter(format_per_level[record.levelno])
-            return formatter.format(record)
-    init()
-    logger = logging.getLogger("fmu_manipulation_toolbox")
-    handler = logging.StreamHandler(stream=sys.stdout)
-    handler.setFormatter(CustomFormatter())
-    logger.addHandler(handler)
-    logger.setLevel(logging.INFO)
-
-    return logger
-
-
-def make_wide(formatter, w=120, h=36):
-    """Return a wider HelpFormatter, if possible."""
-    try:
-        # https://stackoverflow.com/a/5464440
-        # beware: "Only the name of this class is considered a public API."
-        kwargs = {'width': w, 'max_help_position': h}
-        formatter(None, **kwargs)
-        return lambda prog: formatter(prog, **kwargs)
-    except TypeError:
-        return formatter
-
-
-def fmutool():
-    print(f"FMU Manipulation Toolbox version {version}")
-    help_message = Help()
-
-    parser = argparse.ArgumentParser(prog='fmutool',
-                                     description="Analyse and Manipulate a FMU by modifying its 'modelDescription.xml'",
-                                     formatter_class=make_wide(argparse.HelpFormatter),
-                                     add_help=False,
-                                     epilog="see: https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/README.md")
-
-    def add_option(option, *args, **kwargs):
-        parser.add_argument(option, *args, help=help_message.usage(option), **kwargs)
-
-    add_option('-h', '-help', action="help")
-
-    # I/O
-    add_option('-input', action='store', dest='fmu_input', default=None, required=True, metavar='path/to/module.fmu')
-    add_option('-output', action='store', dest='fmu_output', default=None, metavar='path/to/module-modified.fmu')
-
-    # Port name manipulation
-    add_option('-remove-toplevel', action='append_const', dest='operations_list', const=OperationStripTopLevel())
-    add_option('-merge-toplevel', action='append_const', dest='operations_list', const=OperationMergeTopLevel())
-    add_option('-trim-until', action='append', dest='operations_list', type=OperationTrimUntil, metavar='prefix')
-    add_option('-remove-regexp', action='append', dest='operations_list', type=OperationRemoveRegexp,
-               metavar='regular-expression')
-    add_option('-keep-only-regexp', action='append', dest='operations_list', type=OperationKeepOnlyRegexp,
-               metavar='regular-expression')
-    add_option('-remove-all', action='append_const', dest='operations_list', const=OperationRemoveRegexp('.*'))
-
-    # Batch Rename
-    add_option('-dump-csv', action='append', dest='operations_list', type=OperationSaveNamesToCSV,
-               metavar='path/to/list.csv')
-    add_option('-rename-from-csv', action='append', dest='operations_list', type=OperationRenameFromCSV,
-               metavar='path/to/translation.csv')
-
-    # Remoting
-    add_option('-add-remoting-win32', action='append_const', dest='operations_list', const=OperationAddRemotingWin32())
-    add_option('-add-remoting-win64', action='append_const', dest='operations_list', const=OperationAddRemotingWin64())
-    add_option('-add-frontend-win32', action='append_const', dest='operations_list', const=OperationAddFrontendWin32())
-    add_option('-add-frontend-win64', action='append_const', dest='operations_list', const=OperationAddFrontendWin64())
-
-    # Extraction / Removal
-    add_option('-extract-descriptor', action='store', dest='extract_description',
-               metavar='path/to/saved-modelDescriptor.xml')
-    add_option('-remove-sources', action='append_const', dest='operations_list',
-               const=OperationRemoveSources())
-    # Filter
-    add_option('-only-parameters', action='append_const', dest='apply_on', const='parameter')
-    add_option('-only-inputs', action='append_const', dest='apply_on', const='input')
-    add_option('-only-outputs', action='append_const', dest='apply_on', const='output')
-    # Checker
-    add_option('-summary', action='append_const', dest='operations_list', const=OperationSummary())
-    add_option('-check', action='append_const', dest='operations_list', const=[checker() for checker in checker_list])
-
-    cli_options = parser.parse_args()
-    # handle the "no operation" use case
-    if not cli_options.operations_list:
-        cli_options.operations_list = []
-
-    if cli_options.fmu_input == cli_options.fmu_output:
-        print(f"FATAL ERROR: '-input' and '-output' should point to different files.")
-        sys.exit(-3)
-
-    print(f"READING Input='{cli_options.fmu_input}'")
-    try:
-        fmu = FMU(cli_options.fmu_input)
-    except FMUException as reason:
-        print(f"FATAL ERROR: {reason}")
-        sys.exit(-4)
-
-    if cli_options.apply_on:
-        print("Applying operation for :")
-        for causality in cli_options.apply_on:
-            print(f"     - causality = {causality}")
-
-    def flatten(list_of_list: list):
-        return [x for xs in list_of_list for x in xs]
-
-    for operation in flatten(cli_options.operations_list):
-        print(f"     => {operation}")
-        try:
-            fmu.apply_operation(operation, cli_options.apply_on)
-        except OperationException as reason:
-            print(f"ERROR: {reason}")
-            sys.exit(-6)
-
-    if cli_options.extract_description:
-        print(f"WRITING ModelDescriptor='{cli_options.extract_description}'")
-        fmu.save_descriptor(cli_options.extract_description)
-
-    if cli_options.fmu_output:
-        print(f"WRITING Output='{cli_options.fmu_output}'")
-        try:
-            fmu.repack(cli_options.fmu_output)
-        except FMUException as reason:
-            print(f"FATAL ERROR: {reason}")
-            sys.exit(-5)
-    else:
-        print(f"INFO    Modified FMU is not saved. If necessary use '-output' option.")
-
-
-def fmucontainer():
-    logger = setup_logger()
-
-    logger.info(f"FMUContainer version {version}")
-    parser = argparse.ArgumentParser(prog="fmucontainer", description="Generate FMU from FMU's",
-                                     formatter_class=make_wide(argparse.ArgumentDefaultsHelpFormatter),
-                                     add_help=False,
-                                     epilog="see: https://github.com/grouperenault/fmu_manipulation_toolbox/blob/main/"
-                                            "container/README.md")
-
-    parser.add_argument('-h', '-help', action="help")
-
-    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|json|ssp},[:step_size]", required=True,
-                        help="Description of the container to create.")
-
-    parser.add_argument("-debug", action="store_true", dest="debug",
-                        help="Add lot of useful log during the process.")
-
-    parser.add_argument("-no-auto-input", action="store_false", dest="auto_input", default=True,
-                        help="Create ONLY explicit input.")
-
-    parser.add_argument("-no-auto-output", action="store_false", dest="auto_output", default=True,
-                        help="Create ONLY explicit output.")
-
-    parser.add_argument("-auto-parameter", action="store_true", dest="auto_parameter", default=False,
-                        help="Expose parameters of the embedded fmu's.")
-
-    parser.add_argument("-auto-local", action="store_true", dest="auto_local", default=False,
-                        help="Expose local variables of the embedded fmu's.")
-
-    parser.add_argument("-no-auto-link", action="store_false", dest="auto_link", default=True,
-                        help="Create ONLY explicit links.")
-
-    parser.add_argument("-mt", action="store_true", dest="mt", default=False,
-                        help="Enable Multi-Threaded mode for the generated container.")
-
-    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:
-            tokens = description.split(":")
-            filename = ":".join(tokens[:-1])
-            step_size = float(tokens[-1])
-        except ValueError:
-            step_size = None
-            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,
-                                auto_local=config.auto_local, mt=config.mt,
-                                profiling=config.profiling, fmu_directory=fmu_directory, debug=config.debug,
-                                auto_parameter=config.auto_parameter)
-        except FileNotFoundError as e:
-            logger.fatal(f"Cannot read file: {e}")
-            continue
-        except (FMUContainerError, AssemblyError) as e:
-            logger.fatal(f"{filename}: {e}")
-            continue
-
-        try:
-            assembly.make_fmu(dump_json=config.dump)
-        except FMUContainerError as e:
-            logger.fatal(f"{filename}: {e}")
-            continue
-
-
-if __name__ == "__main__":
-    fmucontainer()