fmu-manipulation-toolbox 1.9rc4__tar.gz → 1.9rc6__tar.gz

{fmu_manipulation_toolbox-1.9rc4 → fmu_manipulation_toolbox-1.9rc6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9rc4
+Version: 1.9rc6
 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.9rc6/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.9-rc6'

fmu_manipulation_toolbox-1.9rc6/fmu_manipulation_toolbox/cli/fmucontainer.py

@@ -0,0 +1,103 @@
+import argparse
+import logging
+
+from pathlib import Path
+
+from .utils import setup_logger, make_wide
+from ..assembly import Assembly, AssemblyError
+from ..container import FMUContainerError
+from ..version import __version__ as version
+
+
+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("-fmi", action="store", dest="fmi_version", required=False, default="2",
+                        help="Define version of FMI to be used for container interface."
+                             "Only '2' or '3' is supported.")
+
+    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("-sequential", action="store_true", dest="sequential", default=False,
+                        help="Use sequential mode to schedule embedded fmu's.")
+
+    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, sequential=config.sequential,
+                                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, fmi_version=int(config.fmi_version))
+        except FMUContainerError as e:
+            logger.fatal(f"{filename}: {e}")
+            continue
+
+if __name__ == "__main__":
+    fmucontainer()

fmu_manipulation_toolbox-1.9rc6/fmu_manipulation_toolbox/cli/fmusplit.py

@@ -0,0 +1,45 @@
+import argparse
+import logging
+
+from .utils import setup_logger, make_wide
+from ..split import FMUSplitter, FMUSplitterError
+from ..version import __version__ as version
+
+
+def fmusplit():
+    logger = setup_logger()
+
+    logger.info(f"FMUSplit version {version}")
+    parser = argparse.ArgumentParser(prog="fmusplit", description="Split FMU Container into 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("-debug", action="store_true", dest="debug",
+                        help="Add lot of useful log during the process.")
+
+    parser.add_argument("-fmu", action="append", dest="fmu_filename_list", default=[],
+                        metavar="filename.fmu", required=True,
+                        help="Description of the FMU container to split.")
+
+    config = parser.parse_args()
+
+    if config.debug:
+        logger.setLevel(logging.DEBUG)
+
+    for fmu_filename in config.fmu_filename_list:
+        try:
+            splitter = FMUSplitter(fmu_filename)
+            splitter.split_fmu()
+        except FMUSplitterError as e:
+            logger.fatal(f"{fmu_filename}: {e}")
+            continue
+        except FileNotFoundError as e:
+            logger.fatal(f"Cannot read file: {e}")
+            continue
+
+
+if __name__ == "__main__":
+    fmusplit()

fmu_manipulation_toolbox-1.9rc6/fmu_manipulation_toolbox/cli/fmutool.py

@@ -0,0 +1,115 @@
+import argparse
+import sys
+
+from .utils import setup_logger, make_wide
+from ..operations import (OperationSummary, OperationError, OperationRemoveRegexp,
+                          OperationRemoveSources, OperationTrimUntil, OperationKeepOnlyRegexp, OperationMergeTopLevel,
+                          OperationStripTopLevel, OperationRenameFromCSV, OperationSaveNamesToCSV, FMU, FMUError)
+from ..remoting import  (OperationAddFrontendWin32, OperationAddFrontendWin64, OperationAddRemotingWin32,
+                         OperationAddRemotingWin64)
+from ..checker import checker_list
+from ..version import __version__ as version
+from ..help import Help
+
+
+def fmutool():
+    logger = setup_logger()
+
+    logger.info(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:
+        logger.fatal(f"'-input' and '-output' should point to different files.")
+        sys.exit(-3)
+
+    logger.info(f"READING Input='{cli_options.fmu_input}'")
+    try:
+        fmu = FMU(cli_options.fmu_input)
+    except FMUError as reason:
+        logger.fatal(f"{reason}")
+        sys.exit(-4)
+
+    if cli_options.apply_on:
+        logger.info("Applying operation for :")
+        for causality in cli_options.apply_on:
+            logger.info(f"     - causality = {causality}")
+
+    for operation in cli_options.operations_list:
+        logger.info(f"     => {operation}")
+        try:
+            fmu.apply_operation(operation, cli_options.apply_on)
+        except OperationError as reason:
+            logger.fatal(f"{reason}")
+            sys.exit(-6)
+
+    if cli_options.extract_description:
+        logger.info(f"WRITING ModelDescriptor='{cli_options.extract_description}'")
+        fmu.save_descriptor(cli_options.extract_description)
+
+    if cli_options.fmu_output:
+        logger.info(f"WRITING Output='{cli_options.fmu_output}'")
+        try:
+            fmu.repack(cli_options.fmu_output)
+        except FMUError as reason:
+            logger.fatal(f"FATAL ERROR: {reason}")
+            sys.exit(-5)
+    else:
+        logger.info(f"INFO    Modified FMU is not saved. If necessary use '-output' option.")
+
+if __name__ == "__main__":
+    fmutool()

fmu_manipulation_toolbox-1.9rc6/fmu_manipulation_toolbox/cli/utils.py

@@ -0,0 +1,36 @@
+import logging
+import sys
+from colorama import Fore, Style, init
+
+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

{fmu_manipulation_toolbox-1.9rc4 → fmu_manipulation_toolbox-1.9rc6}/fmu_manipulation_toolbox/container.py

@@ -10,7 +10,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import *
 
-from .operations import FMU, OperationAbstract, FMUError
+from .operations import FMU, OperationAbstract, FMUError, FMUPort
 from .version import __version__ as tool_version
 
 
@@ -71,9 +71,7 @@ class EmbeddedFMUPort:
         "string"
     )
 
