fmu-manipulation-toolbox 1.9rc9__py3-none-any.whl → 1.9.1__py3-none-any.whl

fmu_manipulation_toolbox/__main__.py

@@ -11,7 +11,7 @@ def gui():
 
 def cli():
     from .cli.fmutool import fmutool
-    fmutool()
+    fmutool(sys.argv[1:])
 
 
 def main():

fmu_manipulation_toolbox/__version__.py

@@ -1 +1 @@
-'V1.9-rc9'
+'V1.9.1'

fmu_manipulation_toolbox/assembly.py

@@ -38,7 +38,8 @@ class Connection:
 
 class AssemblyNode:
     def __init__(self, name: Optional[str], step_size: float = None, mt=False, profiling=False, sequential=False,
-                 auto_link=True, auto_input=True, auto_output=True, auto_parameter=False, auto_local=False):
+                 auto_link=True, auto_input=True, auto_output=True, auto_parameter=False, auto_local=False,
+                 ts_multiplier=False):
         self.name = name
         if step_size:
             try:
@@ -56,6 +57,7 @@ class AssemblyNode:
         self.auto_output = auto_output
         self.auto_parameter = auto_parameter
         self.auto_local = auto_local
+        self.ts_multiplier = ts_multiplier
 
         self.parent: Optional[AssemblyNode] = None
         self.children: Dict[str, AssemblyNode] = {}     # sub-containers
@@ -141,7 +143,7 @@ class AssemblyNode:
             self.add_link(link_rule[0], link_rule[1], link_rule[2], link_rule[3])
 
         container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, sequential=self.sequential,
-                           debug=debug)
+                           debug=debug, ts_multiplier=self.ts_multiplier)
 
         for node in self.children.values():
             logger.info(f"Deleting transient FMU Container '{node.name}'")
@@ -221,7 +223,7 @@ class AssemblyError(Exception):
 class Assembly:
     def __init__(self, filename: str, step_size=None, auto_link=True,  auto_input=True, debug=False, sequential=False,
                  auto_output=True, mt=False, profiling=False, fmu_directory: Path = Path("."), auto_parameter=False,
-                 auto_local=False):
+                 auto_local=False, ts_multiplier=False):
         self.filename = Path(filename)
         self.default_auto_input = auto_input
         self.debug = debug
@@ -233,6 +235,7 @@ class Assembly:
         self.default_mt = mt
         self.default_sequential = sequential
         self.default_profiling = profiling
+        self.default_ts_multiplier = ts_multiplier
         self.fmu_directory = fmu_directory
         self.transient_filenames: List[Path] = []
         self.transient_dirnames: Set[Path] = set()
@@ -289,7 +292,7 @@ class Assembly:
                                  mt=self.default_mt, profiling=self.default_profiling,
                                  sequential=self.default_sequential, auto_input=self.default_auto_input,
                                  auto_output=self.default_auto_output, auto_parameter=self.default_auto_parameter,
-                                 auto_local=self.default_auto_local)
+                                 auto_local=self.default_auto_local, ts_multiplier=self.default_ts_multiplier)
 
         with open(self.input_pathname) as file:
             reader = csv.reader(file, delimiter=';')
@@ -397,15 +400,16 @@ class Assembly:
         auto_parameter = data.get("auto_parameter", self.default_auto_parameter)            # 6b
         auto_local = data.get("auto_local", self.default_auto_local)                        # 6c
         step_size = data.get("step_size", self.default_step_size)                           # 7
+        ts_multiplier = data.get("ts_multiplier", self.default_ts_multiplier)               # 7b
 
         node = AssemblyNode(name, step_size=step_size, auto_link=auto_link, mt=mt, profiling=profiling,
                             sequential=sequential,
                             auto_input=auto_input, auto_output=auto_output, auto_parameter=auto_parameter,
-                            auto_local=auto_local)
+                            auto_local=auto_local, ts_multiplier=ts_multiplier)
 
         for key, value in data.items():
             if key in ('name', 'step_size', 'auto_link', 'auto_input', 'auto_output', 'mt', 'profiling', 'sequential',
-                       'auto_parameter', 'auto_local'):
+                       'auto_parameter', 'auto_local', 'ts_multiplier'):
                 continue  # Already read
 
             elif key == "container":  # 8
