fmu-manipulation-toolbox 1.9rc3__py3-none-any.whl → 1.9rc5__py3-none-any.whl

fmu_manipulation_toolbox/__version__.py

@@ -1 +1 @@
-'V1.9-rc3'
+'V1.9-rc5'

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/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/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/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/container.py

@@ -1,5 +1,6 @@
 import logging
 import getpass
+import math
 import os
 import shutil
 import uuid
@@ -9,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
 
 
@@ -70,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"]
@@ -87,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
@@ -162,7 +159,8 @@ class EmbeddedFMUPort:
 
 class EmbeddedFMU(OperationAbstract):
     capability_list = ("needsExecutionTool",
-                       "canBeInstantiatedOnlyOncePerProcess")
+                       "canBeInstantiatedOnlyOncePerProcess",
+                       "canHandleVariableCommunicationStepSize")
 
     def __init__(self, filename):
         self.fmu = FMU(filename)
@@ -189,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
 
@@ -206,12 +204,18 @@ 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
 
     def __repr__(self):
-        return f"FMU '{self.name}' ({len(self.ports)} variables)"
+        return f"FMU '{self.name}' ({len(self.ports)} variables, ts={self.step_size}s)"
 
 
 class FMUContainerError(Exception):
@@ -491,8 +495,8 @@ class FMUContainer:
 
         try:
             fmu = EmbeddedFMU(self.fmu_directory / fmu_filename)
-            if fmu.fmi_version > self.fmi_version:
-                logger.warning(f"Try to embed FMU-{fmu.fmi_version} into container FMI-{self.fmi_version}")
+            if not fmu.fmi_version == self.fmi_version:
+                logger.warning(f"Try to embed FMU-{fmu.fmi_version} into container FMI-{self.fmi_version}.")
             self.involved_fmu[fmu.name] = fmu
 
             logger.debug(f"Adding FMU #{len(self.involved_fmu)}: {fmu}")
@@ -642,16 +646,16 @@ class FMUContainer:
 
         return auto_wired
 
-    def minimum_step_size(self) -> float:
-        step_size = None
+    def default_step_size(self) -> float:
+        freq_set = set()
         for fmu in self.involved_fmu.values():
-            if step_size:
-                if fmu.step_size and fmu.step_size < step_size:
-                    step_size = fmu.step_size
-            else:
-                step_size = fmu.step_size
+            if fmu.step_size and fmu.capabilities["canHandleVariableCommunicationStepSize"] == "false":
+                freq_set.add(int(1.0/fmu.step_size))
 
-        if not step_size:
+        common_freq = math.gcd(*freq_set)
+        try:
+            step_size = 1.0 / float(common_freq)
+        except ZeroDivisionError:
             step_size = 0.1
             logger.warning(f"Defaulting to step_size={step_size}")
 
@@ -659,15 +663,15 @@ class FMUContainer:
 
     def sanity_check(self, step_size: Optional[float]):
         for fmu in self.involved_fmu.values():
-            if not fmu.step_size:
-                continue
-            ts_ratio = step_size / fmu.step_size
-            if ts_ratio < 1.0:
-                logger.warning(f"Container step_size={step_size}s is lower than FMU '{fmu.name}' "
-                               f"step_size={fmu.step_size}s.")
-            if ts_ratio != int(ts_ratio):
-                logger.warning(f"Container step_size={step_size}s should divisible by FMU '{fmu.name}' "
-                               f"step_size={fmu.step_size}s.")
+            if fmu.step_size and fmu.capabilities["canHandleVariableCommunicationStepSize"] == "false":
+                ts_ratio = step_size / fmu.step_size
+                logger.debug(f"container step_size: {step_size} = {fmu.step_size} x {ts_ratio} for {fmu.name}")
+                if ts_ratio < 1.0:
+                    logger.warning(f"Container step_size={step_size}s is lower than FMU '{fmu.name}' "
+                                   f"step_size={fmu.step_size}s.")
+                if ts_ratio != int(ts_ratio):
+                    logger.warning(f"Container step_size={step_size}s should divisible by FMU '{fmu.name}' "
+                                   f"step_size={fmu.step_size}s.")
             for port_name in fmu.ports:
                 cport = ContainerPort(fmu, port_name)
                 if cport not in self.rules:
@@ -683,7 +687,7 @@ class FMUContainer:
 
         if step_size is None:
             logger.info(f"step_size  will be deduced from the embedded FMU's")
-            step_size = self.minimum_step_size()
+            step_size = self.default_step_size()
         self.sanity_check(step_size)
 
         logger.info(f"Building FMU '{fmu_filename}', step_size={step_size}")

fmu_manipulation_toolbox/gui.py

