odxtools 5.3.1__py3-none-any.whl → 6.0.1__py3-none-any.whl

odxtools/minmaxlengthtype.py

@@ -1,12 +1,12 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import Optional, Tuple
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert
-from .odxtypes import DataType
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise
+from .odxtypes import AtomicOdxType, DataType
 
 
 @dataclass
@@ -15,7 +15,7 @@ class MinMaxLengthType(DiagCodedType):
     max_length: Optional[int]
     termination: str
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         odxassert(self.max_length is None or self.min_length <= self.max_length)
         odxassert(
             self.base_data_type in [
@@ -34,113 +34,142 @@ class MinMaxLengthType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "MIN-MAX-LENGTH-TYPE"
 
-    def __termination_character(self):
-        """Returns the termination character or None if it isn't defined."""
-        # The termination character is actually not specified by ASAM
+    def __termination_sequence(self) -> bytes:
+        """Returns the termination byte sequence if it isn't defined."""
+        # The termination sequence is actually not specified by ASAM
         # for A_BYTEFIELD but I assume it is only one byte.
-        termination_char = None
+        termination_sequence = b''
         if self.termination == "ZERO":
             if self.base_data_type not in [DataType.A_UNICODE2STRING]:
-                termination_char = bytes([0x0])
+                termination_sequence = bytes([0x0])
             else:
-                termination_char = bytes([0x0, 0x0])
+                termination_sequence = bytes([0x0, 0x0])
         elif self.termination == "HEX-FF":
             if self.base_data_type not in [DataType.A_UNICODE2STRING]:
-                termination_char = bytes([0xFF])
+                termination_sequence = bytes([0xFF])
             else:
-                termination_char = bytes([0xFF, 0xFF])
-        return termination_char
+                termination_sequence = bytes([0xFF, 0xFF])
+        return termination_sequence
 
-    def convert_internal_to_bytes(self, internal_value, encode_state: EncodeState,
+    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
                                   bit_position: int) -> bytes:
-        byte_length = self._minimal_byte_length_of(internal_value)
-
-        # The coded value must have at least length min_length
-        if byte_length < self.min_length:
-            raise EncodeError(f"The internal value {internal_value} is only {byte_length} bytes"
-                              f" long but the min length is {self.min_length}")
-        # The coded value must not have a length greater than max_length
-        if self.max_length and byte_length > self.max_length:
-            raise EncodeError(f"The internal value {internal_value} requires {byte_length}"
-                              f" bytes, but the max length is {self.max_length}")
-
-        value_byte = self._to_bytes(
-            internal_value,
-            bit_position=0,
-            bit_length=8 * byte_length,
-            base_data_type=self.base_data_type,
-            is_highlow_byte_order=self.is_highlow_byte_order,
-        )
-
-        if encode_state.is_end_of_pdu or byte_length == self.max_length:
-            # All termination types may be ended by the PDU
-            return value_byte
+        if not isinstance(internal_value, (bytes, str)):
+            odxraise("MinMaxLengthType is currently only implemented for strings and byte arrays",
+                     EncodeError)
+
+        if self.max_length is not None:
+            data_length = min(len(internal_value), self.max_length)
         else:
-            termination_char = self.__termination_character()
-            if self.termination == "END-OF-PDU":
-                termination_char = bytes()
-            odxassert(
-                termination_char is not None,
-                f"MinMaxLengthType with termination {self.termination}"
-                f"(min: {self.min_length}, max: {self.max_length}) failed encoding {internal_value}"
-            )
-            return value_byte + termination_char
+            data_length = len(internal_value)
+
+        value_bytes = bytearray(
+            self._to_bytes(
+                internal_value,
+                bit_position=0,
+                bit_length=8 * data_length,
+                base_data_type=self.base_data_type,
+                is_highlow_byte_order=self.is_highlow_byte_order,
+            ))
+
+        # TODO: ensure that the termination delimiter is not
+        # encountered within the encoded value.
 
-    def convert_bytes_to_internal(self, decode_state: DecodeState, bit_position: int = 0):
-        if decode_state.next_byte_position + self.min_length > len(decode_state.coded_message):
-            raise DecodeError("The PDU ended before min length was reached.")
+        odxassert(self.termination != "END-OF-PDU" or encode_state.is_end_of_pdu)
+        if encode_state.is_end_of_pdu or len(value_bytes) == self.max_length:
+            # All termination types may be ended by the end of the PDU
+            # or once reaching the maximum length. In this case, we
+            # must not add the termination sequence
+            pass
+        else:
+            termination_sequence = self.__termination_sequence()
+
+            # ensure that we don't try to encode an odd-length
+            # value when using a two-byte terminator
+            odxassert(len(value_bytes) % len(termination_sequence) == 0)
+
+            value_bytes.extend(termination_sequence)
+
+        if len(value_bytes) < self.min_length:
+            raise EncodeError(f"Encoded value for MinMaxLengthType "
+                              f"must be at least {self.min_length} bytes long. "
+                              f"(Is: {len(value_bytes)} bytes.)")
+        elif self.max_length is not None and len(value_bytes) > self.max_length:
+            raise EncodeError(f"Encoded value for MinMaxLengthType "
+                              f"must not be longer than {self.max_length} bytes. "
+                              f"(Is: {len(value_bytes)} bytes.)")
+
+        return value_bytes
+
+    def convert_bytes_to_internal(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[AtomicOdxType, int]:
+        if decode_state.cursor_position + self.min_length > len(decode_state.coded_message):
+            raise DecodeError("The PDU ended before minimum length was reached.")
 
         coded_message = decode_state.coded_message
-        byte_position = decode_state.next_byte_position
-        termination_char = self.__termination_character()
+        cursor_pos = decode_state.cursor_position
+        termination_seq = self.__termination_sequence()
 
-        # If no termination char is found, this is the next byte after the parameter.
-        max_termination_byte = len(coded_message)
+        max_terminator_pos = len(coded_message)
         if self.max_length is not None:
-            max_termination_byte = min(max_termination_byte, byte_position + self.max_length)
+            max_terminator_pos = min(max_terminator_pos, cursor_pos + self.max_length)
 
         if self.termination != "END-OF-PDU":
-            # The parameter either ends after max length, at the end of the PDU
-            # or if a termination character is found.
-            char_length = len(termination_char)  # either 1 or 2
-
-            termination_byte = byte_position + self.min_length
-            found_char = False
-            # Search the termination character
-            while termination_byte < max_termination_byte and not found_char:
-                found_char = (
-                    coded_message[termination_byte:termination_byte +
-                                  char_length] == termination_char)
-                if not found_char:
-                    termination_byte += char_length
-
-            byte_length = termination_byte - byte_position
+            # The parameter either ends after the maximum length, at
+            # the end of the PDU or if a termination sequence is
+            # found.
+
+            terminator_pos = cursor_pos + self.min_length
+            while True:
+                # Search the termination sequence
+                terminator_pos = coded_message.find(termination_seq, terminator_pos,
+                                                    max_terminator_pos)
+                if terminator_pos < 0:
+                    # termination sequence was not found, i.e., we
+                    # are terminated by either the end of the PDU or
+                    # our maximum size. (whatever is the smaller
+                    # value.)
+                    byte_length = max_terminator_pos - cursor_pos
+                    break
+                elif (terminator_pos - cursor_pos) % len(termination_seq) == 0:
+                    # we found the termination sequence at a position
+                    # and it is correctly aligned (two-byte
+                    # termination sequences must be word aligned
+                    # relative to the beginning of the parameter)!
+                    byte_length = terminator_pos - cursor_pos
+                    break
+                else:
+                    # we found the termination sequence, but its
+                    # alignment was incorrect. Try again one byte
+                    # further...
+                    terminator_pos += 1
 
             # Extract the value
-            value, byte = self._extract_internal(
+            value, byte_pos = self._extract_internal(
                 decode_state.coded_message,
-                byte_position=byte_position,
+                byte_position=cursor_pos,
                 bit_position=bit_position,
                 bit_length=8 * byte_length,
                 base_data_type=self.base_data_type,
                 is_highlow_byte_order=self.is_highlow_byte_order,
             )
-            odxassert(byte == termination_byte)
 
-            # next byte starts after the termination character
-            next_byte_position = byte + char_length if found_char else byte
-            return value, next_byte_position
+            if byte_pos != len(coded_message) and byte_pos - cursor_pos != self.max_length:
+                byte_pos += len(termination_seq)
+
+            # next byte starts after the actual data and the termination sequence
+            return value, byte_pos
         else:
             # If termination == "END-OF-PDU", the parameter ends after max_length
             # or at the end of the PDU.
-            byte_length = max_termination_byte - byte_position
+            byte_length = max_terminator_pos - cursor_pos
 
-            value, byte = self._extract_internal(
+            value, byte_pos = self._extract_internal(
                 decode_state.coded_message,
-                byte_position=byte_position,
+                byte_position=cursor_pos,
                 bit_position=bit_position,
                 bit_length=8 * byte_length,
                 base_data_type=self.base_data_type,
                 is_highlow_byte_order=self.is_highlow_byte_order,
             )
-            return value, byte
+            return value, byte_pos

odxtools/modification.py

@@ -24,8 +24,8 @@ class Modification:
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {}
 
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase):
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer"):
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         pass

odxtools/multiplexer.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-from collections import OrderedDict
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, cast
 from xml.etree import ElementTree
 
 from .createsdgs import create_sdgs_from_et
@@ -14,7 +13,7 @@ from .multiplexercase import MultiplexerCase
 from .multiplexerdefaultcase import MultiplexerDefaultCase
 from .multiplexerswitchkey import MultiplexerSwitchKey
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from .odxtypes import odxstr_to_bool
+from .odxtypes import AtomicOdxType, ParameterValue, odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
@@ -58,17 +57,13 @@ class Multiplexer(DopBase):
             cases=cases,
             **kwargs)
 
-    @property
-    def bit_length(self):
-        return None
-
-    def _get_case_limits(self, case: MultiplexerCase):
+    def _get_case_limits(self, case: MultiplexerCase) -> Tuple[AtomicOdxType, AtomicOdxType]:
         key_type = self.switch_key.dop.physical_type.base_data_type
         lower_limit = key_type.make_from(case.lower_limit)
         upper_limit = key_type.make_from(case.upper_limit)
         return lower_limit, upper_limit
 
-    def convert_physical_to_bytes(self, physical_value, encode_state: EncodeState,
+    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
                                   bit_position: int) -> bytes:
 
         if bit_position != 0:
@@ -88,10 +83,11 @@ class Multiplexer(DopBase):
                     case_bytes = case._structure.convert_physical_to_bytes(
                         case_value, encode_state, 0)
                 else:
-                    case_bytes = bytes()
+                    case_bytes = b''
 
                 key_value, _ = self._get_case_limits(case)
-                key_bytes = self.switch_key.convert_physical_to_bytes(key_value, encode_state)
+                key_bytes = self.switch_key.dop.convert_physical_to_bytes(
+                    key_value, encode_state, bit_position=self.switch_key.bit_position or 0)
 
                 mux_len = max(len(key_bytes), len(case_bytes) + case_pos)
                 mux_bytes = bytearray(mux_len)
@@ -102,18 +98,20 @@ class Multiplexer(DopBase):
 
         raise EncodeError(f"The case {case_name} is not found in Multiplexer {self.short_name}")
 
-    def convert_bytes_to_physical(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_physical(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
 
         if bit_position != 0:
-            raise DecodeError("Multiplexer must be aligned, i.e. bit_position=0, but "
+            raise DecodeError("Multiplexers must be byte-aligned, i.e. bit_position=0, but "
                               f"{self.short_name} was passed the bit position {bit_position}")
-        key_value, key_next_byte = self.switch_key.convert_bytes_to_physical(decode_state)
+        key_value, key_next_byte = self.switch_key.dop.convert_bytes_to_physical(decode_state)
 
-        byte_code = decode_state.coded_message[decode_state.next_byte_position:]
+        byte_code = decode_state.coded_message[decode_state.cursor_position:]
         case_decode_state = DecodeState(
             coded_message=byte_code[self.byte_position:],
-            parameter_values=dict(),
-            next_byte_position=0,
+            parameter_values={},
+            cursor_position=0,
         )
         case_found = False
         case_next_byte = 0
@@ -135,16 +133,20 @@ class Multiplexer(DopBase):
 
         if not case_found:
             raise DecodeError(
-                f"Failed to find a matching case in {self.short_name} for value {key_value}")
+                f"Failed to find a matching case in {self.short_name} for value {key_value!r}")
 
-        mux_value = OrderedDict({case.short_name: case_value})
-        mux_next_byte = decode_state.next_byte_position + max(
+        mux_value = {case.short_name: cast(ParameterValue, case_value)}
+        mux_next_byte = decode_state.cursor_position + max(
             key_next_byte + self.switch_key.byte_position, case_next_byte + self.byte_position)
         return mux_value, mux_next_byte
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
+        odxlinks.update(self.switch_key._build_odxlinks())
+        if self.default_case is not None:
+            odxlinks.update(self.default_case._build_odxlinks())
+
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -157,7 +159,7 @@ class Multiplexer(DopBase):
         for case in self.cases:
             case._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer"):
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
         self.switch_key._resolve_snrefs(diag_layer)

odxtools/multiplexerswitchkey.py

@@ -1,18 +1,47 @@
 from dataclasses import dataclass
-from typing import List
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment
-from .positioneddataobjectproperty import PositionedDataObjectProperty
-from .utils import dataclass_fields_asdict
+from .dataobjectproperty import DataObjectProperty
+from .exceptions import odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+
+if TYPE_CHECKING:
+    from ..diaglayer import DiagLayer
 
 
 @dataclass
-class MultiplexerSwitchKey(PositionedDataObjectProperty):
+class MultiplexerSwitchKey:
+    """
+    The object that determines the case to be used by a multiplexer
+    """
+    byte_position: int
+    bit_position: Optional[int]
+    dop_ref: OdxLinkRef
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerSwitchKey":
-        kwargs = dataclass_fields_asdict(
-            PositionedDataObjectProperty.from_et(et_element, doc_frags))
-        return MultiplexerSwitchKey(**kwargs)
+        byte_position = int(odxrequire(et_element.findtext("BYTE-POSITION")))
+        bit_position_str = et_element.findtext("BIT-POSITION")
+        bit_position = int(bit_position_str) if bit_position_str is not None else None
+        dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
+
+        return MultiplexerSwitchKey(
+            byte_position=byte_position,
+            bit_position=bit_position,
+            dop_ref=dop_ref,
+        )
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
+
+    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+        pass
+
+    @property
+    def dop(self) -> DataObjectProperty:
+        return self._dop

odxtools/nameditemlist.py

@@ -1,8 +1,9 @@
 # SPDX-License-Identifier: MIT
 import abc
+from collections import OrderedDict
 from keyword import iskeyword
-from typing import (Callable, Collection, Generic, Iterable, List, Optional, Protocol, Tuple,
-                    TypeVar, Union, cast, overload, runtime_checkable)
+from typing import (Any, Callable, Collection, Dict, Generic, Iterable, Iterator, List, Optional,
+                    Protocol, Tuple, TypeVar, Union, cast, overload, runtime_checkable)
 
 from .exceptions import odxraise
 
@@ -19,7 +20,7 @@ T = TypeVar("T")
 TNamed = TypeVar("TNamed", bound=OdxNamed)
 
 
-class ItemList(Generic[T]):
+class ItemAttributeList(Generic[T]):
     """A list that provides direct access to its items as named attributes.
 
     This is a hybrid between a list and a user-defined object: One can
@@ -34,8 +35,8 @@ class ItemList(Generic[T]):
     """
 
     def __init__(self, input_list: Optional[Iterable[T]] = None) -> None:
-        self._names: List[str] = []
-        self._values: List[T] = []
+        self._item_dict: OrderedDict[str, T] = OrderedDict()
+        self._item_list: List[T] = []
 
         if input_list is not None:
             for item in input_list:
@@ -54,53 +55,57 @@ class ItemList(Generic[T]):
         """
         item_name = self._get_item_key(item)
 
-        # eliminate conflicts between the item name and existing
-        # attributes of the NamedItemList object
+        # eliminate conflicts between the name of the new item and
+        # existing attributes of the ItemAttributeList object
         i = 1
         tmp = item_name
         while True:
-            # using dir() for checking if there is a name conflict
-            # might be slow, but NamedItemList is not meant for
-            # ginormous lists...
-            if tmp not in dir(self):
+            if not hasattr(self, tmp):
                 break
 
             i += 1
             if item_name.endswith("_"):
+                # if the item name already ends with an underscore,
+                # there's no need to add a second one...
                 tmp = f"{item_name}{i}"
             else:
                 tmp = f"{item_name}_{i}"
+
         item_name = tmp
 
-        self.__dict__[item_name] = item
-        self._names.append(item_name)
-        self._values.append(item)
+        self._item_dict[item_name] = item
+        self._item_list.append(item)
 
     def sort(self, key: Optional[Callable[[T], str]] = None, reverse: bool = False) -> None:
-        tmp = list(zip(self._names, self._values))
         if key is None:
-            tmp.sort(reverse=reverse)
+            self._item_dict = OrderedDict(
+                sorted(self._item_dict.items(), key=lambda x: x[0], reverse=reverse))
         else:
             key_fn = cast(Callable[[T], str], key)
-            tmp.sort(key=lambda x: key_fn(x[1]), reverse=reverse)
+            self._item_dict = OrderedDict(
+                sorted(self._item_dict.items(), key=lambda x: key_fn(x[1]), reverse=reverse))
 
-        self._names = [x[0] for x in tmp]
-        self._values = [x[1] for x in tmp]
+        self._item_list = list(self._item_dict.values())
 
     def keys(self) -> Collection[str]:
-        return self._names
+        return self._item_dict.keys()
 
     def values(self) -> Collection[T]:
-        return self._values
+        return self._item_list
 
-    def items(self) -> List[Tuple[str, T]]:
-        return list(zip(self._names, self._values))
+    def items(self) -> Collection[Tuple[str, T]]:
+        return self._item_dict.items()
 
     def __contains__(self, x: T) -> bool:
-        return x in self._values
+        return x in self._item_list
 
     def __len__(self) -> int:
-        return len(self._values)
+        return len(self._item_list)
+
+    def __dir__(self) -> Dict[str, Any]:
+        result = dict(self.__dict__)
+        result.update(self._item_dict)
+        return result
 
     @overload
     def __getitem__(self, key: int) -> T:
@@ -116,59 +121,55 @@ class ItemList(Generic[T]):
 
     def __getitem__(self, key: Union[int, str, slice]) -> Union[T, List[T]]:
         if isinstance(key, int):
-            if abs(key) < -len(self._values) or key >= len(self._values):
-                # we want to raise a KeyError instead of an IndexError
-                # if the index is out of range...
-                raise KeyError(f"Tried to access item {key} of a NamedItemList "
-                               f"of length {len(self)}")
-
-            return self._values[key]
+            return self._item_list[key]
         elif isinstance(key, slice):
-            # for slices, we unfortunately have to ignore the typing
-            # because if the key is a slice, we cannot return a single
-            # item. (alternatively, the return type of this method
-            # could be defined as Union[T, List[T]], but this leads
-            # mypy to produce *many* spurious and hard to fix errors.
-            return self._values[key]
+            return self._item_list[key]
         else:
-            return self.__dict__[key]
+            return self._item_dict[key]
+
+    def __getattr__(self, key: str) -> T:
+        if key not in self._item_dict:
+            raise AttributeError(f"ItemAttributeList does not contain an item named '{key}'")
+
+        return self._item_dict[key]
 
     def get(self, key: Union[int, str], default: Optional[T] = None) -> Optional[T]:
         if isinstance(key, int):
-            if abs(key) < -len(self._values) or key >= len(self._values):
+            if abs(key) < -len(self._item_dict) or key >= len(self._item_dict):
                 return default
 
-            return self._values[key]
+            return self._item_list[key]
         else:
-            return cast(Optional[T], self.__dict__.get(key, default))
+            return cast(Optional[T], self._item_dict.get(key, default))
 
     def __eq__(self, other: object) -> bool:
         """
-        Named item lists are equal if the underlying lists are equal.
-        Note that this does not consider the map `item_to_name_fn`.
+        Item lists are equal if the underlying lists are equal.
         """
-        if not isinstance(other, NamedItemList):
+        if not isinstance(other, type(self)) or not isinstance(self, type(other)):
             return False
         else:
-            return self._names == other._names and self._values == other._values
+            return self._item_dict == other._item_dict
 
-    # -> Iterator[T]: # <- this leads to *many* type checking errors
-    def __iter__(self):
-        return iter(self._values)
+    def __iter__(self) -> Iterator[T]:
+        return iter(self._item_list)
 
     def __str__(self) -> str:
-        return f"[{', '.join([x for x in self._names])}]"
+        return f"[{', '.join(self._item_dict.keys())}]"
 
     def __repr__(self) -> str:
         return self.__str__()
 
 
 def short_name_as_key(obj: OdxNamed) -> str:
-    """Retrieve an object's `short_name` attribute into a valid python identifier.
+    """Transform an object's `short_name` attribute into a valid
+    python identifier
+
+    Although short names are almost identical to valid python
+    identifiers, their first character is allowed to be a number or
+    they may be python keywords. This method prepends an underscore to
+    such short names.
 
-    Although short names are almost identical to python identifiers,
-    their first character is allowed to be a number. This method
-    prepends an underscore to such shortnames.
     """
     if not isinstance(obj, OdxNamed):
         odxraise()
@@ -176,16 +177,16 @@ def short_name_as_key(obj: OdxNamed) -> str:
     if not isinstance(sn, str):
         odxraise()
 
-    # make sure that the name of the item in question:
-    # * is not a python keyword (this would lead to syntax errors)
-    # * does not starts with a digit
+    # make sure that the name of the item in question is not a python
+    # keyword (this would lead to syntax errors) and that does not
+    # start with a digit
     if sn[0].isdigit() or iskeyword(sn):
         return f"_{sn}"
 
     return sn
 
 
-class NamedItemList(Generic[TNamed], ItemList[TNamed]):
+class NamedItemList(Generic[TNamed], ItemAttributeList[TNamed]):
 
     def _get_item_key(self, obj: OdxNamed) -> str:
         return short_name_as_key(obj)