Unify the iterators of the data vectors

luxtronik/cfi/interface.py

@@ -162,20 +162,20 @@ def _write_and_read(self, parameters, data):
         return self._read(data)
 
     def _write(self, parameters):
-        for index, field in parameters.data.items():
+        for definition, field in parameters.items():
             if field.write_pending:
                 field.write_pending = False
                 value = field.raw
-                if not isinstance(index, int) or not field.check_for_write(parameters.safe):
+                if not isinstance(definition.index, int) or not field.check_for_write(parameters.safe):
                     LOGGER.warning(
                         "%s: Parameter id '%s' or value '%s' invalid!",
                         self._host,
-                        index,
+                        definition.index,
                         value,
                     )
                     continue
-                LOGGER.info("%s: Parameter '%d' set to '%s'", self._host, index, value)
-                self._send_ints(LUXTRONIK_PARAMETERS_WRITE, index, value)
+                LOGGER.info("%s: Parameter '%d' set to '%s'", self._host, definition.index, value)
+                self._send_ints(LUXTRONIK_PARAMETERS_WRITE, definition.index, value)
                 cmd = self._read_int()
                 LOGGER.debug("%s: Command %s", self._host, cmd)
                 val = self._read_int()
@@ -275,7 +275,7 @@ def _parse(self, data_vector, raw_data):
         undefined = {i for i in range(0, raw_len)}
 
         # integrate the data into the fields
-        for pair in data_vector.data.pairs():
+        for pair in data_vector.data.items():
             definition, field = pair
             # skip this field if there are not enough data
             next_idx = definition.index + definition.count

luxtronik/collections.py

@@ -205,8 +205,7 @@ def integrate_data(self, raw_data, num_bits, data_offset=-1):
 
 class LuxtronikFieldsDictionary:
     """
-    Dictionary that behaves like the earlier data vector dictionaries (index-field-dictionary),
-    with the addition that obsolete fields are also supported and can be addressed by name.
+    Dictionary that maps definitions, names or indices to added fields.
     Aliases are also supported.
     """
 
@@ -228,15 +227,12 @@ def __getitem__(self, def_field_name_or_idx):
         return self.get(def_field_name_or_idx)
 
     def __len__(self):
-        return len(self._def_lookup._index_dict)
+        """Return the number of added fields."""
+        return len(self._pairs)
 
     def __iter__(self):
-        """
-        Iterate over all non-obsolete indices. If an index is assigned multiple times,
-        only the index of the preferred definition will be output.
-        """
-        all_related_defs = self._def_lookup._index_dict.values()
-        return iter([d.index for d in self._pairs if d in all_related_defs])
+        """Return the iterator over all definitions related to the added fields."""
+        return iter([d for d, _ in self._pairs])
 
     def __contains__(self, def_field_name_or_idx):
         """
@@ -265,26 +261,16 @@ def __contains__(self, def_field_name_or_idx):
             return def_field_name_or_idx in self._def_lookup
 
     def values(self):
-        """
-        Iterator for all added non-obsolete fields. If an index is assigned multiple times,
-        only the field of the preferred definition will be output.
-        """
-        all_related_defs = self._def_lookup._index_dict.values()
-        return iter([f for d, f in self._pairs if d in all_related_defs])
+        """Return the iterator over all added fields."""
+        return iter([f for _, f in self._pairs])
 
     def items(self):
-        """
-        Iterator for all non-obsolete index-field-pairs (list of tuples with
-        0: index, 1: field) contained herein. If an index is assigned multiple times,
-        only the index-field-pair of the preferred definition will be output.
-        """
-        all_related_defs = self._def_lookup._index_dict.values()
-        return iter([(d.index, f) for d, f in self._pairs if d in all_related_defs])
+        """Return the iterator over all added definition-field-pairs."""
+        return iter(self._pairs)
 
+    @property
     def pairs(self):
-        """
-        Return all definition-field-pairs contained herein.
-        """
+        """Return all definition-field-pairs contained herein."""
         return self._pairs
 
     @property

luxtronik/data_vector.py

@@ -29,10 +29,6 @@ def __init__(self):
         """Initialize DataVector class."""
         self._data = LuxtronikFieldsDictionary()
 
-    def __iter__(self):
-        """Iterator for the data entries."""
-        return iter(self._data.items())
-
     @property
     def data(self):
         """
@@ -55,6 +51,19 @@ def __setitem__(self, def_name_or_idx, value):
         """
         return self.set(def_name_or_idx, value)
 
+    def __len__(self):
+        """
+        Forward the `LuxtronikFieldsDictionary.__len__` method.
+        Please check its documentation.
+        """
+        return len(self._data)
+
+    def __iter__(self):
+        """
+        Forward the `LuxtronikFieldsDictionary.__iter__` method.
+        Please check its documentation.
+        """
+        return iter(self._data)
 
     def __contains__(self, def_field_name_or_idx):
         """
