Use dir() instead of vars() in Referable.update_from() (#338)

Previously, we used `vars()` to iterate over all attributes of an object
when updating it from another object (`Referable.update_from()`).

However, `vars()` only retrieves the instance's `__dict__`, e.g. the 
object's attributes, but does not include properties. As a result, when 
you use `vars(other)`, you get the `_id_short` attribute instead of the 
`id_short` property.

This made it impossible to utilize custom setter methods we developed
for certain cases, e.g. when properties should be immutable.

This now adapts the `Referable.update_from()` method to utilize `dir()`
instead, which iterates over all attributes and properties of the 
object. We skip callables and private attributes. We use `setattr()` to 
set attributes and properties, so that the correct setter methods will 
be used.

Furthermore, we now raise an error if an immutable property changed 
between the two versions of the object.

Fixes #215 

---------

Co-authored-by: Sercan Sahin <[email protected]>

Author: zrgt

sdk/basyx/aas/model/base.py

@@ -802,7 +802,7 @@ def find_source(self) -> Tuple[Optional["Referable"], Optional[List[str]]]:  # t
 
     def update_from(self, other: "Referable", update_source: bool = False):
         """
-        Internal function to updates the object's attributes from another object of a similar type.
+        Internal function to update the object's attributes from a different version of the exact same object.
 
         This function should not be used directly. It is typically used by backend implementations (database adapters,
         protocol clients, etc.) to update the object's data, after ``update()`` has been called.
@@ -811,15 +811,31 @@ def update_from(self, other: "Referable", update_source: bool = False):
         :param update_source: Update the source attribute with the other's source attribute. This is not propagated
                               recursively
         """
-        for name, var in vars(other).items():
-            # do not update the parent, namespace_element_sets or source (depending on update_source parameter)
-            if name in ("parent", "namespace_element_sets") or name == "source" and not update_source:
+        for name in dir(other):
+            # Skip private and protected attributes
+            if name.startswith('_'):
                 continue
-            if isinstance(var, NamespaceSet):
+
+            # Do not update 'parent', 'namespace_element_sets', or 'source' (depending on update_source parameter)
+            if name in ("parent", "namespace_element_sets") or (name == "source" and not update_source):
+                continue
+
+            # Skip methods
+            attr = getattr(other, name)
+            if callable(attr):
+                continue
+
+            if isinstance(attr, NamespaceSet):
                 # update the elements of the NameSpaceSet
-                vars(self)[name].update_nss_from(var)
+                getattr(self, name).update_nss_from(attr)
             else:
-                vars(self)[name] = var  # that variable is not a NameSpaceSet, so it isn't Referable
+                # Check if this is a property and if it has no setter
+                prop = getattr(type(self), name, None)
+                if isinstance(prop, property) and prop.fset is None:
+                    if getattr(self, name) != attr:
+                        raise ValueError(f"property {name} is immutable but has changed between versions of the object")
+                else:
+                    setattr(self, name, attr)
 
     def commit(self) -> None:
         """