@@ -13,6 +13,8 @@ from functools import partial
 
 from .gui_style import gui_style, log_color
 from .operations import *
+from .remoting import (OperationAddRemotingWin32, OperationAddRemotingWin64, OperationAddFrontendWin32,
+                       OperationAddFrontendWin64)
 from .assembly import Assembly, AssemblyNode
 from .checker import checker_list
 from .help import Help

fmu_manipulation_toolbox/operations.py

@@ -8,7 +8,6 @@ import tempfile
 import xml.parsers.expat
 import zipfile
 import hashlib
-from pathlib import Path
 from typing import *
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
@@ -161,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
@@ -279,7 +279,7 @@ class OperationAbstract:
     def experiment_attrs(self, attrs):
         pass
 
-    def port_attrs(self, fmu_port) -> int:
+    def port_attrs(self, fmu_port: FMUPort) -> int:
         """ return 0 to keep port, otherwise remove it"""
         return 0
 
@@ -366,65 +366,6 @@ class OperationRenameFromCSV(OperationAbstract):
             return 1
 
 
-class OperationAddRemotingWinAbstract(OperationAbstract):
-    bitness_from = None
-    bitness_to = None
-
-    def __repr__(self):
-        return f"Add '{self.bitness_to}' remoting on '{self.bitness_from}' FMU"
-
-    def fmi_attrs(self, attrs):
-        if not attrs["fmiVersion"] == "2.0":
-            raise OperationError(f"Adding remoting is only available for FMI-2.0")
-
-    def cosimulation_attrs(self, attrs):
-        fmu_bin = {
-            "win32":  os.path.join(self.fmu.tmp_directory, "binaries", f"win32"),
-            "win64": os.path.join(self.fmu.tmp_directory, "binaries", f"win64"),
-        }
-
-        if not os.path.isdir(fmu_bin[self.bitness_from]):
-            raise OperationError(f"{self.bitness_from} interface does not exist")
-
-        if os.path.isdir(fmu_bin[self.bitness_to]):
-            logger.info(f"{self.bitness_to} already exists. Add front-end.")
-            shutil.move(os.path.join(fmu_bin[self.bitness_to], attrs['modelIdentifier'] + ".dll"),
-                        os.path.join(fmu_bin[self.bitness_to], attrs['modelIdentifier'] + "-remoted.dll"))
-        else:
-            os.mkdir(fmu_bin[self.bitness_to])
-
-        to_path = Path(__file__).parent / "resources" / self.bitness_to
-        shutil.copyfile(to_path / "client_sm.dll",
-                        Path(fmu_bin[self.bitness_to]) / Path(attrs['modelIdentifier']).with_suffix(".dll"))
-
-        from_path = Path(__file__).parent / "resources" / self.bitness_from
-        shutil.copyfile(from_path / "server_sm.exe",
-                        Path(fmu_bin[self.bitness_from]) / "server_sm.exe")
-
-        shutil.copyfile(Path(__file__).parent / "resources" / "license.txt",
-                        Path(fmu_bin[self.bitness_to]) / "license.txt")
-
-
-class OperationAddRemotingWin64(OperationAddRemotingWinAbstract):
-    bitness_from = "win32"
-    bitness_to = "win64"
-
-
-class OperationAddFrontendWin32(OperationAddRemotingWinAbstract):
-    bitness_from = "win32"
-    bitness_to = "win32"
-
-
-class OperationAddFrontendWin64(OperationAddRemotingWinAbstract):
-    bitness_from = "win64"
-    bitness_to = "win64"
-
-
-class OperationAddRemotingWin32(OperationAddRemotingWinAbstract):
-    bitness_from = "win64"
-    bitness_to = "win32"
-
-
 class OperationRemoveRegexp(OperationAbstract):
     def __repr__(self):
         return f"Remove ports matching '{self.regex_string}'"

fmu_manipulation_toolbox/remoting.py