@@ -63,6 +72,20 @@ def __contains__(self, def_field_name_or_idx):
         """
         return def_field_name_or_idx in self._data
 
+    def values(self):
+        """
+        Forward the `LuxtronikFieldsDictionary.values` method.
+        Please check its documentation.
+        """
+        return self._data.values()
+
+    def items(self):
+        """
+        Forward the `LuxtronikFieldsDictionary.items` method.
+        Please check its documentation.
+        """
+        return iter(self._data.items())
+
     def _name_lookup(self, name):
         """
         Try to find the index using the given field name.
@@ -78,12 +101,12 @@ def _name_lookup(self, name):
         obsolete_entry = self._obsolete.get(name, None)
         if obsolete_entry:
             return None, obsolete_entry
-        for index, entry in self._data.items():
-            check_result = entry.check_name(name)
+        for definition, field in self._data.items():
+            check_result = field.check_name(name)
             if check_result == LUXTRONIK_NAME_CHECK_PREFERRED:
-                return index, None
+                return definition.index, None
             elif check_result == LUXTRONIK_NAME_CHECK_OBSOLETE:
-                return index, entry.name
+                return definition.index, field.name
         return None, None
 
     def _lookup(self, target, with_index=False):

luxtronik/scripts/__init__.py

@@ -25,8 +25,8 @@ def print_dump_row(number, field):
 
 def dump_fields(data_vector):
     print_dump_header(f"{data_vector.name}s")
-    for index, field in data_vector.data.items():
-        print_dump_row(index, field)
+    for definition, field in data_vector.data.items():
+        print_dump_row(definition.index, field)
 
 def print_watch_header(screen, caption):
     cols, _ = screen.get_visible_size()
@@ -41,11 +41,11 @@ def get_watch_row(short_name, number, prev_field, this_field):
     return text
 
 def update_changes(changes, prev_data_vector, this_data_vector):
-    for index, this_field in this_data_vector.data.items():
+    for definition, this_field in this_data_vector.data.items():
         short_name = this_data_vector.name[:4]
-        key = f"{short_name}_{str(index).zfill(5)}"
-        prev_field = prev_data_vector.get(index)
+        key = f"{short_name}_{str(definition.index).zfill(5)}"
+        prev_field = prev_data_vector.get(definition.name)
         if this_field.raw != prev_field.raw:
-            changes[key] = get_watch_row(short_name, index, prev_field, this_field)
+            changes[key] = get_watch_row(short_name, definition.index, prev_field, this_field)
         elif key in changes:
-            changes[key] = get_watch_row(short_name, index, prev_field, None)
+            changes[key] = get_watch_row(short_name, definition.index, prev_field, None)

luxtronik/shi/interface.py

@@ -469,12 +469,12 @@ def _collect_fields(self, blocks_list, data_vector, definitions, read_not_write)
             # Trial-and-error mode: Add a block for every field
             blocks = ContiguousDataBlockList(definitions.name, read_not_write)
             if (read_not_write == READ):
-                for definition, field in data_vector.data.pairs():
+                for definition, field in data_vector.data.items():
                     # _prepare_read_field will never fail, no need to call it
                     #if self._prepare_read_field(definition, field):
                     blocks.append_single(definition, field)
             else:
-                for definition, field in data_vector.data.pairs():
+                for definition, field in data_vector.data.items():
                     if self._prepare_write_field(definition, field, data_vector.safe, None):
                         blocks.append_single(definition, field)
             if len(blocks) > 0:
@@ -488,7 +488,7 @@ def _collect_fields(self, blocks_list, data_vector, definitions, read_not_write)
             else:
                 blocks = ContiguousDataBlockList(definitions.name, read_not_write)
                 # Organize data into contiguous blocks
-                for definition, field in data_vector.data.pairs():
+                for definition, field in data_vector.data.items():
                     if self._prepare_write_field(definition, field, data_vector.safe, None):
                         blocks.collect(definition, field)
                 if len(blocks) > 0:

luxtronik/shi/vector.py

@@ -143,25 +143,13 @@ def empty(cls, version=LUXTRONIK_LATEST_SHI_VERSION, safe=True):
         obj._init_instance(version, safe)
         return obj
 
-    def __len__(self):
-        return len(self._data.pairs())
-
-    def __iter__(self):
-        return iter([definition for definition, _ in self._data.pairs()])
-
 
 # properties and access methods ###############################################
 
     @property
     def version(self):
         return self._version
 
-    def values(self):
-        return iter([field for _, field in self._data.pairs()])
-
-    def items(self):
-        return iter(self._data.pairs())
-
 
 # Find, add and alias methods #################################################
 
