fmu-manipulation-toolbox 1.8.1__tar.gz → 1.8.2__tar.gz

{fmu_manipulation_toolbox-1.8.1 → fmu_manipulation_toolbox-1.8.2}/PKG-INFO

@@ -1,14 +1,19 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: fmu_manipulation_toolbox
-Version: 1.8.1
+Version: 1.8.2
 Summary: FMU Manipulation Toobox is a python application which help to modify a Functional Mock-up Units (FMUs) without recompilation or to group them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com
 License-File: LICENSE.txt
-Requires-Dist: PyQt5>=5.15.10
+Requires-Dist: PySide6>=6.8.0
 Requires-Dist: xmlschema>=3.3.1
 Requires-Dist: elementpath>=4.4.0
 Requires-Dist: colorama>=0.4.6
+Dynamic: author
+Dynamic: description
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
 
 FMU Manipulation Toolbox is a python application which help to modify a Functional Mock-up Units (FMUs) 
 without recompilation. It mainly modifies the `modelDescription.xml` file. It is highly customizable.

{fmu_manipulation_toolbox-1.8.1 → fmu_manipulation_toolbox-1.8.2}/README.md

@@ -123,7 +123,7 @@ optional arguments:
 
 ```
 usage: fmucontainer [-h] [-fmu-directory FMU_DIRECTORY] -container filename.{csv|json|ssp},[:step_size] [-debug]
-                    [-no-auto-input] [-no-auto-output] [-no-auto-link] [-mt] [-profile] [-dump-json]
+                    [-no-auto-input] [-no-auto-output] [-auto-parameter] [-no-auto-link] [-mt] [-profile] [-dump-json]
 
 Generate FMU from FMU's
 
@@ -136,6 +136,7 @@ optional arguments:
   -debug                            Add lot of useful log during the process. (default: False)
   -no-auto-input                    Create ONLY explicit input. (default: True)
   -no-auto-output                   Create ONLY explicit output. (default: True)
+  -auto-parameter                   Expose parameters of the embedded fmu's. (default: False)
   -no-auto-link                     Create ONLY explicit links. (default: True)
   -mt                               Enable Multi-Threaded mode for the generated container. (default: False)
   -profile                          Enable Profiling mode for the generated container. (default: False)

fmu_manipulation_toolbox-1.8.2/fmu_manipulation_toolbox/__version__.py

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

{fmu_manipulation_toolbox-1.8.1 → fmu_manipulation_toolbox-1.8.2}/fmu_manipulation_toolbox/assembly.py

@@ -23,16 +23,22 @@ class Port:
     def __eq__(self, other):
         return str(self) == str(other)
 
+    def __str__(self):
+        return f"{self.fmu_name}/{self.port_name}"
+
 
 class Connection:
     def __init__(self, from_port: Port, to_port: Port):
         self.from_port = from_port
         self.to_port = to_port
 
+    def __str__(self):
+        return f"{self.from_port} -> {self.to_port}"
+
 
 class AssemblyNode:
     def __init__(self, name: Optional[str], step_size: float = None, mt=False, profiling=False,
-                 auto_link=True, auto_input=True, auto_output=True):
+                 auto_link=True, auto_input=True, auto_output=True, auto_parameter=False, auto_local=False):
         self.name = name
         if step_size:
             try:
@@ -47,12 +53,14 @@ class AssemblyNode:
         self.auto_link = auto_link
         self.auto_input = auto_input
         self.auto_output = auto_output
+        self.auto_parameter = auto_parameter
+        self.auto_local = auto_local
 
         self.parent: Optional[AssemblyNode] = None
-        self.children: List[AssemblyNode] = []          # sub-containers
-        self.fmu_names_list: Set[str] = set()           # FMUs contained at this level
-        self.input_ports: Dict[Port, str] = {}
-        self.output_ports: Dict[Port, str] = {}
+        self.children: Dict[str, AssemblyNode] = {}     # sub-containers
+        self.fmu_names_list: List[str] = []             # FMUs contained at this level (ordered list)
+        self.input_ports: Dict[Port, str] = {}          # value is input port name, key is the source
+        self.output_ports: Dict[Port, str] = {}         # value is output port name, key is the origin
         self.start_values: Dict[Port, str] = {}
         self.drop_ports: List[Port] = []
         self.links: List[Connection] = []
@@ -64,13 +72,17 @@ class AssemblyNode:
         if sub_node.parent is not None:
             raise AssemblyError(f"Internal Error: AssemblyNode {sub_node.name} is already parented.")
 
-        sub_node.parent = self
-        self.fmu_names_list.add(sub_node.name)
-        self.children.append(sub_node)
+        if sub_node.name in self.children:
+            raise AssemblyError(f"Internal Error: AssemblyNode {sub_node.name} is already child of {self.name}")
 
+        sub_node.parent = self
+        if sub_node.name not in self.fmu_names_list:
+            self.fmu_names_list.append(sub_node.name)
+        self.children[sub_node.name] = sub_node
 
     def add_fmu(self, fmu_name: str):
-        self.fmu_names_list.add(fmu_name)
+        if fmu_name not in self.fmu_names_list:
+            self.fmu_names_list.append(fmu_name)
 
     def add_input(self, from_port_name: str, to_fmu_filename: str, to_port_name: str):
         self.input_ports[Port(to_fmu_filename, to_port_name)] = from_port_name
@@ -89,12 +101,13 @@ class AssemblyNode:
         self.start_values[Port(fmu_filename, port_name)] = value
 
     def make_fmu(self, fmu_directory: Path, debug=False, description_pathname=None):
-        for node in self.children:
+        for node in self.children.values():
             node.make_fmu(fmu_directory, debug=debug)
 
-        container = FMUContainer(self.name, fmu_directory, description_pathname=description_pathname)
+        identifier = str(Path(self.name).stem)
+        container = FMUContainer(identifier, fmu_directory, description_pathname=description_pathname)
 
-        for fmu_name in sorted(self.fmu_names_list):
+        for fmu_name in self.fmu_names_list:
             container.get_fmu(fmu_name)
 
         for port, source in self.input_ports.items():
@@ -115,14 +128,78 @@ class AssemblyNode:
 
         container.add_implicit_rule(auto_input=self.auto_input,
                                     auto_output=self.auto_output,
-                                    auto_link=self.auto_link)
+                                    auto_link=self.auto_link,
+                                    auto_parameter=self.auto_parameter,
+                                    auto_local=self.auto_local)
 
         container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, debug=debug)
 
-        for node in self.children:
+        for node in self.children.values():
             logger.info(f"Deleting transient FMU Container '{node.name}'")
             (fmu_directory / node.name).unlink()
 
+    def get_final_from(self, port: Port) -> Port:
+        if port in self.input_ports:
+            ancestor = Port(self.name, self.input_ports[port])
+            if self.parent:
+                return self.parent.get_final_from(ancestor)  # input port
+            else:
+                return ancestor  # TOPLEVEL input port
+        elif port.fmu_name in self.fmu_names_list:
+            if port.fmu_name in self.children:
+                child = self.children[port.fmu_name]
+                ancestors = [key for key, val in child.output_ports.items() if val == port.port_name]
+                if len(ancestors) == 1:
+                    return child.get_final_from(ancestors[0])  # child output port
+            else:
+                return port  # embedded FMU
+
+        raise AssemblyError(f"{self.name}: Port {port} is not connected upstream.")
+
+    def get_final_to(self, port: Port) -> Port:
+        if port in self.output_ports:
+            successor = Port(self.name, self.output_ports[port])
+            if self.parent:
+                return self.parent.get_final_to(successor)  # Output port
+            else:
+                return successor  # TOLEVEL output port
+        elif port.fmu_name in self.fmu_names_list:
+            if port.fmu_name in self.children:
+                child = self.children[port.fmu_name]
+                successors = [key for key, val in child.input_ports.items() if val == port.port_name]
+                if len(successors) == 1:
+                    return child.get_final_to(successors[0])  # Child input port
+            else:
+                return port  # embedded FMU
+
+        raise AssemblyError(f"Node {self.name}: Port {port} is not connected downstream.")
+
+    def get_fmu_connections(self, fmu_name: str) -> List[Connection]:
+        connections = []
+        if fmu_name not in self.fmu_names_list:
+            raise AssemblyError(f"Internal Error: FMU {fmu_name} is not embedded by {self.name}.")
+        for link in self.links:
+            if link.from_port.fmu_name == fmu_name:
+                connections.append(Connection(link.from_port, self.get_final_to(link.to_port)))
+            elif link.to_port.fmu_name == fmu_name:
+                connections.append(Connection(self.get_final_from(link.from_port), link.to_port))
+
+        for to_port, input_port_name in self.input_ports.items():
+            if to_port.fmu_name == fmu_name:
+                if self.parent:
+                    connections.append(Connection(self.parent.get_final_from(Port(self.name, input_port_name)), to_port))
+                else:
+                    connections.append(Connection(Port(self.name, input_port_name), to_port))
+
+        for from_port, output_port_name in self.output_ports.items():
+            if from_port.fmu_name == fmu_name:
+                if self.parent:
+                    connections.append(Connection(from_port, self.parent.get_final_to(Port(self.name, output_port_name))))
+                else:
+                    connections.append(Connection(from_port, Port(self.name, output_port_name))) ###HERE
+
+        return connections
+
 
 class AssemblyError(Exception):
     def __init__(self, reason: str):
@@ -134,13 +211,16 @@ class AssemblyError(Exception):
 
 class Assembly:
     def __init__(self, filename: str, step_size=None, auto_link=True,  auto_input=True, debug=False,
-                 auto_output=True, mt=False, profiling=False, fmu_directory: Path = "."):
+                 auto_output=True, mt=False, profiling=False, fmu_directory: Path = Path("."), auto_parameter=False,
+                 auto_local=False):
         self.filename = Path(filename)
         self.default_auto_input = auto_input
         self.debug = debug
         self.default_auto_output = auto_output
         self.default_step_size = step_size
         self.default_auto_link = auto_link
+        self.default_auto_parameter = auto_parameter
+        self.default_auto_local = auto_local
         self.default_mt = mt
         self.default_profiling = profiling
         self.fmu_directory = fmu_directory
@@ -197,7 +277,8 @@ class Assembly:
         name = str(self.filename.with_suffix(".fmu"))
         self.root = AssemblyNode(name, step_size=self.default_step_size, auto_link=self.default_auto_link,
                                  mt=self.default_mt, profiling=self.default_profiling,
-                                 auto_input=self.default_auto_input, auto_output=self.default_auto_output)
+                                 auto_input=self.default_auto_input, auto_output=self.default_auto_output,
+                                 auto_parameter=self.default_auto_parameter, auto_local=self.default_auto_local)
 
         with open(self.input_pathname) as file:
             reader = csv.reader(file, delimiter=';')
@@ -292,49 +373,53 @@ class Assembly:
                 raise AssemblyError(f"Cannot read json: {e}")
         self.root = self._json_decode_node(data)
         if not self.root.name:
-            self.root.name = str(self.filename.with_suffix(".fmu"))
+            self.root.name = str(self.filename.with_suffix(".fmu").name)
 
-    def _json_decode_node(self, data:Dict) -> AssemblyNode:
+    def _json_decode_node(self, data: Dict) -> AssemblyNode:
         name = data.get("name", None)                                                       # 1
-        step_size = data.get("step_size", self.default_step_size)                           # 7
+        mt = data.get("mt", self.default_mt)                                                # 2
+        profiling = data.get("profiling", self.default_profiling)                           # 3
         auto_link = data.get("auto_link", self.default_auto_link)                           # 4
         auto_input = data.get("auto_input", self.default_auto_input)                        # 5
         auto_output = data.get("auto_output", self.default_auto_output)                     # 6
-        mt = data.get("mt", self.default_mt)                                                # 2
-        profiling = data.get("profiling", self.default_profiling)                           # 3
+        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
 
         node = AssemblyNode(name, step_size=step_size, auto_link=auto_link, mt=mt, profiling=profiling,
-                            auto_input=auto_input, auto_output=auto_output)
+                            auto_input=auto_input, auto_output=auto_output, auto_parameter=auto_parameter,
+                            auto_local=auto_local)
 
         for key, value in data.items():
-            if key in ('name', 'step_size', 'auto_link', 'auto_input', 'auto_output', 'mt', 'profiling'):
+            if key in ('name', 'step_size', 'auto_link', 'auto_input', 'auto_output', 'mt', 'profiling',
+                       'auto_parameter', 'auto_local'):
                 continue  # Already read
 
-            elif key == "container": # 8
+            elif key == "container":  # 8
                 if not isinstance(value, list):
                     raise AssemblyError("JSON: 'container' keyword should define a list.")
                 for sub_data in value:
                     node.add_sub_node(self._json_decode_node(sub_data))
 
-            elif key == "fmu": # 9
+            elif key == "fmu":  # 9
                 if not isinstance(value, list):
                     raise AssemblyError("JSON: 'fmu' keyword should define a list.")
                 for fmu in value:
                     node.add_fmu(fmu)
 
-            elif key == "input": # 10
+            elif key == "input":  # 10
                 self._json_decode_keyword('input', value, node.add_input)
 
-            elif key == "output": # 11
+            elif key == "output":  # 11
                 self._json_decode_keyword('output', value, node.add_output)
 
-            elif key == "link": # 12
+            elif key == "link":  # 12
                 self._json_decode_keyword('link', value, node.add_link)
 
-            elif key == "start": # 13
+            elif key == "start":  # 13
                 self._json_decode_keyword('start', value, node.add_start_value)
 
-            elif key == "drop": #14
+            elif key == "drop":  # 14
                 self._json_decode_keyword('drop', value, node.add_drop_port)
 
             else:
@@ -354,7 +439,6 @@ class Assembly:
             except TypeError:
                 raise AssemblyError(f"JSON: '{keyword}' value does not contain right number of fields: {line}.")
 
-
     def write_json(self, filename: Union[str, Path]):
         with open(self.fmu_directory / filename, "wt") as file:
             data = self._json_encode_node(self.root)
@@ -362,21 +446,23 @@ class Assembly:
 
     def _json_encode_node(self, node: AssemblyNode) -> Dict[str, Any]:
         json_node = dict()
-        json_node["name"] = node.name               # 1
-        json_node["mt"] = node.mt                   # 2
-        json_node["profiling"] = node.profiling     # 3
-        json_node["auto_link"] = node.auto_link     # 4
-        json_node["auto_input"] = node.auto_input   # 5
-        json_node["auto_output"] = node.auto_output # 6
+        json_node["name"] = node.name                      # 1
+        json_node["mt"] = node.mt                          # 2
+        json_node["profiling"] = node.profiling            # 3
+        json_node["auto_link"] = node.auto_link            # 4
+        json_node["auto_input"] = node.auto_input          # 5
+        json_node["auto_output"] = node.auto_output        # 6
+        json_node["auto_parameter"] = node.auto_parameter  # 6b
+        json_node["auto_local"] = node.auto_local          # 6c
 
         if node.step_size:
-            json_node["step_size"] = node.step_size # 7
+            json_node["step_size"] = node.step_size        # 7
 
         if node.children:
-            json_node["container"] = [self._json_encode_node(child) for child in node.children]     # 8
+            json_node["container"] = [self._json_encode_node(child) for child in node.children.values()]  # 8
 
         if node.fmu_names_list:
-            json_node["fmu"] = [f"{fmu_name}" for fmu_name in sorted(node.fmu_names_list)]          #9
+            json_node["fmu"] = [f"{fmu_name}" for fmu_name in sorted(node.fmu_names_list)]          # 9
 
         if node.input_ports:
             json_node["input"] = [[f"{source}", f"{port.fmu_name}", f"{port.port_name}"]            # 10
@@ -396,7 +482,7 @@ class Assembly:
                                   for port, value in node.start_values.items()]
 
         if node.drop_ports:
-            json_node["drop"] = [[f"{port.fmu_name}", f"{port.port_name}"] for port in node.drop_ports] # 14
+            json_node["drop"] = [[f"{port.fmu_name}", f"{port.port_name}"] for port in node.drop_ports]  # 14
 
         return json_node
 

{fmu_manipulation_toolbox-1.8.1 → fmu_manipulation_toolbox-1.8.2}/fmu_manipulation_toolbox/cli.py

@@ -176,6 +176,12 @@ def fmucontainer():
     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.")
 
@@ -198,16 +204,19 @@ def fmucontainer():
 
     for description in config.container_descriptions_list:
         try:
-            filename, step_size = description.split(":")
-            step_size = float(step_size)
+            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, mt=config.mt,
-                                profiling=config.profiling, fmu_directory=fmu_directory, debug=config.debug)
-
+                                auto_input=config.auto_input, auto_output=config.auto_output,
+                                auto_local=config.auto_local, mt=config.mt,
+                                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

{fmu_manipulation_toolbox-1.8.1 → fmu_manipulation_toolbox-1.8.2}/fmu_manipulation_toolbox/fmu_container.py

@@ -74,9 +74,12 @@ class EmbeddedFMU(OperationAbstract):
     def __init__(self, filename):
         self.fmu = FMU(filename)
         self.name = Path(filename).name
+        self.id = Path(filename).stem
 
         self.fmi_version = None
         self.step_size = None
+        self.start_time = None
+        self.stop_time = None
         self.model_identifier = None
         self.guid = None
         self.ports: Dict[str, FMUPort] = {}
@@ -103,15 +106,18 @@ class EmbeddedFMU(OperationAbstract):
         for capability in self.capability_list:
             self.capabilities[capability] = attrs.get(capability, "false")
 
-    def experiment_attrs(self, attrs):
+    def experiment_attrs(self, attrs: Dict[str, str]):
         try:
             self.step_size = float(attrs['stepSize'])
         except KeyError:
             logger.warning(f"FMU '{self.name}' does not specify preferred step size")
-            pass
+        self.start_time = float(attrs.get("startTime", 0.0))
+        self.stop_time = float(attrs.get("stopTime", self.start_time + 1.0))
 
     def scalar_type(self, type_name, attrs):
         if self.current_port:
+            if type_name == "Enumeration":
+                type_name = "Integer"
             self.current_port.set_port_type(type_name, attrs)
         self.current_port = None
 
@@ -148,7 +154,7 @@ class ContainerPort:
 
 class Local:
     def __init__(self, cport_from: ContainerPort):
-        self.name = cport_from.fmu.name[:-4] + "." + cport_from.port.name  # strip .fmu suffix
+        self.name = cport_from.fmu.id + "." + cport_from.port.name  # strip .fmu suffix
         self.cport_from = cport_from
         self.cport_to_list: List[ContainerPort] = []
         self.vr = None
@@ -195,6 +201,9 @@ class FMUContainer:
 
         self.description_pathname = description_pathname
 
+        self.start_time = None
+        self.stop_time = None
+
         # Rules
         self.inputs: Dict[str, ContainerPort] = {}
         self.outputs: Dict[str, ContainerPort] = {}
@@ -299,13 +308,19 @@ class FMUContainer:
                     return ContainerPort(fmu, port.name)
         return None
 
-    def add_implicit_rule(self, auto_input: bool = True, auto_output: bool = True, auto_link: bool = True):
+    def add_implicit_rule(self, auto_input=True, auto_output=True, auto_link=True, auto_parameter=False,
+                          auto_local=False):
         # Auto Link outputs
         for fmu in self.execution_order:
             for port_name in fmu.ports:
                 cport = ContainerPort(fmu, port_name)
                 if cport not in self.rules:
-                    if cport.port.causality == 'output':
+                    if cport.port.causality == 'parameter' and auto_parameter:
+                        parameter_name = cport.fmu.model_identifier+"."+cport.port.name
+                        logger.info(f"AUTO PARAMETER: {cport} as {parameter_name}")
+                        self.inputs[parameter_name] = cport
+                        self.mark_ruled(cport, 'PARAMETER')
+                    elif cport.port.causality == 'output':
                         candidate_cport = self.find_input(cport.port)
                         if auto_link and candidate_cport:
                             local = Local(cport)
@@ -314,11 +329,21 @@ class FMUContainer:
                             self.mark_ruled(cport, 'LINK')
                             self.mark_ruled(candidate_cport, 'LINK')
                             self.locals[cport] = local
-                        else:
-                            if auto_output:
-                                self.mark_ruled(cport, 'OUTPUT')
-                                self.outputs[port_name] = cport
-                                logger.info(f"AUTO OUTPUT: Expose {cport}")
+                        elif auto_output:
+                            self.mark_ruled(cport, 'OUTPUT')
+                            self.outputs[port_name] = cport
+                            logger.info(f"AUTO OUTPUT: Expose {cport}")
+                    elif cport.port.causality == 'local':
+                        local_portname = None
+                        if port_name.startswith("container."):
+                            local_portname = "container." + cport.fmu.id + "." + port_name[10:]
+                            logger.info(f"PROFILING: Expose {cport}")
+                        elif auto_local:
+                            local_portname = cport.fmu.id + "." + port_name
+                            logger.info(f"AUTO LOCAL: Expose {cport}")
+                        if local_portname:
+                            self.mark_ruled(cport, 'OUTPUT')
+                            self.outputs[local_portname] = cport
 
         if auto_input:
             # Auto link inputs
@@ -406,6 +431,18 @@ class FMUContainer:
                 if fmu.capabilities[capability] == "true":
                     capabilities[capability] = "true"
 
+        if self.start_time is None:
+            self.start_time = self.execution_order[0].start_time
+            logger.info(f"start_time={self.start_time} (deduced from '{self.execution_order[0].name}')")
+        else:
+            logger.info(f"start_time={self.start_time}")
+
+        if self.stop_time is None:
+            self.stop_time = self.execution_order[0].stop_time
+            logger.info(f"stop_time={self.stop_time} (deduced from '{self.execution_order[0].name}')")
+        else:
+            logger.info(f"stop_time={self.stop_time}")
+
         xml_file.write(f"""<?xml version="1.0" encoding="ISO-8859-1"?>
 <fmiModelDescription
   fmiVersion="2.0"
@@ -434,14 +471,14 @@ class FMUContainer:
     <Category name="fmucontainer"/>
   </LogCategories>
 
-  <DefaultExperiment stepSize="{step_size}"/>
+  <DefaultExperiment stepSize="{step_size}" startTime="{self.start_time}" stopTime="{self.stop_time}"/>
 
   <ModelVariables>
 """)
         if profiling:
             for fmu in self.execution_order:
                 vr = vr_table.add_vr("Real")
-                name = f"container.{fmu.model_identifier}.rt_ratio"
+                name = f"container.{fmu.id}.rt_ratio"
                 print(f'<ScalarVariable valueReference="{vr}" name="{name}" causality="local">'
                       f'<Real /></ScalarVariable>', file=xml_file)
 
@@ -591,6 +628,14 @@ class FMUContainer:
                 for cport, vr in outputs_fmu_per_type[type_name][fmu.name].items():
                     print(f"{vr} {cport.port.vr}", file=txt_file)
 
+    @staticmethod
+    def long_path(path: Union[str, Path]) -> str:
+        # https://stackoverflow.com/questions/14075465/copy-a-file-with-a-too-long-path-to-another-directory-in-python
+        if os.name == 'nt':
+            return "\\\\?\\" + os.path.abspath(str(path))
+        else:
+            return path
+
     def make_fmu_skeleton(self, base_directory: Path) -> Path:
         logger.debug(f"Initialize directory '{base_directory}'")
 
@@ -617,8 +662,8 @@ class FMUContainer:
                 shutil.copy(library_filename, binary_directory / f"{self.identifier}.dll")
 
         for fmu in self.involved_fmu.values():
-            shutil.copytree(fmu.fmu.tmp_directory, resources_directory / fmu.name, dirs_exist_ok=True)
-
+            shutil.copytree(self.long_path(fmu.fmu.tmp_directory),
+                            self.long_path(resources_directory / fmu.name), dirs_exist_ok=True)
         return resources_directory
 
     def make_fmu_package(self, base_directory: Path, fmu_filename: Path):
@@ -626,11 +671,10 @@ class FMUContainer:
         with zipfile.ZipFile(self.fmu_directory / fmu_filename, "w", zipfile.ZIP_DEFLATED) as zip_file:
             for root, dirs, files in os.walk(base_directory):
                 for file in files:
-                    zip_file.write(os.path.join(root, file),
+                    zip_file.write(self.long_path(os.path.join(root, file)),
                                    os.path.relpath(os.path.join(root, file), base_directory))
         logger.info(f"'{fmu_filename}' is available.")
 
-    @staticmethod
-    def make_fmu_cleanup(base_directory: Path):
+    def make_fmu_cleanup(self, base_directory: Path):
         logger.debug(f"Delete directory '{base_directory}'")
-        shutil.rmtree(base_directory)
+        shutil.rmtree(self.long_path(base_directory))

{fmu_manipulation_toolbox-1.8.1 → fmu_manipulation_toolbox-1.8.2}/fmu_manipulation_toolbox/fmu_operations.py

@@ -89,9 +89,8 @@ class Manipulation:
                         self.remove_port(attrs['name'])
                     else:
                         self.keep_port(attrs['name'])
-                else:
+                else:  # Keep ScalarVariable as it is.
                     self.keep_port(attrs['name'])
-                    self.skip_until = name   # do not read inner tags
             elif name == 'CoSimulation':
                 self.operation.cosimulation_attrs(attrs)
             elif name == 'DefaultExperiment':
@@ -100,7 +99,7 @@ class Manipulation:
                 self.operation.fmi_attrs(attrs)
             elif name == 'Unknown':
                 self.unknown_attrs(attrs)
-            elif name in ('Real', 'Integer', 'String', 'Boolean'):
+            elif name in ('Real', 'Integer', 'String', 'Boolean', 'Enumeration'):
                 self.operation.scalar_type(name, attrs)
 
         except ManipulationSkipTag: