fmu-manipulation-toolbox 1.8.4.2rc1__tar.gz → 1.9rc0__tar.gz

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.9rc0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.8.4.2rc1
+Version: 1.9rc0
 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.8.4.2rc1 → fmu_manipulation_toolbox-1.9rc0}/README.md

@@ -12,12 +12,21 @@ FMU Manipulation Toolbox also allows to group FMU's inside FMU Containers. (see
 
 Two options available to install FMU Manipulation Toolbox:
 
-- (Easiest option) Install with from PyPI: `python -m pip install fmu_manipulation`
+- (*Easiest option*) Install with from PyPI: `pip install fmu-manipulation-toolbox`. This will install the latest
+  version of FMU Manipulation Toolbox and all its dependencies. See [PyPI page](https://pypi.org/project/fmu-manipulation-toolbox/).
 - Compile and install from [github repository](https://github.com/grouperenault/fmu_manipulation_toolbox). You will need 
-  - Python required packages. See `requirements.txt`.
-  - C compiler
+  - Python required packages. See [`requirements.txt`](requirements.txt).
+  - C compiler (C99 or later)
+  - CMake (>= 3.16)
+
+### Supported platforms
+FMU Manipulation Toolbox is tested on:
+- Windows 10/11
+- Linux (Ubuntu 22.04)
+
+Compilation is reported to work on:
+- MacOS (Apple Silicon and Intel)
 
-    
 ## Graphical User Interface
 
 FMU Manipulation Toolbox is released with a GUI. You can launch it with the following command `fmutool`
@@ -122,24 +131,29 @@ optional arguments:
 ### FMU Containers
 
 ```
-usage: fmucontainer [-h] [-fmu-directory FMU_DIRECTORY] -container filename.{csv|json|ssp},[:step_size] [-debug]
-                    [-no-auto-input] [-no-auto-output] [-auto-parameter] [-no-auto-link] [-mt] [-profile] [-dump-json]
+usage: fmucontainer [-h] [-fmu-directory FMU_DIRECTORY] [-fmi FMI_VERSION]
+                    -container filename.{csv|json|ssp},[:step_size] [-debug] [-no-auto-input] [-no-auto-output]
+                    [-auto-parameter] [-auto-local] [-no-auto-link] [-mt] [-profile] [-sequential] [-dump-json]
 
 Generate FMU from FMU's
 
-optional arguments:
+options:
   -h, -help
   -fmu-directory FMU_DIRECTORY      Directory containing initial FMU’s and used to generate containers. If not defined,
                                     current directory is used. (default: .)
+  -fmi FMI_VERSION                  Define version of FMI to be used for container interface.Only '2' or '3' is
+                                    supported. (default: 2)
   -container filename.{csv|json|ssp},[:step_size]
                                     Description of the container to create. (default: [])
   -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)
+  -auto-local                       Expose local variables 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)
+  -sequential                       Use sequential mode to schedule embedded fmu's. (default: False)
   -dump-json                        Dump a JSON file for each container. (default: False)
 ```
 
@@ -149,8 +163,9 @@ You can write your own FMU Manipulation scripts. Once you downloaded fmutool mod
 adding the `import` statement lets you access the API :
 
 ```python
-from fmu_manipulation_toolbox.fmu_operations import FMU, OperationExtractNames, OperationStripTopLevel,
-  OperationRenameFromCSV
+from fmu_manipulation_toolbox.operations import FMU, OperationExtractNames, OperationStripTopLevel,
+
+OperationRenameFromCSV
 ```
 
 ### remove toplevel bus (if any)

fmu_manipulation_toolbox-1.9rc0/fmu_manipulation_toolbox/__version__.py

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

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.9rc0}/fmu_manipulation_toolbox/assembly.py

@@ -7,7 +7,7 @@ import uuid
 import xml.parsers.expat
 import zipfile
 
-from .fmu_container import FMUContainer, AutoWired
+from .container import FMUContainer, AutoWired
 
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
@@ -37,7 +37,7 @@ class Connection:
 
 
 class AssemblyNode:
-    def __init__(self, name: Optional[str], step_size: float = None, mt=False, profiling=False,
+    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):
         self.name = name
         if step_size:
@@ -50,6 +50,7 @@ class AssemblyNode:
             self.step_size = None
         self.mt = mt
         self.profiling = profiling
+        self.sequential = sequential
         self.auto_link = auto_link
         self.auto_input = auto_input
         self.auto_output = auto_output
@@ -138,7 +139,8 @@ class AssemblyNode:
         for link_rule in wired.rule_link:
             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, debug=debug)
