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

fmu_manipulation_toolbox/split.py

@@ -0,0 +1,314 @@
+import logging
+import zipfile
+import json
+import xml.parsers.expat
+
+from typing import *
+from pathlib import Path
+
+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")
+        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"] = fmu_filename
+            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]] = {
+            "Real": {},
+            "Integer": {},
+            "Boolean": {},
+            "String": {}
+        }
+        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_vr = None
+        self.current_name = None
+        self.current_causality = None
+
+    @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, name, attrs):
+        if name == "ScalarVariable":
+            self.current_name = attrs["name"]
+            self.current_vr = int(attrs["valueReference"])
+            self.current_causality = attrs["causality"]
+        elif name in self.vr_to_name[self.current_fmu_filename]:
+            self.vr_to_name[self.current_fmu_filename][name][self.current_vr] = {"name": self.current_name,
+                                                                                 "causality": self.current_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] = {
+            "Real": {},
+            "Integer": {},
+            "Boolean": {},
+            "String": {}
+        }
+        parser = xml.parsers.expat.ParserCreate()
+        self.current_fmu_filename = fmu_filename
+        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.config["mt"] = flags[0] == "1"
+            self.config["profiling"] = self.get_line(file) == "1"
+            self.config["sequential"] = False
+        elif len(flags) == 3:
+            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):
+            fmu_filename = self.get_line(file)
+            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 ("Real", "Integer", "Boolean", "String"):
+            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 ("Real", "Integer", "Boolean", "String"):
+                    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 ("Real", "Integer", "Boolean", "String"):
+                    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 ("Real", "Integer", "Boolean", "String"):
+                    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"])
+
+            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.9rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.8.4.2rc1
+Version: 1.9rc0
 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.8.4.2rc1.dist-info → fmu_manipulation_toolbox-1.9rc0.dist-info}/RECORD

@@ -1,14 +1,14 @@
 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=jnm0HeOalO32T8hqtCK89pKFbJPLz-YFYj_G4Pi_q6M,15
-fmu_manipulation_toolbox/assembly.py,sha256=p8c8l2BLexns21ADr8WhmedLO015Oma1tOHEYZwvgpk,25900
-fmu_manipulation_toolbox/checker.py,sha256=lE2MpH4BAKCDjUvbr06N56u7ao8hWXaJgMKaLvmhFTQ,2272
-fmu_manipulation_toolbox/cli.py,sha256=2p5T1qp7kTcMlScwmvXyUfEmAIGSJsld96ObY216QMA,10616
-fmu_manipulation_toolbox/fmu_container.py,sha256=V6-pcAdkj380h16Gbxe0kmzfw1n8GDoqmpI270v2ZsE,32079
-fmu_manipulation_toolbox/fmu_operations.py,sha256=zxsbwnfctmTv-wU37GiiaX3CFM7LmvXAVDCNpdVyRZo,15886
-fmu_manipulation_toolbox/gui.py,sha256=3y_3CjPr-R-Oa5DTCm0LLnOLVG0_IFjadpNjACAmayQ,29222
+fmu_manipulation_toolbox/__version__.py,sha256=pIetL3-rgAy__3Y9bhoI5aPvTCG8a1qRIBr7IZdM-aA,12
+fmu_manipulation_toolbox/assembly.py,sha256=1jlNc_Rfls2Nah22sd9IL11rC0J5MWs0slT4Bc3sjOw,26364
+fmu_manipulation_toolbox/checker.py,sha256=836wCri6aEl0M6_xHPZ94JRngFjsy8Ee-_t8bzclxBs,2332
+fmu_manipulation_toolbox/container.py,sha256=DjzRgSGNth50V-8eQ107mbYZQq1Q5-ZPsO6E-oZG4KE,32831
+fmu_manipulation_toolbox/gui.py,sha256=tVTPLbGZlD5P0WYqaD5B4crG2nHjBGe73yAJrzRXpYE,29218
 fmu_manipulation_toolbox/gui_style.py,sha256=uzEruJumnC5Vf2cfHXVa_c-SHAQoTvDWemro3-b9Mpc,6492
 fmu_manipulation_toolbox/help.py,sha256=aklKiLrsE0adSzQ5uoEB1sBDmI6s4l231gavu4XxxzA,5856