-
-
-    def __init__(self, fmi_type, attrs: Dict[str, str], fmi_version=0):
+    def __init__(self, fmi_type, attrs: Union[FMUPort, Dict[str, str]], fmi_version=0):
         self.causality = attrs.get("causality", "local")
         self.variability = attrs.get("variability", "continuous")
         self.name = attrs["name"]
@@ -88,8 +86,6 @@ class EmbeddedFMUPort:
         self.start_value = attrs.get("start", None)
         self.initial = attrs.get("initial", None)
 
-
-
     def xml(self, vr: int, name=None, causality=None, start=None, fmi_version=2) -> str:
         if name is None:
             name = self.name
@@ -191,7 +187,7 @@ class EmbeddedFMU(OperationAbstract):
         if fmi_version == "2.0":
             self.guid = attrs['guid']
             self.fmi_version = 2
-        if fmi_version == "3.0":
+        if fmi_version == "3.0": # TODO: handle 3.x cases
             self.guid = attrs['instantiationToken']
             self.fmi_version = 3
 
@@ -208,7 +204,13 @@ class EmbeddedFMU(OperationAbstract):
         self.start_time = float(attrs.get("startTime", 0.0))
         self.stop_time = float(attrs.get("stopTime", self.start_time + 1.0))
 
-    def port_attrs(self, fmu_port):
+    def port_attrs(self, fmu_port: FMUPort):
+        # Container will manage Enumeration as Integer
+        if fmu_port.fmi_type == "Enumeration":
+            if self.fmi_version == 2:
+                fmu_port.fmi_type = "Integer"
+            else:
+                fmu_port.fmi_type = "Int32"
         port = EmbeddedFMUPort(fmu_port.fmi_type, fmu_port, fmi_version=self.fmi_version)
         self.ports[port.name] = port
 

{fmu_manipulation_toolbox-1.9rc4 → fmu_manipulation_toolbox-1.9rc6}/fmu_manipulation_toolbox/operations.py

@@ -160,8 +160,9 @@ class Manipulation:
                 self.current_port = FMUPort()
                 self.current_port.push_attrs(attrs)
             elif self.fmu.fmi_version == 2 and name in self.fmu.FMI2_TYPES:
-                self.current_port.fmi_type = name
-                self.current_port.push_attrs(attrs)
+                if self.current_port: # <Enumeration> can be found before port defition. Ignored.
+                    self.current_port.fmi_type = name
+                    self.current_port.push_attrs(attrs)
             elif self.fmu.fmi_version == 3 and name in self.fmu.FMI3_TYPES:
                 self.current_port = FMUPort()
                 self.current_port.fmi_type = name

{fmu_manipulation_toolbox-1.9rc4 → fmu_manipulation_toolbox-1.9rc6}/fmu_manipulation_toolbox/remoting.py

@@ -19,8 +19,8 @@ class OperationAddRemotingWinAbstract(OperationAbstract):
             "Integer": [],
             "Boolean": []
         }
-        self.nb_input = 0;
-        self.nb_output = 0;
+        self.nb_input = 0
+        self.nb_output = 0
 
     def fmi_attrs(self, attrs):
         if not attrs["fmiVersion"] == "2.0":
@@ -61,7 +61,7 @@ class OperationAddRemotingWinAbstract(OperationAbstract):
 
     def port_attrs(self, fmu_port) -> int:
         try:
-            self.vr[fmu_port.fmi_type].append(fmu_port["valueReference"])
+            self.vr[fmu_port.fmi_type].append(int(fmu_port["valueReference"]))
             if fmu_port["causality"] in ("input", "parameter"):
                 self.nb_input += 1
             else:

{fmu_manipulation_toolbox-1.9rc4 → fmu_manipulation_toolbox-1.9rc6}/fmu_manipulation_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9rc4
+Version: 1.9rc6
 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.9rc4 → fmu_manipulation_toolbox-1.9rc6}/fmu_manipulation_toolbox.egg-info/SOURCES.txt

@@ -21,6 +21,11 @@ fmu_manipulation_toolbox.egg-info/dependency_links.txt
 fmu_manipulation_toolbox.egg-info/entry_points.txt
 fmu_manipulation_toolbox.egg-info/requires.txt
 fmu_manipulation_toolbox.egg-info/top_level.txt
+fmu_manipulation_toolbox/cli/__init__.py
+fmu_manipulation_toolbox/cli/fmucontainer.py
+fmu_manipulation_toolbox/cli/fmusplit.py
+fmu_manipulation_toolbox/cli/fmutool.py
+fmu_manipulation_toolbox/cli/utils.py
 fmu_manipulation_toolbox/resources/checkbox-checked-disabled.png
 fmu_manipulation_toolbox/resources/checkbox-checked-hover.png
 fmu_manipulation_toolbox/resources/checkbox-checked.png

{fmu_manipulation_toolbox-1.9rc4 → fmu_manipulation_toolbox-1.9rc6}/setup.py

@@ -24,7 +24,7 @@ except Exception as e:
 setup(
     name="fmu_manipulation_toolbox",
     version=version,
-    packages=["fmu_manipulation_toolbox"],
+    packages=["fmu_manipulation_toolbox", "fmu_manipulation_toolbox.cli"],
     package_data={"fmu_manipulation_toolbox": [
         "resources/win32/client_sm.dll",
         "resources/win32/server_sm.exe",

fmu_manipulation_toolbox-1.9rc4/fmu_manipulation_toolbox/__version__.py

@@ -1 +0,0 @@
-'V1.9-rc4'