remove ModelVariables class, update dimension, uprev to 0.3.0rc0 (#7)

Author: ticoder00

.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.2.1rc0"
+current_version = "0.3.0rc0"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mdreader"
-version = "0.2.1rc0"
+version = "0.3.0rc0"
 description = "A Python library for reading and parsing Functional Mock-up Interface model description XML file."
 readme = "README.md"
 authors = [

src/mdreader/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.1rc0"
+__version__ = "0.3.0rc0"

src/mdreader/fmi2.py

@@ -44,7 +44,6 @@
     "StringVariable",
     "EnumerationVariable",
     "ScalarVariable",
-    "ModelVariables",
     "UnitDefinitions",
     "TypeDefinitions",
     "FmiModelDescription",
@@ -1489,22 +1488,6 @@ def to_xml(self) -> Element:
         return element
 
 
-class ModelVariables(BaseModel):
-    """Model variables list"""
-
-    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
-
-    variables: Annotated[list[ScalarVariable], Field(..., alias="ScalarVariable")]
-
-    def to_xml(self) -> Element:
-        """Convert ModelVariables to XML Element"""
-        element = Element("ModelVariables")
-        if self.variables is not None:
-            for variable in self.variables:
-                element.append(variable.to_xml())
-        return element
-
-
 class UnitDefinitions(BaseModel):
     """Unit definitions list"""
 
@@ -1696,7 +1679,7 @@ class FmiModelDescription(BaseModel):
         ),
     ] = None
     model_variables: Annotated[
-        ModelVariables,
+        list[ScalarVariable],
         Field(
             ...,
             alias="ModelVariables",
@@ -1758,7 +1741,10 @@ def to_xml(self) -> Element:
         if self.vendor_annotations is not None:
             element.append(self.vendor_annotations.to_xml())
         if self.model_variables is not None:
-            element.append(self.model_variables.to_xml())
+            model_vars_elem = Element("ModelVariables")
+            for variable in self.model_variables:
+                model_vars_elem.append(variable.to_xml())
+            element.append(model_vars_elem)
         if self.model_structure is not None:
             element.append(self.model_structure.to_xml())
 
@@ -2213,13 +2199,13 @@ def _parse_vendor_annotations(elem: Element) -> Annotation:
     return Annotation(tools=tools)
 
 
-def _parse_model_variables(elem: Element) -> ModelVariables:
-    """Parse ModelVariables element"""
+def _parse_model_variables(elem: Element) -> list[ScalarVariable]:
+    """Parse ModelVariables element into a flat list"""
     variables = []
     for variable_elem in elem.findall("ScalarVariable"):
         variable = _parse_scalar_variable(variable_elem)
         variables.append(variable)
-    return ModelVariables(variables=variables)
+    return variables
 
 
 def _parse_scalar_variable(elem: Element) -> ScalarVariable:

src/mdreader/fmi3.py

@@ -65,7 +65,6 @@
     "EnumerationVariable",
     "ClockVariable",
     "Variable",
-    "ModelVariables",
     "UnitDefinitions",
     "TypeDefinitions",
     "FmiModelDescription",
@@ -786,7 +785,7 @@ class Annotation(BaseModel):
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
-    tools: Annotated[list[Tool], Field(..., alias="Tool")]
+    tools: Annotated[list[Tool] | None, Field(default=None, alias="Tool")] = None
 
     def to_xml(self) -> Element:
         """Convert Annotation to XML Element"""
@@ -802,11 +801,20 @@ class Dimension(BaseModel):
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
-    start: Annotated[int | None, Field(default=None, alias="start")]
+    start: Annotated[int | None, Field(default=None, alias="start")] = None
     value_reference: Annotated[
         int | None, Field(default=None, alias="valueReference")
     ] = None
 
+    @model_validator(mode="after")
+    def _validate_exclusive_start_or_value_reference(self) -> "Dimension":
+        """Ensure exactly one of start or value_reference is provided."""
+        if (self.start is None) == (self.value_reference is None):
+            raise ValueError(
+                "Dimension: exactly one of start or valueReference must be set"
+            )
+        return self
+
     def to_xml(self) -> Element:
         """Convert Dimension to XML Element"""
         element = Element("Dimension")
@@ -3113,7 +3121,7 @@ class Variable(BaseModel):
         Field(default=None, alias="Clock", description="Clock variable definition"),
     ] = None
 
-    def get_variable_type(self):
+    def get_variable_type(self) -> str | None:
         """Get the type of variable based on which field is set"""
         if self.float32 is not None:
             return "Float32"
@@ -3147,6 +3155,91 @@ def get_variable_type(self):
             return "Clock"
         return None
 
+    def _concrete(
+        self,
+    ) -> (
+        Float32Variable
+        | Float64Variable
+        | Int8Variable
+        | Int16Variable
+        | Int32Variable
+        | Int64Variable
+        | UInt8Variable
+        | UInt16Variable
+        | UInt32Variable
+        | UInt64Variable
+        | BooleanVariable
+        | StringVariable
+        | BinaryVariable
+        | EnumerationVariable
+        | ClockVariable
+    ):
+        """Return the underlying concrete variable instance or raise if unset."""
+        for attr in (
+            "float32",
+            "float64",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64",
+            "boolean",
+            "string",
+            "binary",
+            "enumeration",
+            "clock",
+        ):
+            value = getattr(self, attr)
+            if value is not None:
+                return value
+        raise ValueError("No variable type is set")
+
+    @property
+    def concrete(
+        self,
+    ) -> (
+        Float32Variable
+        | Float64Variable
+        | Int8Variable
+        | Int16Variable
+        | Int32Variable
+        | Int64Variable
+        | UInt8Variable
+        | UInt16Variable
+        | UInt32Variable
+        | UInt64Variable
+        | BooleanVariable
+        | StringVariable
+        | BinaryVariable
+        | EnumerationVariable
+        | ClockVariable
+    ):
+        """Direct access to the concrete variable instance."""
+        return self._concrete()
+
+    @property
+    def name(self) -> str:
+        return self.concrete.name
+
+    @property
+    def value_reference(self) -> int:
+        return self.concrete.value_reference
+
+    @property
+    def causality(self) -> CausalityEnum | None:
+        return getattr(self.concrete, "causality", None)
+
+    @property
+    def variability(self) -> VariabilityEnum | None:
+        return getattr(self.concrete, "variability", None)
+
+    @property
+    def initial(self) -> InitialEnum | None:
+        return getattr(self.concrete, "initial", None)
+
     def to_xml(self) -> Element:
         """Convert Variable to XML Element"""
         # Add the appropriate variable type element
@@ -3184,22 +3277,6 @@ def to_xml(self) -> Element:
             raise ValueError("No variable type is set")
 
 
-class ModelVariables(BaseModel):
-    """Model variables list for FMI 3.0"""
-
-    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
-
-    variables: Annotated[list[Variable], Field(..., alias="Variable")]
-
-    def to_xml(self) -> Element:
-        """Convert ModelVariables to XML Element"""
-        element = Element("ModelVariables")
-        if self.variables is not None:
-            for variable in self.variables:
-                element.append(variable.to_xml())
-        return element
-
-
 class UnitDefinitions(BaseModel):
     """Unit definitions list for FMI 3.0"""
 
@@ -3391,7 +3468,7 @@ class FmiModelDescription(BaseModel):
         ),
     ] = None
     model_variables: Annotated[
-        ModelVariables,
+        list[Variable],
         Field(
             ...,
             alias="ModelVariables",
@@ -3453,7 +3530,10 @@ def to_xml(self) -> Element:
         if self.vendor_annotations is not None:
             element.append(self.vendor_annotations.to_xml())
         if self.model_variables is not None:
-            element.append(self.model_variables.to_xml())
+            model_vars_elem = Element("ModelVariables")
+            for variable in self.model_variables:
+                model_vars_elem.append(variable.to_xml())
+            element.append(model_vars_elem)
         if self.model_structure is not None:
             element.append(self.model_structure.to_xml())
 
@@ -5182,8 +5262,8 @@ def _parse_dimensions(elem: Element) -> list[Dimension] | None:
     return dims or None
 
 
-def _parse_model_variables(elem: Element) -> ModelVariables:
-    """Parse ModelVariables element"""
+def _parse_model_variables(elem: Element) -> list[Variable]:
+    """Parse ModelVariables element into a flat list"""
     variables = []
     # Find all variable types in the model variables section
     for var_type in [
@@ -5206,7 +5286,7 @@ def _parse_model_variables(elem: Element) -> ModelVariables:
         for variable_elem in elem.findall(var_type):
             variable = _parse_variable(variable_elem, var_type)
             variables.append(variable)
-    return ModelVariables(variables=variables)
+    return variables
 
 
 def _parse_variable(elem: Element, var_type: str) -> Variable:

tests/test_fmi2.py

@@ -175,12 +175,8 @@ def test_scarlar_variables(
 ):
     filename = (reference_fmus_dir / reference_fmu).absolute()
     md = read_model_description(filename)
-    input_vars = [
-        var.name for var in md.model_variables.variables if var.causality == "input"
-    ]
-    output_vars = [
-        var.name for var in md.model_variables.variables if var.causality == "output"
-    ]
+    input_vars = [var.name for var in md.model_variables if var.causality == "input"]
+    output_vars = [var.name for var in md.model_variables if var.causality == "output"]
     assert sorted(input_vars) == sorted(expected_inputs)
     assert sorted(output_vars) == sorted(expected_outputs)
 
@@ -411,7 +407,7 @@ def test_variable_properties(reference_fmu, expected_variables, reference_fmus_d
     md = read_model_description(filename)
 
     # Create a mapping of variable names to variables for easy lookup
-    var_map = {var.name: var for var in md.model_variables.variables}
+    var_map = {var.name: var for var in md.model_variables}
 
     for expected_var in expected_variables:
         var_name = expected_var["name"]
@@ -877,7 +873,6 @@ def test_xml_serialization():
     """Test the to_xml() methods for all model classes"""
     from mdreader.fmi2 import (
         FmiModelDescription,
-        ModelVariables,
         ScalarVariable,
         RealVariable,
         CausalityEnum,
@@ -1165,11 +1160,8 @@ def test_xml_serialization():
     assert scalar_var_xml.get("variability") == "continuous"
     assert len(scalar_var_xml) == 2  # Real element and Annotations element
 
-    # Test ModelVariables to_xml
-    model_vars = ModelVariables(variables=[scalar_var])
-    model_vars_xml = model_vars.to_xml()
-    assert model_vars_xml.tag == "ModelVariables"
-    assert len(model_vars_xml) == 1
+    # Collect model variables as a flat list
+    model_vars = [scalar_var]
 
     # Test UnitDefinitions to_xml
     from mdreader.fmi2 import UnitDefinitions
@@ -1221,7 +1213,6 @@ def test_xml_serialization_roundtrip():
     """Test that XML serialization and deserialization work correctly"""
     from mdreader.fmi2 import (
         FmiModelDescription,
-        ModelVariables,
         ScalarVariable,
         RealVariable,
         CausalityEnum,
@@ -1239,12 +1230,11 @@ def test_xml_serialization_roundtrip():
         variability=VariabilityEnum.continuous,
         real=real_var,
     )
-    model_vars = ModelVariables(variables=[scalar_var])
     model_desc = FmiModelDescription(
         fmi_version="2.0",
         model_name="TestModel",
         guid="{12345678-1234-5678-9012-123456789012}",
-        model_variables=model_vars,
+        model_variables=[scalar_var],
     )
 
     # Convert to XML
@@ -1309,14 +1299,12 @@ def test_xml_serialization_roundtrip_with_reference_fmus(
     )
 
     # Compare variable counts
-    assert len(original_md.model_variables.variables) == len(
-        reconstructed_md.model_variables.variables
-    )
+    assert len(original_md.model_variables) == len(reconstructed_md.model_variables)
 
     # Compare some variable properties
     for orig_var, recon_var in zip(
-        original_md.model_variables.variables,
-        reconstructed_md.model_variables.variables,
+        original_md.model_variables,
+        reconstructed_md.model_variables,
     ):
         assert orig_var.name == recon_var.name
         assert orig_var.value_reference == recon_var.value_reference