@@ -0,0 +1,105 @@
+import logging
+import shutil
+
+from pathlib import Path
+from .operations import OperationAbstract, OperationError
+
+logger = logging.getLogger("fmu_manipulation_toolbox")
+
+class OperationAddRemotingWinAbstract(OperationAbstract):
+    bitness_from = None
+    bitness_to = None
+
+    def __repr__(self):
+        return f"Add '{self.bitness_to}' remoting on '{self.bitness_from}' FMU"
+
+    def __init__(self):
+        self.vr = {
+            "Real": [],
+            "Integer": [],
+            "Boolean": []
+        }
+        self.nb_input = 0;
+        self.nb_output = 0;
+
+    def fmi_attrs(self, attrs):
+        if not attrs["fmiVersion"] == "2.0":
+            raise OperationError(f"Adding remoting is only available for FMI-2.0")
+
+    def cosimulation_attrs(self, attrs):
+        fmu_bin = {
+            "win32": Path(self.fmu.tmp_directory) / "binaries" / "win32",
+            "win64": Path(self.fmu.tmp_directory) / "binaries" / "win64",
+        }
+
+        if not fmu_bin[self.bitness_from].is_dir():
+            raise OperationError(f"{self.bitness_from} interface does not exist")
+
+        if fmu_bin[self.bitness_to].is_dir():
+            logger.info(f"{self.bitness_to} already exists. Add front-end.")
+            shutil.move(fmu_bin[self.bitness_to] / Path(attrs['modelIdentifier']).with_suffix(".dll"),
+                        fmu_bin[self.bitness_to] / Path(attrs['modelIdentifier']).with_suffix("-remoted.dll"))
+        else:
+            fmu_bin[self.bitness_to].mkdir()
+
+        to_path = Path(__file__).parent / "resources" / self.bitness_to
+        try:
+            shutil.copyfile(to_path / "client_sm.dll",
+                            fmu_bin[self.bitness_to] / Path(attrs['modelIdentifier']).with_suffix(".dll"))
+        except FileNotFoundError as e:
+            logger.critical(f"Cannot add remoting client: {e}")
+
+        from_path = Path(__file__).parent / "resources" / self.bitness_from
+        try:
+            shutil.copyfile(from_path / "server_sm.exe",
+                            fmu_bin[self.bitness_from] / "server_sm.exe")
+        except FileNotFoundError as e:
+            logger.critical(f"Cannot add remoting server: {e}")
+
+        shutil.copyfile(Path(__file__).parent / "resources" / "license.txt",
+                        fmu_bin[self.bitness_to] / "license.txt")
+
+    def port_attrs(self, fmu_port) -> int:
+        try:
+            self.vr[fmu_port.fmi_type].append(fmu_port["valueReference"])
+            if fmu_port["causality"] in ("input", "parameter"):
+                self.nb_input += 1
+            else:
+                self.nb_output += 1
+        except KeyError:
+            logger.error(f"Type '{fmu_port.fmi_type}' is not supported by remoting.")
+
+        return 0
+
+    def closure(self):
+        target_dir = Path(self.fmu.tmp_directory) / "resources"
+        if not target_dir.is_dir():
+            target_dir.mkdir()
+
+        logger.info(f"Remoting nb input port: {self.nb_input}")
+        logger.info(f"Remoting nb output port: {self.nb_output}")
+        with open(target_dir/ "remoting_table.txt", "wt") as file:
+            for fmi_type in ('Real', 'Integer', 'Boolean'):
+                print(len(self.vr[fmi_type]), file=file)
+            for fmi_type in ('Real', 'Integer', 'Boolean'):
+                for vr in sorted(self.vr[fmi_type]):
+                    print(vr, file=file)
+
+class OperationAddRemotingWin64(OperationAddRemotingWinAbstract):
+    bitness_from = "win32"
+    bitness_to = "win64"
+
+
+class OperationAddFrontendWin32(OperationAddRemotingWinAbstract):
+    bitness_from = "win32"
+    bitness_to = "win32"
+
+
+class OperationAddFrontendWin64(OperationAddRemotingWinAbstract):
+    bitness_from = "win64"
+    bitness_to = "win64"
+
+
+class OperationAddRemotingWin32(OperationAddRemotingWinAbstract):
+    bitness_from = "win64"
+    bitness_to = "win32"

{fmu_manipulation_toolbox-1.9rc3.dist-info → fmu_manipulation_toolbox-1.9rc5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9rc3
+Version: 1.9rc5
 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.9rc3.dist-info → fmu_manipulation_toolbox-1.9rc5.dist-info}/RECORD

@@ -1,15 +1,21 @@
 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=CGyZIselV5kCL6An0m7aR4m-Y2X2IRQadcj88KEF3Ps,11
+fmu_manipulation_toolbox/__version__.py,sha256=niVpMeIUg7iKHRlsUPuXHpvJ5XeFDKAdI2L5ilFhMbg,11
 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=8Wf16sgUPkY-ByWeKt-3TD_4vNRQuLwH9Gs7D2Q6tAk,44959
