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

fmu_manipulation_toolbox/__init__.py

@@ -0,0 +1 @@
+

fmu_manipulation_toolbox/__main__.py

@@ -0,0 +1,25 @@
+import sys
+
+
+def gui():
+    try:
+        from .gui import main
+        main()
+    except ModuleNotFoundError as e:
+        print(f"FATAL ERROR: {e}. No GUI Available.")
+
+
+def cli():
+    from .cli import fmutool
+    fmutool()
+
+
+def main():
+    if len(sys.argv) == 1:
+        gui()
+    else:
+        cli()
+
+
+if __name__ == '__main__':
+    main()

fmu_manipulation_toolbox/__version__.py

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

fmu_manipulation_toolbox/checker.py

@@ -0,0 +1,61 @@
+import importlib.util
+import inspect
+import os
+import xmlschema
+from xmlschema.validators.exceptions import XMLSchemaValidationError
+from .fmu_operations import OperationAbstract
+
+
+class OperationGenericCheck(OperationAbstract):
+    SUPPORTED_FMI_VERSIONS = ('2.0',)
+
+    def __init__(self):
+        self.compliant_with_version = None
+
+    def __repr__(self):
+        return f"FMU Generic Conformity Checks"
+
+    def fmi_attrs(self, attrs):
+        if attrs['fmiVersion'] not in self.SUPPORTED_FMI_VERSIONS:
+            print(f"ERROR: Expected FMI {','.join(self.SUPPORTED_FMI_VERSIONS)} versions.")
+            return
+
+        xsd_filename = os.path.join(os.path.dirname(__file__), "resources", "fmi-" + attrs['fmiVersion'],
+                                    "fmi2ModelDescription.xsd")
+        try:
+            xmlschema.validate(self.fmu.descriptor_filename, schema=xsd_filename)
+        except XMLSchemaValidationError as error:
+            print(error.reason, error.msg)
+        else:
+            self.compliant_with_version = attrs['fmiVersion']
+
+    def closure(self):
+        if self.compliant_with_version:
+            print(f"INFO: This FMU seems to be compliant with FMI-{self.compliant_with_version}.")
+        else:
+            print(f"ERROR: This FMU does not validate with FMI standard.")
+
+
+checker_list = [OperationGenericCheck]
+
+
+def add_from_file(checker_filename: str):
+    spec = importlib.util.spec_from_file_location(checker_filename, checker_filename)
+    if not spec:
+        print(f"ERROR: Cannot load {checker_filename}. Is this a python file?")
+        return
+    try:
+        checker_module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(checker_module)
+        except (ModuleNotFoundError, SyntaxError) as error:
+            print(f"ERROR: Cannot load {checker_filename}: {error})")
+            return
+
+        for checker_name, checker_class in inspect.getmembers(checker_module, inspect.isclass):
+            if OperationAbstract in checker_class.__bases__:
+                checker_list.append(checker_class)
+                print(f"Adding checker: {checker_filename}|{checker_name}")
+
+    except AttributeError:
+        print(f"ERROR: {checker_filename} should implement class 'OperationCheck'")

fmu_manipulation_toolbox/cli.py

@@ -0,0 +1,216 @@
+import argparse
+import logging
+import sys
+from colorama import Fore, Style, init
+
+from .fmu_operations import *
+from .fmu_container import FMUContainerSpecReader, FMUContainerError
+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=True,
+                        help="Directory containing initial FMU’s and used to generate containers.")
+
+    parser.add_argument("-container", action="append", dest="container_descriptions_list", default=[],
+                        metavar="filename.csv:step_size",
+                        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("-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.")
+
+    config = parser.parse_args()
+
+    if config.debug:
+        logger.setLevel(logging.DEBUG)
+
+    for description in config.container_descriptions_list:
+        try:
+            filename_description, step_size = description.split(":")
+            step_size = float(step_size)
+        except ValueError:
+            step_size = None
+            filename_description = description
+
+        container_filename = Path(filename_description).with_suffix(".fmu")
+
+        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}")
+            continue
+
+
+# for debug purpose
+if __name__ == "__main__":
+    fmucontainer()