@@ -472,6 +476,9 @@ class Assembly:
         if node.step_size:
             json_node["step_size"] = node.step_size        # 7
 
+        if node.ts_multiplier:
+            json_node["ts_multiplier"] = node.ts_multiplier # 7b
+
         if node.children:
             json_node["container"] = [self._json_encode_node(child) for child in node.children.values()]  # 8
 

fmu_manipulation_toolbox/checker.py

@@ -2,8 +2,11 @@ import importlib.util
 import inspect
 import logging
 import os
+import sys
 import xmlschema
+from typing import *
 from xmlschema.validators.exceptions import XMLSchemaValidationError
+
 from .operations import OperationAbstract
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
@@ -40,8 +43,24 @@ class OperationGenericCheck(OperationAbstract):
         else:
             logger.error(f"This FMU does not validate with FMI standard.")
 
+_checkers_list: List[type[OperationAbstract]] = [OperationGenericCheck]
+
+def get_checkers() -> List[type[OperationAbstract]]:
+    if sys.version_info < (3, 10):
+        from importlib_metadata import entry_points
+    else:
+        from importlib.metadata import entry_points
+    checkers: List[type[OperationAbstract]] = _checkers_list
+    discovered_checkers = entry_points(group='fmu_manipulation_toolbox.checkers')
+
+    for checker in discovered_checkers:
+        entry = checker.load()
+        checker_class = entry()
+        if issubclass(checker_class, OperationAbstract):
+            logger.debug(f"Addon checker: {checker.name}")
+            checkers.append(checker_class)
 
-checker_list = [OperationGenericCheck]
+    return checkers
 
 
 def add_from_file(checker_filename: str):
@@ -59,7 +78,7 @@ def add_from_file(checker_filename: str):
 
         for checker_name, checker_class in inspect.getmembers(checker_module, inspect.isclass):
             if OperationAbstract in checker_class.__bases__:
-                checker_list.append(checker_class)
+                _checkers_list.append(checker_class)
                 logger.info(f"Adding checker: {checker_filename}|{checker_name}")
 
     except AttributeError:

fmu_manipulation_toolbox/cli/fmucontainer.py

@@ -65,6 +65,9 @@ def fmucontainer(command_options: Sequence[str]):
     parser.add_argument("-dump-json",  action="store_true", dest="dump", default=False,
                         help="Dump a JSON file for each container.")
 
+    parser.add_argument("-vr", action="store_true", dest="ts_multiplier", default=False,
+                        help="Add TS_MULTIPLIER input port to control step_size")
+
     config = parser.parse_args(command_options)
 
     if config.debug:
@@ -87,7 +90,7 @@ def fmucontainer(command_options: Sequence[str]):
                                 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)
+                                auto_parameter=config.auto_parameter, ts_multiplier=config.ts_multiplier)
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
             sys.exit(-1)

fmu_manipulation_toolbox/cli/fmutool.py

@@ -9,7 +9,7 @@ from ..operations import (OperationSummary, OperationError, OperationRemoveRegex
                           OperationStripTopLevel, OperationRenameFromCSV, OperationSaveNamesToCSV, FMU, FMUError)
 from ..remoting import  (OperationAddFrontendWin32, OperationAddFrontendWin64, OperationAddRemotingWin32,
                          OperationAddRemotingWin64)
-from ..checker import checker_list
+from ..checker import get_checkers
 from ..version import __version__ as version
 from ..help import Help
 
@@ -69,7 +69,7 @@ def fmutool(command_options: Sequence[str]):
     add_option('-only-locals', action='append_const', dest='apply_on', const='local')
     # 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])
+    add_option('-check', action='append_const', dest='operations_list', const=[checker() for checker in get_checkers()])
 
     cli_options = parser.parse_args(command_options)
     # handle the "no operation" use case

fmu_manipulation_toolbox/container.py