+        container.make_fmu(self.name, self.step_size, mt=self.mt, profiling=self.profiling, sequential=self.sequential,
+                           debug=debug)
 
         for node in self.children.values():
             logger.info(f"Deleting transient FMU Container '{node.name}'")
@@ -216,7 +218,7 @@ class AssemblyError(Exception):
 
 
 class Assembly:
-    def __init__(self, filename: str, step_size=None, auto_link=True,  auto_input=True, debug=False,
+    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):
         self.filename = Path(filename)
@@ -228,6 +230,7 @@ class Assembly:
         self.default_auto_parameter = auto_parameter
         self.default_auto_local = auto_local
         self.default_mt = mt
+        self.default_sequential = sequential
         self.default_profiling = profiling
         self.fmu_directory = fmu_directory
         self.transient_filenames: List[Path] = []
@@ -283,8 +286,9 @@ 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_parameter=self.default_auto_parameter, auto_local=self.default_auto_local)
+                                 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)
 
         with open(self.input_pathname) as file:
             reader = csv.reader(file, delimiter=';')
@@ -385,6 +389,7 @@ class Assembly:
         name = data.get("name", None)                                                       # 1
         mt = data.get("mt", self.default_mt)                                                # 2
         profiling = data.get("profiling", self.default_profiling)                           # 3
+        sequential = data.get("sequential", self.default_sequential)                        # 3b
         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
@@ -393,11 +398,12 @@ class Assembly:
         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,
+                            sequential=sequential,
                             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', 'sequential',
                        'auto_parameter', 'auto_local'):
                 continue  # Already read
 
@@ -455,6 +461,7 @@ class Assembly:
         json_node["name"] = node.name                      # 1
         json_node["mt"] = node.mt                          # 2
         json_node["profiling"] = node.profiling            # 3
+        json_node["sequential"] = node.sequential          # 3b
         json_node["auto_link"] = node.auto_link            # 4
         json_node["auto_input"] = node.auto_input          # 5
         json_node["auto_output"] = node.auto_output        # 6

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.9rc0}/fmu_manipulation_toolbox/checker.py

@@ -3,11 +3,11 @@ import inspect
 import os
 import xmlschema
 from xmlschema.validators.exceptions import XMLSchemaValidationError
-from .fmu_operations import OperationAbstract
+from .operations import OperationAbstract
 
 
 class OperationGenericCheck(OperationAbstract):
-    SUPPORTED_FMI_VERSIONS = ('2.0',)
+    SUPPORTED_FMI_VERSIONS = ('2.0', '3.0')
 
     def __init__(self):
         self.compliant_with_version = None
@@ -20,8 +20,10 @@ class OperationGenericCheck(OperationAbstract):
             print(f"ERROR: Expected FMI {','.join(self.SUPPORTED_FMI_VERSIONS)} versions.")
             return
 
+        fmi_name = f"fmi{attrs['fmiVersion'][0]}"
+
         xsd_filename = os.path.join(os.path.dirname(__file__), "resources", "fmi-" + attrs['fmiVersion'],
-                                    "fmi2ModelDescription.xsd")
+                                    f"{fmi_name}ModelDescription.xsd")
         try:
             xmlschema.validate(self.fmu.descriptor_filename, schema=xsd_filename)
         except XMLSchemaValidationError as error:

fmu_manipulation_toolbox-1.8.4.2rc1/fmu_manipulation_toolbox/fmu_container.py → fmu_manipulation_toolbox-1.9rc0/fmu_manipulation_toolbox/container.py

@@ -7,7 +7,7 @@ from datetime import datetime
 from pathlib import Path
 from typing import *
 
-from .fmu_operations import FMU, OperationAbstract
+from .operations import FMU, OperationAbstract, FMUError
 from .version import __version__ as tool_version
 
 
@@ -16,55 +16,61 @@ logger = logging.getLogger("fmu_manipulation_toolbox")
 
 class FMUPort:
     def __init__(self, attrs: Dict[str, str]):
-        self.name = attrs["name"]
-        self.vr = int(attrs["valueReference"])
         self.causality = attrs.get("causality", "local")
-        self.attrs = attrs.copy()
-        self.attrs.pop("name")
-        self.attrs.pop("valueReference")
-        if "causality" in self.attrs:
-            self.attrs.pop("causality")
-        self.type_name = None
-        self.child = None
+        self.variability = attrs.get("variability", "continuous")
+        self.name = attrs.get("name")
+        self.vr = int(attrs.get("valueReference"))
+        self.description = attrs.get("description", None)
+
+        self.type_name = attrs.get("type_name", None)
+        self.start_value = attrs.get("start", None)
+        self.initial = attrs.get("initial", None)
 
     def set_port_type(self, type_name: str, attrs: Dict[str, str]):
         self.type_name = type_name
-        self.child = attrs.copy()
-        for unsupported in ("unit", "declaredType"):
-            if unsupported in self.child:
-                self.child.pop(unsupported)
-
-    def xml(self, vr: int, name=None, causality=None, start=None):
-
-        if self.child is None:
-            raise FMUContainerError(f"FMUPort has no child. Bug?")
-
-        child_str = f"<{self.type_name}"
-        if self.child:
-            if start is not None and 'start' in self.child:
-                self.child['start'] = start
-            child_str += " " + " ".join([f'{key}="{value}"' for (key, value) in self.child.items()]) + "/>"
-        else:
-            child_str += "/>"
+        self.start_value = attrs.pop("start", None)
+        self.initial = attrs.pop("initial", None)
 
+    def xml(self, vr: int, name=None, causality=None, start=None, fmi_version=2):
         if name is None:
             name = self.name
         if causality is None:
             causality = self.causality
-
-        variability = "continuous" if self.type_name == "Real" else "discrete"
-
-        scalar_attrs = {
-            "name": name,
-            "valueReference": vr,
-            "causality": causality,
-            "variability": variability,
-        }
-        scalar_attrs.update(self.attrs)
-
-        scalar_attrs_str = " ".join([f'{key}="{value}"' for (key, value) in scalar_attrs.items()])
-
-        return f'<ScalarVariable {scalar_attrs_str}>{child_str}</ScalarVariable>'
+        if start is None:
+            start = self.start_value
+        if self.variability is None:
+            self.variability = "continuous" if self.type_name == "Real" else "discrete"
+
+
+        if fmi_version == 2:
+            child_dict =  {
+                "start": start,
+            }
+            if "Float" in self.type_name:
+                type_name = "Real"
+            elif "Int" in self.type_name:
+                type_name = "Integer"
+            else:
+                type_name = self.type_name
+
+            child_str = (f"<{type_name} " +
+                         " ".join([f'{key}="{value}"' if value is not None else ""
+                                   for (key, value) in child_dict.items()]) +
+                         "/>")
+
+            scalar_attrs = {
+                "name": name,
+                "valueReference": vr,
+                "causality": causality,
+                "variability": self.variability,
+                "initial": self.initial,
+                "description": self.description,
+            }
+            scalar_attrs_str = " ".join([f'{key}="{value}"' if value is not None else ""
+                                         for (key, value) in scalar_attrs.items()])
+            return f'<ScalarVariable {scalar_attrs_str}>{child_str}</ScalarVariable>'
+        else:
+            return f'FIX ME'
 
 
 class EmbeddedFMU(OperationAbstract):