@@ -265,7 +253,7 @@ def update_read_blocks(self):
         """
         if not self._read_blocks_up_to_date:
             self._read_blocks.clear()
-            for definition, field in self._data.pairs():
+            for definition, field in self._data.pairs:
                 self._read_blocks.collect(definition, field)
         self._read_blocks_up_to_date = True
 

tests/cfi/test_cfi_calculations.py

@@ -4,6 +4,7 @@
 
 from luxtronik import Calculations
 from luxtronik.datatypes import Base
+from luxtronik.definitions import LuxtronikDefinition
 
 
 class TestCalculations:
@@ -23,10 +24,10 @@ def test_data(self):
         # The Value must be a fields
         # The key can be an index
         assert isinstance(data[0], Base)
-        for k in data:
-            assert isinstance(k, int)
+        for d in data:
+            assert isinstance(d, LuxtronikDefinition)
         for v in data.values():
             assert isinstance(v, Base)
-        for k, v in data.items():
-            assert isinstance(k, int)
+        for d, v in data.items():
+            assert isinstance(d, LuxtronikDefinition)
             assert isinstance(v, Base)

tests/cfi/test_cfi_interface.py

@@ -46,7 +46,7 @@ def test_parse(self):
         parameters[20].write_pending = True
         parameters[40].write_pending = True
         lux._parse(parameters, t)
-        for definition, field in parameters.data.pairs():
+        for definition, field in parameters.data.items():
             if definition.index > n:
                 assert field.raw is None
             assert not field.write_pending
@@ -55,7 +55,7 @@ def test_parse(self):
         calculations[20].write_pending = True
         calculations[40].write_pending = True
         lux._parse(calculations, t)
-        for definition, field in calculations.data.pairs():
+        for definition, field in calculations.data.items():
             if definition.index > n:
                 assert field.raw is None
             assert not field.write_pending
@@ -64,7 +64,7 @@ def test_parse(self):
         visibilities[20].write_pending = True
         visibilities[40].write_pending = True
         lux._parse(visibilities, t)
-        for definition, field in visibilities.data.pairs():
+        for definition, field in visibilities.data.items():
             if definition.index > n:
                 assert field.raw is None
             assert not field.write_pending

tests/cfi/test_cfi_parameters.py

@@ -4,6 +4,7 @@
 
 from luxtronik import Parameters
 from luxtronik.datatypes import Base
+from luxtronik.definitions import LuxtronikDefinition
 
 
 class TestParameters:
@@ -27,12 +28,12 @@ def test_data(self):
         # The Value must be a fields
         # The key can be an index
         assert isinstance(data[0], Base)
-        for k in data:
-            assert isinstance(k, int)
+        for d in data:
+            assert isinstance(d, LuxtronikDefinition)
         for v in data.values():
             assert isinstance(v, Base)
-        for k, v in data.items():
-            assert isinstance(k, int)
+        for d, v in data.items():
+            assert isinstance(d, LuxtronikDefinition)
             assert isinstance(v, Base)
 
     def test_get(self):
@@ -68,11 +69,15 @@ def test___iter__(self):
         """Test cases for __iter__"""
         parameters = Parameters()
 
-        for i, p in parameters:
-            if i == 0:
+        for d, p in parameters.items():
+            if d.index == 0:
                 assert p.name == "ID_Transfert_LuxNet"
-            elif i == 1:
+                assert d is parameters.data.def_dict.get(0)
+                assert p is parameters.get(0)
+            elif d.index == 1:
                 assert p.name == "ID_Einst_WK_akt"
+                assert d is parameters.data.def_dict.get(1)
+                assert p is parameters.get(1)
             else:
                 break
 

tests/cfi/test_cfi_visibilities.py

@@ -4,6 +4,7 @@
 
 from luxtronik import Visibilities
 from luxtronik.datatypes import Base
+from luxtronik.definitions import LuxtronikDefinition
 
 
 class TestVisibilities:
@@ -23,10 +24,10 @@ def test_data(self):
         # The Value must be a fields
         # The key can be an index
         assert isinstance(data[0], Base)
-        for k in data:
-            assert isinstance(k, int)
+        for d in data:
+            assert isinstance(d, LuxtronikDefinition)
         for v in data.values():
             assert isinstance(v, Base)
-        for k, v in data.items():
-            assert isinstance(k, int)
+        for d, v in data.items():
+            assert isinstance(d, LuxtronikDefinition)
             assert isinstance(v, Base)

tests/fake/fake_luxtronik.py

@@ -5,9 +5,9 @@ class FakeLuxtronik(Luxtronik):
 
     def __init__(self):
         LuxtronikAllData.__init__(self)
-        for idx, field in self.parameters:
-            field.raw = idx
-        for idx, field in self.calculations:
-            field.raw = idx
-        for idx, field in self.visibilities:
-            field.raw = idx
+        for definition, field in self.parameters.items():
+            field.raw = definition.index
+        for definition, field in self.calculations.items():
+            field.raw = definition.index
+        for definition, field in self.visibilities.items():
+            field.raw = definition.index