@@ -426,7 +426,7 @@ class FMUContainer:
     <Category name="fmucontainer"/>
   </LogCategories>
 
-  <DefaultExperiment stepSize="{step_size}" startTime="{start_time}" stopTime="{stop_time}"/>
+  <DefaultExperiment stepSize="{step_size}"{default_experiment_times}/>
 
   <ModelVariables>
     <ScalarVariable valueReference="0" name="time" causality="independent"><Real /></ScalarVariable>
@@ -460,7 +460,7 @@ class FMUContainer:
     <Category name="fmucontainer"/>
   </LogCategories>
 
-  <DefaultExperiment stepSize="{step_size}" startTime="{start_time}" stopTime="{stop_time}"/>
+  <DefaultExperiment stepSize="{step_size}"{default_experiment_times}/>
 
   <ModelVariables>
     <Float64 valueReference="0" name="time" causality="independent"/>
@@ -681,7 +681,7 @@ class FMUContainer:
                         logger.warning(f"{cport} is not connected")
 
     def make_fmu(self, fmu_filename: Union[str, Path], step_size: Optional[float] = None, debug=False, mt=False,
-                 profiling=False, sequential=False):
+                 profiling=False, sequential=False, ts_multiplier=False):
         if isinstance(fmu_filename, str):
             fmu_filename = Path(fmu_filename)
 
@@ -695,7 +695,7 @@ class FMUContainer:
         base_directory = self.fmu_directory / fmu_filename.with_suffix('')
         resources_directory = self.make_fmu_skeleton(base_directory)
         with open(base_directory / "modelDescription.xml", "wt") as xml_file:
-            self.make_fmu_xml(xml_file, step_size, profiling)
+            self.make_fmu_xml(xml_file, step_size, profiling, ts_multiplier)
         with open(resources_directory / "container.txt", "wt") as txt_file:
             self.make_fmu_txt(txt_file, step_size, mt, profiling, sequential)
 
@@ -703,7 +703,7 @@ class FMUContainer:
         if not debug:
             self.make_fmu_cleanup(base_directory)
 
-    def make_fmu_xml(self, xml_file, step_size: float, profiling: bool):
+    def make_fmu_xml(self, xml_file, step_size: float, profiling: bool, ts_multiplier: bool):
         timestamp = datetime.now().strftime('%Y-%m-%dT%H:%M:%SZ')
         guid = str(uuid.uuid4())
         embedded_fmu = ", ".join([fmu_name for fmu_name in self.involved_fmu])
@@ -732,13 +732,19 @@ class FMUContainer:
         else:
             logger.info(f"stop_time={self.stop_time}")
 
+        default_experiment_times = ""
+        if self.start_time is not None:
+            default_experiment_times += f' startTime="{self.start_time}"'
+        if self.stop_time is not None:
+            default_experiment_times += f' stopTime="{self.stop_time}"'
+
         if self.fmi_version == 2:
             xml_file.write(self.HEADER_XML_2.format(identifier=self.identifier, tool_version=tool_version,
                                                     timestamp=timestamp, guid=guid, embedded_fmu=embedded_fmu,
                                                     author=author,
                                                     only_once=capabilities['canBeInstantiatedOnlyOncePerProcess'],
                                                     execution_tool=capabilities['needsExecutionTool'],
-                                                    start_time=self.start_time, stop_time=self.stop_time,
+                                                    default_experiment_times=default_experiment_times,
                                                     step_size=step_size))
         elif self.fmi_version == 3:
             xml_file.write(self.HEADER_XML_3.format(identifier=self.identifier, tool_version=tool_version,
@@ -746,12 +752,24 @@ class FMUContainer:
                                                     author=author,
                                                     only_once=capabilities['canBeInstantiatedOnlyOncePerProcess'],
                                                     execution_tool=capabilities['needsExecutionTool'],
-                                                    start_time=self.start_time, stop_time=self.stop_time,
+                                                    default_experiment_times=default_experiment_times,
                                                     step_size=step_size))
 
         vr_time = self.vr_table.add_vr("real64", local=True)
         logger.debug(f"Time vr = {vr_time}")
 
+        vr_ts_multiplier = self.vr_table.add_vr("integer32", local=True)
+        if ts_multiplier:
+            logger.debug(f"TS Multiplier vr = {vr_ts_multiplier}")
+            port = EmbeddedFMUPort("integer32", {"valueReference": vr_ts_multiplier,
+                                                 "name": f"container.ts_multiplier",
+                                                 "causality": "input",
+                                                 "description": f"Timestep multiplier",
+                                                 "variability": "discrete",
+                                                 "start": 1,
+                                                 "initial": "exact"})
+            print(f"    {port.xml(vr_ts_multiplier, fmi_version=self.fmi_version)}", file=xml_file)
+
         if profiling:
             for fmu in self.involved_fmu.values():
                 vr = self.vr_table.add_vr("real64", local=True)
@@ -915,6 +933,8 @@ class FMUContainer:
                 if profiling:
                     for profiling_port, _ in enumerate(self.involved_fmu.values()):
                         print(f"{profiling_port + 1} 1 -2 {profiling_port + 1}", file=txt_file)
+            elif type_name == "integer32":
+                print(f"0 1 -1 0", file=txt_file)  # TS Multiplier
 
             for input_port in inputs_per_type[type_name]:
                 cport_string = [f"{fmu_rank[cport.fmu.name]} {cport.port.vr}" for cport in input_port.cport_list]

fmu_manipulation_toolbox/gui.py

@@ -16,7 +16,7 @@ from .operations import *
 from .remoting import (OperationAddRemotingWin32, OperationAddRemotingWin64, OperationAddFrontendWin32,
                        OperationAddFrontendWin64)
 from .assembly import Assembly, AssemblyNode
-from .checker import checker_list
+from .checker import get_checkers
 from .help import Help
 from .version import __version__ as version
 
@@ -414,7 +414,7 @@ class MainWindow(WindowWithLayout):
             ("Add Win64 remoting",    '-add-remoting-win64', 'info',    OperationAddRemotingWin64),
             ("Add Win32 frontend",    '-add-frontend-win32', 'info',    OperationAddFrontendWin32),
             ("Add Win64 frontend",    '-add-frontend-win64', 'info',    OperationAddFrontendWin64),
-            ("Check",                 '-check',              'info',    checker_list),
+            ("Check",                 '-check',              'info',    get_checkers()),
         ]
 
         width = 5

fmu_manipulation_toolbox/operations.py

@@ -69,7 +69,13 @@ class FMUPort:
             print(f"      <{self.fmi_type} {self.dict_level(1)}/>", file=file)
             print(f"    </ScalarVariable>", file=file)
         elif fmi_version == 3:
-            print(f"    <{self.fmi_type} {self.dict_level(0)}/>", file=file)
+            start_value = self.get("start", "")
+            if self.fmi_type in ("String", "Binary") and start_value:
+                print(f"    <{self.fmi_type} {self.dict_level(0)}>", file=file)
+                print(f'      <Start value="{start_value}"/>', file=file)
+                print(f"    </{self.fmi_type}>", file=file)
+            else:
+                print(f"    <{self.fmi_type} {self.dict_level(0)}/>", file=file)
         else:
             raise FMUError(f"FMUPort writing: unsupported FMI version {fmi_version}")
 
@@ -177,6 +183,8 @@ class Manipulation:
                 self.current_port = FMUPort()
                 self.current_port.fmi_type = name
                 self.current_port.push_attrs(attrs)
+            elif self.fmu.fmi_version == 3 and name == "Start":
+                self.current_port.push_attrs({"start": attrs.get("value", "")})
             elif name == 'CoSimulation':
                 self.operation.cosimulation_attrs(attrs)
             elif name == 'DefaultExperiment':

fmu_manipulation_toolbox/split.py

@@ -111,16 +111,10 @@ class FMUSplitter:
                     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.links: Dict[str, Dict[int, FMUSplitterLink]] = dict((el, {}) for el in EmbeddedFMUPort.ALL_TYPES)
         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,
