fmu-manipulation-toolbox 1.8.4.2rc1__tar.gz → 1.8.4.3b0__tar.gz

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.8.4.3b0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.8.4.2rc1
+Version: 1.8.4.3b0
 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.8.4.3b0}/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`
@@ -149,8 +158,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.8.4.3b0/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.8.4.3-beta'

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.8.4.3b0}/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")
 

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.8.4.3b0}/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.8.4.3b0/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.causality = attrs.pop("causality", "local")
+        self.variability = attrs.pop("variability", "continuous")
+        self.name = attrs.pop("name")
+        self.vr = int(attrs.pop("valueReference"))
+        self.description = attrs.pop("description", None)
+
+        self.type_name = attrs.pop("type_name", None)
+        self.start_value = attrs.pop("start", None)
+        self.initial = attrs.pop("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))

{fmu_manipulation_toolbox-1.8.4.2rc1 → fmu_manipulation_toolbox-1.8.4.3b0}/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.8.4.3b0/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.8.4.3b0/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>

fmu_manipulation_toolbox-1.8.4.3b0/fmu_manipulation_toolbox/resources/fmi-3.0/fmi3AttributeGroups.xsd

@@ -0,0 +1,119 @@
+<?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:attributeGroup name="fmi3RealBaseAttributes">
+        <xs:attribute name="quantity" type="xs:normalizedString"/>
+        <xs:attribute name="unit" type="xs:normalizedString"/>
+        <xs:attribute name="displayUnit" type="xs:normalizedString"/>
+        <xs:attribute name="relativeQuantity" type="xs:boolean" default="false"/>
+        <xs:attribute name="unbounded" type="xs:boolean" default="false"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3Float64Attributes">
+        <xs:attribute name="min" type="xs:double"/>
+        <xs:attribute name="max" type="xs:double"/>
+        <xs:attribute name="nominal" type="xs:double"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3Float32Attributes">
+        <xs:attribute name="min" type="xs:float"/>
+        <xs:attribute name="max" type="xs:float"/>
+        <xs:attribute name="nominal" type="xs:float"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3IntegerBaseAttributes">
+        <xs:attribute name="quantity" type="xs:normalizedString"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3Int8Attributes">
+        <xs:attribute name="min" type="xs:byte"/>
+        <xs:attribute name="max" type="xs:byte"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3UInt8Attributes">
+        <xs:attribute name="min" type="xs:unsignedByte"/>
+        <xs:attribute name="max" type="xs:unsignedByte"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3Int16Attributes">
+        <xs:attribute name="min" type="xs:short"/>
+        <xs:attribute name="max" type="xs:short"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3UInt16Attributes">
+        <xs:attribute name="min" type="xs:unsignedShort"/>
+        <xs:attribute name="max" type="xs:unsignedShort"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3Int32Attributes">
+        <xs:attribute name="min" type="xs:int"/>
+        <xs:attribute name="max" type="xs:int"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3UInt32Attributes">
+        <xs:attribute name="min" type="xs:unsignedInt"/>
+        <xs:attribute name="max" type="xs:unsignedInt"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3Int64Attributes">
+        <xs:attribute name="min" type="xs:long"/>
+        <xs:attribute name="max" type="xs:long"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3UInt64Attributes">
+        <xs:attribute name="min" type="xs:unsignedLong"/>
+        <xs:attribute name="max" type="xs:unsignedLong"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3RealVariableAttributes">
+        <xs:attribute name="derivative" type="xs:unsignedInt"/>
+        <xs:attribute name="reinit" type="xs:boolean" default="false"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3EnumerationAttributes">
+        <xs:attribute name="min" type="xs:long"/>
+        <xs:attribute name="max" type="xs:long"/>
+    </xs:attributeGroup>
+    <xs:attributeGroup name="fmi3ClockAttributes">
+        <xs:attribute name="canBeDeactivated" type="xs:boolean" default="false"/>
+        <xs:attribute name="priority" type="xs:unsignedInt" use="optional"/>
+        <xs:attribute name="intervalVariability" use="required">
+            <xs:simpleType>
+                <xs:restriction base="xs:normalizedString">
+                    <xs:enumeration value="constant"/>
+                    <xs:enumeration value="fixed"/>
+                    <xs:enumeration value="tunable"/>
+                    <xs:enumeration value="changing"/>
+                    <xs:enumeration value="countdown"/>
+                    <xs:enumeration value="triggered"/>
+                </xs:restriction>
+            </xs:simpleType>
+        </xs:attribute>
+        <xs:attribute name="intervalDecimal" type="xs:double" use="optional"/>
+        <xs:attribute name="shiftDecimal" type="xs:double" default="0"/>
+        <xs:attribute name="supportsFraction" type="xs:boolean" default="false"/>
+        <xs:attribute name="resolution" type="xs:unsignedLong" use="optional"/>
+        <xs:attribute name="intervalCounter" type="xs:unsignedLong" use="optional"/>
+        <xs:attribute name="shiftCounter" type="xs:unsignedLong" default="0"/>
+    </xs:attributeGroup>
+</xs:schema>