-fmu_manipulation_toolbox/gui.py,sha256=iOJ3F_zfw3mU34VofZrYdaffljTmYfuy33fJXlLaOwg,29045
+fmu_manipulation_toolbox/container.py,sha256=Anubg08tr0HRb1_6rUqIRoE3E6emv6pKqDbs2aezv38,45625
+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=aklKiLrsE0adSzQ5uoEB1sBDmI6s4l231gavu4XxxzA,5856
-fmu_manipulation_toolbox/operations.py,sha256=b7N5AVHLIpQO8od4BYasb9CppHJ-ZmW8mu0ZdhndoHI,19472
+fmu_manipulation_toolbox/operations.py,sha256=WayxcpnVRpvxGOXx2I5Vh9ThVbj6IRW6Vr8qKfqck8Y,17348
+fmu_manipulation_toolbox/remoting.py,sha256=vsvGRIUr-VxUkpBMCfE_G0kYVnB2CN03ts_Imi2uLk8,3814
 fmu_manipulation_toolbox/split.py,sha256=NVkfdTRR0jj_VOdgtxHQoKptkAg5TFVUA7nUx3_o9Pg,13336
 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=bxiOcVwHHLQaVtTga77t_UdE6duPX1kTXef53LyPqbA,4738
+fmu_manipulation_toolbox/cli/fmusplit.py,sha256=QSMHZJlNOYbaPgI6Z9QHr95mrC3PuXDeUXR2sHm73HU,1636
+fmu_manipulation_toolbox/cli/fmutool.py,sha256=OuPrDeqnbsMGV50Jq7ugX7q19gt9WI2v1HMXvOvzozM,5637
+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
@@ -27,7 +33,7 @@ fmu_manipulation_toolbox/resources/icon_fmu.png,sha256=EuygB2xcoM2WAfKKdyKG_UvTL
 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=qYV-5d35a7OmSHjYejuTRG8TurfctN5rkF-YjQua-Zo,161560
+fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=hc8FpHbqZDkpnLRy8oKfhk7iSTW7G89B4sACASW4Ta8,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
@@ -47,19 +53,19 @@ fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Type.xsd,sha256=TaHRoUBIFtmdEwBKB
 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=KT6_GdTc0saR-H6l2-0udaJtEDiHnzlFBIp0FtlOtrw,135520
-fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=ulfoPvmaYe9nInYcVEyj7mD9zDzGk56OUoWx1mPKLiE,22768
-fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=q91IE2IFDzchUukNc93c7MkRHgKYA3ll3CnKthPfKB0,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=cTmbVSx_wyD-VcJMXgQWvfmByzrb9lJnTlp9Dzdu9sA,15872
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=RYaQA4l0iOis-QbnCz_T1zRnuDTlWFtt-FzWnEnenag,22016
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=vBslbM-PWm9Dj4zTwhElqm9EPHFwv4BV9obBEb0sx9I,98816
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=oKiRKA1irVkkL-P84bOU1TC7K9h_xrnr_4EGJqoYIfU,19968
-fmu_manipulation_toolbox-1.9rc3.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
-fmu_manipulation_toolbox-1.9rc3.dist-info/METADATA,sha256=4E3iWPeD60EJzvvBjPFnWqMI6cIEMn3wxsaLjmZwkNw,1156
-fmu_manipulation_toolbox-1.9rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_manipulation_toolbox-1.9rc3.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
-fmu_manipulation_toolbox-1.9rc3.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.9rc3.dist-info/RECORD,,
+fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=ytv2fMHRYkQS4v_ODKVCt3Z_19k7tCYTKT8kKOK0Pu0,34756
+fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=pHXd5rRyJrCEUPGxVcK3irE86ThxVUTBRn_rgOZdSYg,21224
+fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=xBgQTTiww_SON8bHP4UP6UT8PqzzHiBgJHTiiG3Asi8,32592
+fmu_manipulation_toolbox/resources/linux64/container.so,sha256=cCue2KyQjBi75dJnlySPVmAGb8H0WzpHqhxYkB7Aay4,135520
+fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=A6-IQUCN51r5rQkEW9lJJuZKqRPgeoxyMwjc5NNMq-A,22552
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=1HXgBXj0FwLmT7xPdlWCYsTRu-TnggJTTNtkrDS7v0o,17408
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=h4CkEB4a47vF_Dsnwbvy9YwIra8mn_taWYTkBdlDrNc,15360
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=diUwWUB_pKjbU2NT8q4JUaby6ppAQnxbTj6ZCAxjTK8,20992
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=-EnDn6FIpLxX3L0vp1tGAOp78fQAQfaIWl4tC0P1rj8,98816
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=5woZaxLhHP5xr7tOSCz6JmaHK9Wb0xuB0pzdROUDDpU,18432
+fmu_manipulation_toolbox-1.9rc5.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
+fmu_manipulation_toolbox-1.9rc5.dist-info/METADATA,sha256=8O6lxLDyaW5Fu3qxa4PNsyawnvBtEtDuozgyHxvJ-4w,1156
+fmu_manipulation_toolbox-1.9rc5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_manipulation_toolbox-1.9rc5.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
+fmu_manipulation_toolbox-1.9rc5.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.9rc5.dist-info/RECORD,,