+fmu_manipulation_toolbox/operations.py,sha256=p0e6OgNRT0JrQaDjhdHk1rxVoRXbdhPHueVvn021UdM,16346
+fmu_manipulation_toolbox/split.py,sha256=lHIct-ANlFB0p7MgViUaSF8jlOlD1-M7TP-I-x9kkpI,13061
 fmu_manipulation_toolbox/version.py,sha256=OhBLkZ1-nhC77kyvffPNAf6m8OZe1bYTnNf_PWs1NvM,392
 fmu_manipulation_toolbox/resources/checkbox-checked-disabled.png,sha256=FWIuyrXlaNLLePHfXj7j9ca5rT8Hgr14KCe1EqTCZyk,2288
 fmu_manipulation_toolbox/resources/checkbox-checked-hover.png,sha256=KNlV-d_aJNTTvUVXKGT9DBY30sIs2LwocLJrFKNKv8k,2419
@@ -34,19 +34,31 @@ 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/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=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=diiqk5qF2doso3lYvb1qL-B062HY7-qgf55RItP9d3U,50152
+fmu_manipulation_toolbox/resources/linux64/container.so,sha256=0hpVEgJkGxbgMeoVAgeqL73aewZ8j-tfzXlf0A0UBpM,85064
 fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=ulfoPvmaYe9nInYcVEyj7mD9zDzGk56OUoWx1mPKLiE,22768
-fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=ttt3rSF4hqNhxIEiXaJx95-_9pPD44r1gjK5ky76bMA,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=Xh_YAy8OfLXKVhGuxPl940YzEePiU65HKOLkAHUzKsk,15872
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=cRO6IW_i5mom29FLhWIrYp0aesyZPh-slQJrDe0tOLU,22016
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=ZLKDYR10jE17Yr2ZtIJTUdk2b_4ObLxA4zAcqfFDc50,40960
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=pMmVbYV5G3j1fxqVUY32h2f6CJQCtURG_w10sjsrMgA,19456
-fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
-fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/METADATA,sha256=pZQUBDsxkfGn94TulBQLpB2bYife9duUIo9XF9edx-4,1160
-fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/entry_points.txt,sha256=jCPLMBdS-eOvmRfDv7n0wHZSbJHccHviW03mz5vwO-Q,124
-fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/RECORD,,
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=ZF0W5N4ZZgMWVnyYrLrEgxamj3WNw667QK5pqK4HvnA,17920
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=KnUM49rDTpTHjVr-J2kfBsYnQnPsX7ho6H7vTlF8i-E,15872
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=58N8xOmJ9XU_oe2rC9JP95lzR-IhDzbwD9FDPaQ7VtM,22016
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=bvxsESgpzAn7IyLnf5Oc41pBPCM7tQz0LJrlXaSpTJQ,57856
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=ftJC5fBoCnlzrcbLJBIfniOAieWGFHZ5klv5UFL9LEE,19968
+fmu_manipulation_toolbox-1.9rc0.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
+fmu_manipulation_toolbox-1.9rc0.dist-info/METADATA,sha256=kWBmPNMw9UYn11B144bSf7H0inSSo6uD-Cpe0h2OyQ4,1156
+fmu_manipulation_toolbox-1.9rc0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_manipulation_toolbox-1.9rc0.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
+fmu_manipulation_toolbox-1.9rc0.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.9rc0.dist-info/RECORD,,

fmu_manipulation_toolbox-1.9rc0.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()

fmu_manipulation_toolbox-1.8.4.2rc1.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-fmucontainer = fmu_manipulation_toolbox.cli:fmucontainer
-fmutool = fmu_manipulation_toolbox.__main__:main