Fix: Types for nested attributes

Author: jmhorcas

flamapy/metamodels/fm_metamodel/models/feature_model.py

@@ -104,6 +104,7 @@ class AttributeType(Enum):
     INTEGER = 'Integer'
     REAL = 'Real'
     STRING = 'String'
+    VECTOR = 'Vector'  # Vector (list of values)
     NESTED = 'Nested'  # Nested attribute (i.e., list of attributes)
 
 
@@ -410,10 +411,15 @@ def get_features(self) -> list["Feature"]:
         return features
 
     def get_attributes(self) -> list["Attribute"]:
-        attributes: set["Attribute"] = set()
+        attributes_dict: dict[str, "Attribute"] = {}
         for feature in self.get_features():
-            attributes.update(feature.get_attributes())
-        return list(attributes)
+            attributes_dict.update({attr.name: attr for attr in feature.get_attributes()})
+        attributes = []
+        for attr in attributes_dict.values():
+            attribute = Attribute(attr.name, attr.domain, None, attr.null_value)
+            attribute.attribute_type = attr.attribute_type
+            attributes.append(attribute)
+        return attributes
 
     def get_attribute_by_name(self, attribute_name: str) -> Optional["Attribute"]:
         return next((a for a in self.get_attributes() if a.name == attribute_name), None)
@@ -598,9 +604,9 @@ def _infer_attribute_type(self, value: Any) -> Optional["AttributeType"]:
         elif isinstance(value, str):
             attr_type = AttributeType.STRING
         elif isinstance(value, list):
-            attr_type = AttributeType.NESTED
+            attr_type = AttributeType.VECTOR
         else:
-            attr_type = None
+            attr_type = AttributeType.NESTED
         return attr_type
 
     def get_name(self) -> str:

flamapy/metamodels/fm_metamodel/transformations/uvl_reader.py

@@ -183,27 +183,34 @@ def _check_attributes(
                     feature.is_abstract = True
                 else:
                     # Handle attributes
-                    if isinstance(value, dict):  # it represents nested attributes
-                        attributes_list = self._process_nested_attribute(feature, value)
+                    if value is None:  # for boolean values the value may be not provided
+                        default_value = True
+                    elif isinstance(value, dict):  # it represents nested attributes
+                        attributes_list = self._process_nested_attribute(feature, key, value)
                         for attr in attributes_list:
                             feature.add_attribute(attr)
+                        default_value = None
                     else:
                         default_value = value
                     feature.add_attribute(Attribute(name=str(key), default_value=default_value))
         feature.constraints_attributes = self.constraints_attributes[feature]
 
     def _process_nested_attribute(self,
                                   parent: Feature,
+                                  parent_attribute_name: str,
                                   nested_values: dict[Any, Any]) -> list[Attribute]:
         attributes = []
         for key, value in nested_values.items():
-            if isinstance(value, dict):
-                attributes_list = self._process_nested_attribute(parent, value)
+            if value is None:  # for boolean values the value may be not provided
+                default_value = True
+            elif isinstance(value, dict):
+                attributes_list = self._process_nested_attribute(parent, f'{parent_attribute_name}.{key}', value)
                 for attr in attributes_list:
                     attributes.append(attr)
+                    default_value = None
             else:
                 default_value = value
-            attribute = Attribute(name=str(key), default_value=default_value)
+            attribute = Attribute(name=f'{parent_attribute_name}.{key}', default_value=default_value)
             attribute.parent = parent
             attributes.append(attribute)
         return attributes