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

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

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

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

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

@@ -1,5 +1,6 @@
 import logging
 import getpass
+import math
 import os
 import shutil
 import uuid
@@ -162,7 +163,8 @@ class EmbeddedFMUPort:
 
 class EmbeddedFMU(OperationAbstract):
     capability_list = ("needsExecutionTool",
-                       "canBeInstantiatedOnlyOncePerProcess")
+                       "canBeInstantiatedOnlyOncePerProcess",
+                       "canHandleVariableCommunicationStepSize")
 
     def __init__(self, filename):
         self.fmu = FMU(filename)
@@ -211,7 +213,7 @@ class EmbeddedFMU(OperationAbstract):
         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 +493,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 +644,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 +661,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 +685,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-1.9rc2 → fmu_manipulation_toolbox-1.9rc4}/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-1.9rc2 → fmu_manipulation_toolbox-1.9rc4}/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")
@@ -279,7 +278,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 +365,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-1.9rc4/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.9rc2 → fmu_manipulation_toolbox-1.9rc4}/fmu_manipulation_toolbox.egg-info/PKG-INFO

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

@@ -12,6 +12,7 @@ fmu_manipulation_toolbox/gui.py
 fmu_manipulation_toolbox/gui_style.py
 fmu_manipulation_toolbox/help.py
 fmu_manipulation_toolbox/operations.py
+fmu_manipulation_toolbox/remoting.py
 fmu_manipulation_toolbox/split.py
 fmu_manipulation_toolbox/version.py
 fmu_manipulation_toolbox.egg-info/PKG-INFO

{fmu_manipulation_toolbox-1.9rc2 → fmu_manipulation_toolbox-1.9rc4}/tests/test_suite.py

@@ -4,6 +4,7 @@ from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 from fmu_manipulation_toolbox.operations import *
+from fmu_manipulation_toolbox.remoting import *
 from fmu_manipulation_toolbox.container import *
 from fmu_manipulation_toolbox.assembly import *
 
@@ -143,6 +144,12 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
         self.assert_identical_files_but_guid("containers/start/REF-modelDescription.xml",
                                              "containers/start/container-slx/modelDescription.xml")
 
+    def test_fmi3_pt2(self):
+        assembly = Assembly("passthrough.json", fmu_directory=Path("fmi3/passthrough"), debug=True)
+        assembly.make_fmu(fmi_version=2)
+        self.assert_identical_files("fmi3/passthrough/REF-container.txt",
+                                    "fmi3/passthrough/container-passthrough/resources/container.txt")
+
     def test_container_move(self):
         #bb = Assembly("bouncing.csv", fmu_directory=Path("containers/bouncing_ball"))
         #links = bb.root.get_fmu_connections("bb_position.fmu")

fmu_manipulation_toolbox-1.9rc2/fmu_manipulation_toolbox/__version__.py

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