@@ -76,7 +82,6 @@ class EmbeddedFMU(OperationAbstract):
         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
@@ -92,12 +97,22 @@ class EmbeddedFMU(OperationAbstract):
             raise FMUContainerError(f"FMU '{self.name}' does not implement Co-Simulation mode.")
 
     def fmi_attrs(self, attrs):
-        self.guid = attrs['guid']
-        self.fmi_version = attrs['fmiVersion']
+        fmi_version = attrs['fmiVersion']
+        if fmi_version == "2.0":
+            self.guid = attrs['guid']
+        if fmi_version == "3.0":
+            self.guid = attrs['instantiationToken']
+
 
     def scalar_attrs(self, attrs) -> int:
-        self.current_port = FMUPort(attrs)
-        self.ports[self.current_port.name] = self.current_port
+        if 'type_name' in attrs:  # FMI 3.0
+            type_name = attrs.pop('type_name')
+            port = FMUPort(attrs)
+            port.type_name = type_name
+            self.ports[port.name] = port
+        else: # FMI 2.0
+            self.current_port = FMUPort(attrs)
+            self.ports[self.current_port.name] = self.current_port
 
         return 0
 
@@ -199,6 +214,7 @@ class ValueReferenceTable:
     def __init__(self):
         self.vr_table: Dict[str, int] = {
             "Real": 0,
+            "Float64": 0,
             "Integer": 0,
             "Boolean": 0,
             "String": 0,
@@ -268,10 +284,8 @@ class FMUContainer:
             fmu = EmbeddedFMU(self.fmu_directory / fmu_filename)
             self.involved_fmu[fmu.name] = fmu
             self.execution_order.append(fmu)
-            if not fmu.fmi_version == "2.0":
-                raise FMUContainerError("Only FMI-2.0 is supported by FMUContainer")
             logger.debug(f"Adding FMU #{len(self.execution_order)}: {fmu}")
-        except Exception as e:
+        except (FMUContainerError, FMUError) as e:
             raise FMUContainerError(f"Cannot load '{fmu_filename}': {e}")
 
         return fmu
@@ -346,9 +360,9 @@ class FMUContainer:
         cport = ContainerPort(self.get_fmu(fmu_filename), port_name)
 
         try:
-            if cport.port.type_name == 'Real':
+            if cport.port.type_name in ('Real', 'Float64', 'Float32'):
                 value = float(value)
-            elif cport.port.type_name == 'Integer':
+            elif cport.port.type_name in ('Integer', 'Int8', 'UInt8', 'Int16', 'UInt16', 'Int32', 'UInt32', 'Int64', 'UInt64'):
                 value = int(value)
             elif cport.port.type_name == 'Boolean':
                 value = int(bool(value))
@@ -451,7 +465,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):
+                 profiling=False, sequential=False):
         if isinstance(fmu_filename, str):
             fmu_filename = Path(fmu_filename)
 
@@ -467,7 +481,7 @@ class FMUContainer:
         with open(base_directory / "modelDescription.xml", "wt") as xml_file:
             self.make_fmu_xml(xml_file, step_size, profiling)
         with open(resources_directory / "container.txt", "wt") as txt_file:
-            self.make_fmu_txt(txt_file, step_size, mt, profiling)
+            self.make_fmu_txt(txt_file, step_size, mt, profiling, sequential)
 
         self.make_fmu_package(base_directory, fmu_filename)
         if not debug:
@@ -580,16 +594,10 @@ class FMUContainer:
 </fmiModelDescription>
 """)
 
-    def make_fmu_txt(self, txt_file, step_size: float, mt: bool, profiling: bool):
-        if mt:
-            print("# Use MT\n1", file=txt_file)
-        else:
-            print("# Don't use MT\n0", file=txt_file)
-
-        if profiling:
-            print("# Profiling ENABLED\n1", file=txt_file)
-        else:
-            print("# Profiling DISABLED\n0", file=txt_file)
+    def make_fmu_txt(self, txt_file, step_size: float, mt: bool, profiling: bool, sequential: bool):
+        print("# Container flags <MT> <Profiling> <Sequential>", file=txt_file)
+        flags = [ str(int(flag == True)) for flag in (mt, profiling, sequential)]
+        print(" ".join(flags), file=txt_file)
 
         print(f"# Internal time step in seconds", file=txt_file)
         print(f"{step_size}", file=txt_file)

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.9rc0}/fmu_manipulation_toolbox/gui.py

@@ -12,7 +12,7 @@ from functools import partial
 from typing import Optional
 
 from .gui_style import gui_style
-from .fmu_operations import *
+from .operations import *
 from .assembly import Assembly, AssemblyNode
 from .checker import checker_list
 from .help import Help

fmu_manipulation_toolbox-1.8.4.2rc1/fmu_manipulation_toolbox/fmu_operations.py → fmu_manipulation_toolbox-1.9rc0/fmu_manipulation_toolbox/operations.py

@@ -8,23 +8,29 @@ import xml.parsers.expat
 import zipfile
 import hashlib
 from pathlib import Path
+from typing import *
 
 
 class FMU:
     """Unpack and Repack facilities for FMU package. Once unpacked, we can process Operation on
     modelDescription.xml file."""
+
+    FMI2_TYPES = ('Real', 'Integer', 'String', 'Boolean', 'Enumeration')
+    FMI3_TYPES = ('Float64')
+
     def __init__(self, fmu_filename):
         self.fmu_filename = fmu_filename
         self.tmp_directory = tempfile.mkdtemp()
+        self.fmi_version = None
 
         try:
             with zipfile.ZipFile(self.fmu_filename) as zin:
                 zin.extractall(self.tmp_directory)
         except FileNotFoundError:
-            raise FMUException(f"'{fmu_filename}' does not exist")
+            raise FMUError(f"'{fmu_filename}' does not exist")
         self.descriptor_filename = os.path.join(self.tmp_directory, "modelDescription.xml")
         if not os.path.isfile(self.descriptor_filename):
-            raise FMUException(f"'{fmu_filename}' is not valid: {self.descriptor_filename} not found")
+            raise FMUError(f"'{fmu_filename}' is not valid: {self.descriptor_filename} not found")
 
     def __del__(self):
         shutil.rmtree(self.tmp_directory)
@@ -45,7 +51,7 @@ class FMU:
         manipulation.manipulate(self.descriptor_filename, apply_on)
 
 
-class FMUException(Exception):
+class FMUError(Exception):
     def __init__(self, reason):
         self.reason = reason
 
@@ -63,12 +69,13 @@ class Manipulation:
         self.parser.StartElementHandler = self.start_element
         self.parser.EndElementHandler = self.end_element
         self.parser.CharacterDataHandler = self.char_data
-        self.skip_until = None
+        self.skip_until: Optional[str] = None
         self.operation.set_fmu(fmu)
+        self.fmu = fmu
 
-        self.current_port = 0
-        self.port_translation = []
-        self.port_name = []
+        self.current_port: int = 0
+        self.port_translation: List[int] = []
+        self.port_names_list: List[str] = []
         self.apply_on = None
 
     @staticmethod
@@ -78,19 +85,27 @@ class Manipulation:
         else:
             return value
 
+    def start_variable(self, attrs):
+        causality = OperationAbstract.scalar_get_causality(attrs)
+        port_name = attrs['name']
+        if not self.apply_on or causality in self.apply_on:
+            if self.operation.scalar_attrs(attrs):
+                self.remove_port(port_name)
+            else:
+                self.keep_port(port_name)
+        else:  # Keep ScalarVariable as it is.
+            self.keep_port(port_name)
+
+
     def start_element(self, name, attrs):
         if self.skip_until:
             return
         try:
             if name == 'ScalarVariable':
-                causality = OperationAbstract.scalar_get_causality(attrs)
-                if not self.apply_on or causality in self.apply_on:
-                    if self.operation.scalar_attrs(attrs):
-                        self.remove_port(attrs['name'])
-                    else:
-                        self.keep_port(attrs['name'])
-                else:  # Keep ScalarVariable as it is.
-                    self.keep_port(attrs['name'])
+                self.start_variable(attrs)
+            elif name in self.fmu.FMI3_TYPES:
+                attrs['type_name'] = name
+                self.start_variable(attrs)
             elif name == 'CoSimulation':
                 self.operation.cosimulation_attrs(attrs)
             elif name == 'DefaultExperiment':
@@ -99,7 +114,7 @@ class Manipulation:
                 self.operation.fmi_attrs(attrs)
             elif name == 'Unknown':
                 self.unknown_attrs(attrs)
-            elif name in ('Real', 'Integer', 'String', 'Boolean', 'Enumeration'):
+            elif name in self.fmu.FMI2_TYPES:
                 self.operation.scalar_type(name, attrs)
 
         except ManipulationSkipTag:
@@ -107,6 +122,7 @@ class Manipulation:
             return
 
         if attrs:
+            attrs.pop('fmi_type', None) # FMI 3.0: this attr was added during manipulation
             attrs_list = [f'{key}="{self.escape(value)}"' for (key, value) in attrs.items()]
             print(f"<{name}", " ".join(attrs_list), ">", end='', file=self.out)
         else:
@@ -125,12 +141,12 @@ class Manipulation:
             print(data, end='', file=self.out)
 
     def remove_port(self, name):
-        self.port_name.append(name)
+        self.port_names_list.append(name)
         self.port_translation.append(None)
         raise ManipulationSkipTag
 
     def keep_port(self, name):
-        self.port_name.append(name)
+        self.port_names_list.append(name)
         self.current_port += 1
         self.port_translation.append(self.current_port)
 
@@ -140,7 +156,7 @@ class Manipulation:
         if new_index:
             attrs['index'] = self.port_translation[int(attrs['index']) - 1]
         else:
-            print(f"WARNING: Removed port '{self.port_name[index]}' is involved in dependencies tree.")
+            print(f"WARNING: Removed port '{self.port_names_list[index]}' is involved in dependencies tree.")
             raise ManipulationSkipTag
 
     def manipulate(self, descriptor_filename, apply_on=None):

fmu_manipulation_toolbox-1.9rc0/fmu_manipulation_toolbox/resources/fmi-3.0/fmi3Annotation.xsd

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="unqualified">
+    <xs:annotation>
+        <xs:documentation>
+Copyright(c) 2008-2011 MODELISAR consortium,
+             2012-2024 Modelica Association Project "FMI".
+             All rights reserved.
+
+This file is licensed by the copyright holders under the 2-Clause BSD License
+(https://opensource.org/licenses/BSD-2-Clause):
+
+----------------------------------------------------------------------------
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+- Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+----------------------------------------------------------------------------
+        </xs:documentation>
+    </xs:annotation>
+    <xs:complexType name="fmi3Annotations">
+        <xs:sequence maxOccurs="unbounded">
+            <xs:element name="Annotation">
+                <xs:complexType mixed="true">
+                    <xs:sequence>
+                        <xs:any namespace="##any" processContents="lax" minOccurs="0" maxOccurs="unbounded"/>
+                    </xs:sequence>
+                    <xs:attribute name="type" type="xs:normalizedString" use="required">
+                    </xs:attribute>
+                </xs:complexType>
+            </xs:element>
+        </xs:sequence>
+    </xs:complexType>
+    <xs:element name="Annotations" type="fmi3Annotations"/>
+</xs:schema>