@@ -133,10 +127,11 @@ class FMUSplitterDescription:
 
         # used for modelDescription.xml parsing
         self.current_fmu_filename = None
+        self.current_fmi_version = None
         self.current_vr = None
         self.current_name = None
         self.current_causality = None
-        self.supported_fmi_types: Tuple[str] = ()
+        self.supported_fmi_types: Tuple[str] = tuple()
 
     @staticmethod
     def get_line(file):
@@ -146,14 +141,23 @@ class FMUSplitterDescription:
                 return line
         raise StopIteration
 
-    def start_element(self, name, attrs):
-        if name == "ScalarVariable":
+    def start_element(self, tag, attrs):
+        if tag == "fmiModelDescription":
+            self.current_fmi_version = attrs["fmiVersion"]
+        elif tag == "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}
+        elif self.current_fmi_version == "2.0" and tag in EmbeddedFMUPort.FMI_TO_CONTAINER[2]:
+            fmi_type = EmbeddedFMUPort.FMI_TO_CONTAINER[2][tag]
+            self.vr_to_name[self.current_fmu_filename][fmi_type][self.current_vr] = {
+                "name": self.current_name,
+                "causality": self.current_causality}
+        elif self.current_fmi_version == "3.0" and tag in EmbeddedFMUPort.FMI_TO_CONTAINER[3]:
+            fmi_type = EmbeddedFMUPort.FMI_TO_CONTAINER[3][tag]
+            self.vr_to_name[self.current_fmu_filename][fmi_type][int(attrs["valueReference"])] = {
+                "name": attrs["name"],
+                "causality": attrs["causality"]}
         else:
             self.current_vr = None
             self.current_name = None
@@ -166,14 +170,10 @@ class FMUSplitterDescription:
         else:
             filename = f"{directory}/modelDescription.xml"
 
-        self.vr_to_name[fmu_filename] = {
-            "Real": {},
-            "Integer": {},
-            "Boolean": {},
-            "String": {}
-        }
+        self.vr_to_name[fmu_filename] = dict((el, {}) for el in EmbeddedFMUPort.ALL_TYPES)
         parser = xml.parsers.expat.ParserCreate()
         self.current_fmu_filename = fmu_filename
+        self.current_fmi_version = None
         self.current_vr = None
         self.current_name = None
         self.current_causality = None
@@ -266,14 +266,14 @@ class FMUSplitterDescription:
     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"):
+
+                for fmi_type in self.supported_fmi_types:
                     nb_input = int(self.get_line(file))
                     for i in range(nb_input):
                         local, vr = self.get_line(file).split(" ")
@@ -285,7 +285,7 @@ class FMUSplitterDescription:
                         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"):
+                for fmi_type in self.supported_fmi_types:
                     nb_start = int(self.get_line(file))
                     for i in range(nb_start):
                         tokens = self.get_line(file).split(" ")
@@ -299,7 +299,7 @@ class FMUSplitterDescription:
                             self.config["start"] = [start_definition]
 
                 # Output per FMUs
-                for fmi_type in ("Real", "Integer", "Boolean", "String"):
+                for fmi_type in self.supported_fmi_types:
                     nb_output = int(self.get_line(file))
 
                     for i in range(nb_output):
@@ -311,6 +311,10 @@ class FMUSplitterDescription:
                             self.links[fmi_type][local] = link
                         link.from_port = FMUSplitterPort(fmu_filename,
                                                          self.vr_to_name[fmu_filename][fmi_type][int(vr)]["name"])
+                #conversion
+                nb_conversion = int(self.get_line(file))
+                for i in range(nb_conversion):
+                    self.get_line(file)
 
             logger.debug("End of parsing.")
 

{fmu_manipulation_toolbox-1.9rc9.dist-info → fmu_manipulation_toolbox-1.9.1.dist-info}/METADATA

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

@@ -1,20 +1,20 @@
 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=a17zC1vWGKiyRqtqXxKoo5DItHBYHj480oIEWpgEdNw,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=Ed6JsWM2oMs-jyGyKmrHHebNuG4qwiGLYtx0BREIiBE,45710
-fmu_manipulation_toolbox/gui.py,sha256=ax-IbGO7GyBG0Mb5okN588CKQDfMxoF1uZtD1_CYnjc,29199
+fmu_manipulation_toolbox/__main__.py,sha256=Ixgo_5YS_khXseMujNPsVzaerkHPugLPYPV7FIi5umo,364
+fmu_manipulation_toolbox/__version__.py,sha256=F1YnOtakt3tZZDQQNxPG2WjLDNM0C_-tnWfumOBOxOI,9
+fmu_manipulation_toolbox/assembly.py,sha256=-i9iQLKiPyjdFZyxHmB1FgL3NYmRPfTWVs9lf3fC5sE,27022
+fmu_manipulation_toolbox/checker.py,sha256=RmIYd6s4p2S9wdv-uSILfVm__QTZSUJCiq6hr_G5rxA,3119
+fmu_manipulation_toolbox/container.py,sha256=dUjgOlTjzIOYDrc9vuxdL5g8WYxmDzhIzP0W8X_QcIE,46894
+fmu_manipulation_toolbox/gui.py,sha256=-DyWY2MoECr3FGRYdS60Ltoayhd3O0uOCtkQ4YXE8xc,29201
 fmu_manipulation_toolbox/gui_style.py,sha256=s6WdrnNd_lCMWhuBf5LKK8wrfLXCU7pFTLUfvqkJVno,6633
 fmu_manipulation_toolbox/help.py,sha256=j8xmnCrwQpaW-SZ8hSqA1dlTXgaqzQWc4Yr3RH_oqck,6012
-fmu_manipulation_toolbox/operations.py,sha256=VQvFXRHF48e-ZLqoG8nbz61iB5lX6qAkqZHQ0m0lUPw,20577
+fmu_manipulation_toolbox/operations.py,sha256=ZV6BRXszwvmqJwUCnTFkWfIYvfK4i-OHN69kffkmGbI,21075
 fmu_manipulation_toolbox/remoting.py,sha256=N25MDFkIcEWe9CIT1M4L9kea3j-8E7i2I1VOI6zIAdw,3876
-fmu_manipulation_toolbox/split.py,sha256=ONl1T37xJypF45GH3sZC6gKMSQ83xEl4xAWDSEOJsao,13571
+fmu_manipulation_toolbox/split.py,sha256=yFaW6yhvFjOXpRynWzitR7o7uSrxb-RxeFzmQNxUFHI,14147
 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=6UaSSY6UGGlOfIh_CTG-Gk3ZPSd88Pi2cFCuzb87eks,4839
+fmu_manipulation_toolbox/cli/fmucontainer.py,sha256=C-gJvPcz_0YNqbLatgDHC1PC5WjcW8SslfpZCS5k9qs,5047
 fmu_manipulation_toolbox/cli/fmusplit.py,sha256=VMDYjmvIsjPHJINZaOt1Zy8D0so6d99285LbS8v-Tro,1734
-fmu_manipulation_toolbox/cli/fmutool.py,sha256=QRe6xQxQMD8FtEzoT5421Bq0YasgdIwOd9Too5TX5zg,6086
+fmu_manipulation_toolbox/cli/fmutool.py,sha256=TEDZxRVfFT_HHfXsslE6U4E5mhEMmxvbHJjCQX4WI2c,6088
 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
@@ -33,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=5LphcmCaBa76MIq8WoA5FwhLNgu3LxmcaWa49dGQ11I,161560
+fmu_manipulation_toolbox/resources/darwin64/container.dylib,sha256=zpruIma2DMFAwn14kIbG3IxiLkfC8PDG89OjFaXMY_Y,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
@@ -53,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=9-lH-dE6QqWg_FNxsFcF9zismk2Qq3PXNWSOqE2pBMk,34756
+fmu_manipulation_toolbox/resources/linux32/client_sm.so,sha256=TQa6UMAVKfdVLO6adH17cw_PeYX68AjWhREMygvsrMY,34756
 fmu_manipulation_toolbox/resources/linux32/server_sm,sha256=gzKU0BTeaRkvhTMQtHHj3K8uYFyEdyGGn_mZy_jG9xo,21304
-fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=p4zIi1YKQ_81oA6IaMOkKZGwkG-POi4vGj4TKemoHuY,32592
-fmu_manipulation_toolbox/resources/linux64/container.so,sha256=nqZspiOIdn1DwHdCEPJiEybE1JyeO2wTGGQacMYUXqM,135520
+fmu_manipulation_toolbox/resources/linux64/client_sm.so,sha256=zKqTUEgbroHc-NQj5WmS8-B1sZEBu3jJPvZRQJ9S9iA,32592
+fmu_manipulation_toolbox/resources/linux64/container.so,sha256=EeJdbmr-oQVTUPNtUQfnYtfracVtdoRueOuIII5WcBI,135520
 fmu_manipulation_toolbox/resources/linux64/server_sm,sha256=MZn6vITN2qpBHYt_RaK2VnFFp00hk8fTALBHmXPtLwc,22608
-fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=E0TqeuNbYeV3tp0S5PFMIK6ipTN4TCWeaUKAbTcHbnE,17920
-fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=otceaiC_nRbGCtlExCBl8IlqHd4KMsRTPdVhHMx-jic,15360
-fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=3DfTRKHVfwNvcOFjJbpe7T4Jm_wcenQ9x81hJQw2xwk,21504
-fmu_manipulation_toolbox/resources/win64/container.dll,sha256=iy0XO-TUcD27VLiKejB9kJTdBUUt0oh9J-kt1A_u_FI,98816
-fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=_61NOrYKKUa0B_wZhogr47x8-1ppUCcaOsYRkrZ31Hc,18432
-fmu_manipulation_toolbox-1.9rc9.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
-fmu_manipulation_toolbox-1.9rc9.dist-info/METADATA,sha256=m0zac5QSzdnCaQKDSXMt8bPm--ReqaBXPxNVkhOOQ3U,1156
-fmu_manipulation_toolbox-1.9rc9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-fmu_manipulation_toolbox-1.9rc9.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
-fmu_manipulation_toolbox-1.9rc9.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
-fmu_manipulation_toolbox-1.9rc9.dist-info/RECORD,,
+fmu_manipulation_toolbox/resources/win32/client_sm.dll,sha256=OZH0q8D8gr0JgMUTeb48z5y-CjmecqcA8EWukwmQjbM,17920
+fmu_manipulation_toolbox/resources/win32/server_sm.exe,sha256=cOk25w7HmJrQptetQvWTSFSODfCz0aVVniD_hNZwtYg,15360
+fmu_manipulation_toolbox/resources/win64/client_sm.dll,sha256=XUhJMOUGiF1Gzedf7sQu5UtucfQ7Hoy9N0lrsVbBNgQ,21504
+fmu_manipulation_toolbox/resources/win64/container.dll,sha256=FXoB8zGRc3qm7ydGaGq1ow-2-usbzDJQeGTJfCunLyI,98816
+fmu_manipulation_toolbox/resources/win64/server_sm.exe,sha256=xuTcp83QJ-0pctU8Q3D9YGhQCAkPCBgc_nHA3w42onw,18432
+fmu_manipulation_toolbox-1.9.1.dist-info/licenses/LICENSE.txt,sha256=c_862mzyk6ownO3Gt6cVs0-53IXLi_-ZEQFNDVabESw,1285
+fmu_manipulation_toolbox-1.9.1.dist-info/METADATA,sha256=t2dJhOk02gbTS2bcZp8mX0DdwpYiHOvdkb8V3Bt5fbA,1155
+fmu_manipulation_toolbox-1.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fmu_manipulation_toolbox-1.9.1.dist-info/entry_points.txt,sha256=HjOZkflbI1IuSY8BpOZre20m24M4GDQGCJfPIa7NrlY,264
+fmu_manipulation_toolbox-1.9.1.dist-info/top_level.txt,sha256=9D_h-5BMjSqf9z-XFkbJL_bMppR2XNYW3WNuPkXou0k,25
+fmu_manipulation_toolbox-1.9.1.dist-info/RECORD,,