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

odxtools/parameters/tablekeyparameter.py

@@ -6,6 +6,7 @@ from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxtypes import ParameterValue
 from .parameter import Parameter, ParameterType
 
 if TYPE_CHECKING:
@@ -94,14 +95,6 @@ class TableKeyParameter(Parameter):
     def is_settable(self) -> bool:
         return True
 
-    def get_coded_value(self, physical_value=None) -> Any:
-        key_dop = self.table.key_dop
-        if key_dop is None:
-            raise EncodeError(f"Table '{self.table.short_name}' does not define "
-                              f"a KEY-DOP, but is used in TABLE-KEY parameter "
-                              f"'{self.short_name}'")
-        return key_dop.convert_physical_to_internal(physical_value)
-
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         tr_short_name = encode_state.parameter_values.get(self.short_name)
 
@@ -116,7 +109,7 @@ class TableKeyParameter(Parameter):
                                   f"a KEY-DOP, but is used in TABLE-KEY parameter "
                                   f"'{self.short_name}'")
 
-            byte_len = (key_dop.bit_length + 7) // 8
+            byte_len = (odxrequire(key_dop.get_static_bit_length()) + 7) // 8
             if self.bit_position is not None and self.bit_position > 0:
                 byte_len += 1
 
@@ -142,21 +135,21 @@ class TableKeyParameter(Parameter):
     def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
         return super().encode_into_pdu(encode_state)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[Any, int]:
-        if self.byte_position is not None and self.byte_position != decode_state.next_byte_position:
-            next_byte_position = self.byte_position
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
+        if self.byte_position is not None and self.byte_position != decode_state.cursor_position:
+            cursor_position = self.byte_position
 
         # update the decode_state's table key
         if self.table_row is not None:
             # the table row to be used is statically specified -> no
             # need to decode anything!
             phys_val = self.table_row.short_name
-            next_byte_position = decode_state.next_byte_position
+            cursor_position = decode_state.cursor_position
         else:
             # Use DOP to decode
             key_dop = odxrequire(self.table.key_dop)
             bit_position_int = self.bit_position if self.bit_position is not None else 0
-            key_dop_val, next_byte_position = key_dop.convert_bytes_to_physical(
+            key_dop_val, cursor_position = key_dop.convert_bytes_to_physical(
                 decode_state, bit_position=bit_position_int)
 
             table_row_candidates = [x for x in self.table.table_rows if x.key == key_dop_val]
@@ -167,4 +160,4 @@ class TableKeyParameter(Parameter):
                     f"Multiple rows exhibiting key '{str(key_dop_val)}' found in table")
             phys_val = table_row_candidates[0].short_name
 
-        return phys_val, next_byte_position
+        return phys_val, cursor_position

odxtools/parameters/tablestructparameter.py

@@ -2,12 +2,13 @@
 import warnings
 from copy import copy
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, cast
 
 from ..decodestate import DecodeState
 from ..encodestate import EncodeState
 from ..exceptions import EncodeError, OdxWarning, odxraise
 from ..odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from ..odxtypes import ParameterValue
 from .parameter import Parameter, ParameterType
 from .tablekeyparameter import TableKeyParameter
 
@@ -44,24 +45,22 @@ class TableStructParameter(Parameter):
         if self.table_key_snref is not None:
             warnings.warn(
                 "Table keys cannot yet be defined using SNREFs"
-                " in TableStructParameters.", OdxWarning)
+                " in TableStructParameters.",
+                OdxWarning,
+                stacklevel=1)
 
     @property
     def table_key(self) -> TableKeyParameter:
         return self._table_key
 
     @property
-    def is_required(self):
+    def is_required(self) -> bool:
         return True
 
     @property
-    def is_settable(self):
+    def is_settable(self) -> bool:
         return True
 
-    def get_coded_value(self, physical_value=None):
-        raise EncodeError("TableStructParameters cannot be converted to "
-                          "internal values without a table row.")
-
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         physical_value = encode_state.parameter_values.get(self.short_name)
 
@@ -131,11 +130,11 @@ class TableStructParameter(Parameter):
     def encode_into_pdu(self, encode_state: EncodeState) -> bytes:
         return super().encode_into_pdu(encode_state)
 
-    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[Any, int]:
-        if self.byte_position is not None and self.byte_position != decode_state.next_byte_position:
+    def decode_from_pdu(self, decode_state: DecodeState) -> Tuple[ParameterValue, int]:
+        if self.byte_position is not None and self.byte_position != decode_state.cursor_position:
             next_pos = self.byte_position if self.byte_position is not None else 0
             decode_state = copy(decode_state)
-            decode_state.next_byte_position = next_pos
+            decode_state.cursor_position = next_pos
 
         # find the selected table row
         key_name = self.table_key.short_name
@@ -160,4 +159,4 @@ class TableStructParameter(Parameter):
         else:
             # the table row associated with the key neither defines a
             # DOP not a structure -> ignore it
-            return (table_row.short_name, None), decode_state.next_byte_position
+            return (table_row.short_name, cast(int, None)), decode_state.cursor_position

odxtools/parameters/valueparameter.py

@@ -31,17 +31,15 @@ class ValueParameter(ParameterWithDOP):
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         super()._resolve_snrefs(diag_layer)
 
-        self._physical_default_value: Optional[AtomicOdxType]
-        pdvr = self.physical_default_value_raw
-        if pdvr is None:
-            self._physical_default_value = None
-            return
-
-        dop = odxrequire(self.dop)
-        if not isinstance(dop, DataObjectProperty):
-            odxraise("The type of PHYS-CONST parameters must be a simple DOP")
-        base_data_type = dop.physical_type.base_data_type
-        self._physical_default_value = base_data_type.from_string(pdvr)
+        self._physical_default_value: Optional[AtomicOdxType] = None
+        if self.physical_default_value_raw is not None:
+            dop = odxrequire(self.dop)
+            if not isinstance(dop, DataObjectProperty):
+                odxraise("Value parameters can only define a physical default "
+                         "value if they use a simple DOP")
+            base_data_type = dop.physical_type.base_data_type
+            self._physical_default_value = base_data_type.from_string(
+                self.physical_default_value_raw)
 
     @property
     def physical_default_value(self) -> Optional[AtomicOdxType]:
@@ -55,15 +53,6 @@ class ValueParameter(ParameterWithDOP):
     def is_settable(self) -> bool:
         return True
 
-    def get_coded_value(self, physical_value: Optional[AtomicOdxType] = None):
-        if physical_value is not None:
-            dop = odxrequire(self.dop)
-            if not isinstance(dop, DataObjectProperty):
-                odxraise()
-            return dop.convert_physical_to_internal(physical_value)
-        else:
-            return self.physical_default_value
-
     def get_coded_value_as_bytes(self, encode_state: EncodeState) -> bytes:
         physical_value = encode_state.parameter_values.get(self.short_name,
                                                            self.physical_default_value)
@@ -77,7 +66,3 @@ class ValueParameter(ParameterWithDOP):
         bit_position_int = self.bit_position if self.bit_position is not None else 0
         return dop.convert_physical_to_bytes(
             physical_value, encode_state=encode_state, bit_position=bit_position_int)
-
-    def get_valid_physical_values(self):
-        if isinstance(self.dop, DataObjectProperty):
-            return self.dop.get_valid_physical_values()

odxtools/paramlengthinfotype.py

@@ -1,13 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any, Dict, Tuple
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import odxraise
-from .odxlink import OdxLinkDatabase, OdxLinkRef
-from .odxtypes import DataType
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import AtomicOdxType, DataType
 
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
@@ -23,7 +23,7 @@ class ParamLengthInfoType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "PARAM-LENGTH-INFO-TYPE"
 
-    def _build_odxlinks(self):
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -40,7 +40,7 @@ class ParamLengthInfoType(DiagCodedType):
     def length_key(self) -> "LengthKeyParameter":
         return self._length_key
 
-    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:
         bit_length = encode_state.parameter_values.get(self.length_key.short_name, None)
 
@@ -50,9 +50,9 @@ class ParamLengthInfoType(DiagCodedType):
                     DataType.A_ASCIISTRING,
                     DataType.A_UTF8STRING,
             ]:
-                bit_length = 8 * len(internal_value)
+                bit_length = 8 * len(internal_value)  # type: ignore[arg-type]
             if self.base_data_type in [DataType.A_UNICODE2STRING]:
-                bit_length = 16 * len(internal_value)
+                bit_length = 16 * len(internal_value)  # type: ignore[arg-type]
 
             if self.base_data_type in [DataType.A_INT32, DataType.A_UINT32]:
                 bit_length = int(internal_value).bit_length()
@@ -74,7 +74,9 @@ class ParamLengthInfoType(DiagCodedType):
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-    def convert_bytes_to_internal(self, decode_state: DecodeState, bit_position: int = 0):
+    def convert_bytes_to_internal(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[AtomicOdxType, int]:
         # Find length key with matching ID.
         bit_length = None
         for parameter_name, value in decode_state.parameter_values.items():
@@ -91,7 +93,7 @@ class ParamLengthInfoType(DiagCodedType):
         # Extract the internal value and return.
         return self._extract_internal(
             decode_state.coded_message,
-            decode_state.next_byte_position,
+            decode_state.cursor_position,
             bit_position,
             bit_length,
             self.base_data_type,

odxtools/physicaldimension.py

@@ -58,7 +58,7 @@ class PhysicalDimension(IdentifiableElement):
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
         oid = et_element.get("OID")
 
-        def read_optional_int(element, name):
+        def read_optional_int(element: ElementTree.Element, name: str) -> int:
             if val_str := element.findtext(name):
                 return int(val_str)
             else:

odxtools/physicaltype.py

@@ -51,13 +51,13 @@ class PhysicalType:
     The precision is only applicable if the base data type is A_FLOAT32 or A_FLOAT64.
     """
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.base_data_type = DataType(self.base_data_type)
         if self.display_radix is not None:
             self.display_radix = Radix(self.display_radix)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]):
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "PhysicalType":
         base_data_type_str = et_element.get("BASE-DATA-TYPE")
         if base_data_type_str not in DataType.__members__:
             odxraise(f"Encountered unknown base data type '{base_data_type_str}'")

odxtools/response.py

@@ -3,17 +3,21 @@ from dataclasses import dataclass
 from typing import Optional
 
 from .basicstructure import BasicStructure
+from .odxtypes import ParameterValue
+from .parameters.matchingrequestparameter import MatchingRequestParameter
 
 
 @dataclass
 class Response(BasicStructure):
     response_type: str  # "POS-RESPONSE" or "NEG-RESPONSE"
 
-    def encode(self, coded_request: Optional[bytes] = None, **params) -> bytes:
+    def encode(self, coded_request: Optional[bytes] = None, **params: ParameterValue) -> bytes:
         if coded_request is not None:
-            # Extract MATCHING-REQUEST-PARAMs from the coded request
+            # Extract MATCHING-REQUEST-PARAMs from the coded
+            # request. TODO: this should be done by
+            # MatchingRequestParam itself!
             for param in self.parameters:
-                if param.parameter_type == "MATCHING-REQUEST-PARAM":
+                if isinstance(param, MatchingRequestParameter):
                     byte_pos = param.request_byte_position
                     byte_length = param.byte_length
 

odxtools/singleecujob.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from itertools import chain
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
 from xml.etree import ElementTree
 
@@ -17,7 +16,7 @@ from .message import Message
 from .nameditemlist import NamedItemList
 from .negoutputparam import NegOutputParam
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import odxstr_to_bool
+from .odxtypes import ParameterValue, odxstr_to_bool
 from .outputparam import OutputParam
 from .progcode import ProgCode
 from .specialdatagroup import SpecialDataGroup
@@ -71,21 +70,21 @@ class SingleEcuJob(IdentifiableElement):
     sdgs: List[SpecialDataGroup]
 
     @property
-    def is_mandatory(self):
-        return self.is_mandatory_raw == True
+    def is_mandatory(self) -> bool:
+        return self.is_mandatory_raw is True
 
     @property
-    def is_executable(self):
+    def is_executable(self) -> bool:
         return self.is_executable_raw in (None, True)
 
     @property
-    def is_final(self):
-        return self.is_final_raw == True
+    def is_final(self) -> bool:
+        return self.is_final_raw is True
 
     def __post_init__(self) -> None:
         if not self.functional_class_refs:
             self.functional_class_refs = []
-        self._functional_classes: Optional[NamedItemList[FunctionalClass]] = None
+        self._functional_classes: NamedItemList[FunctionalClass]
 
         # Replace None attributes by empty lists
         if not self.input_params:
@@ -164,7 +163,7 @@ class SingleEcuJob(IdentifiableElement):
             **kwargs)
 
     @property
-    def functional_classes(self) -> Optional[NamedItemList[FunctionalClass]]:
+    def functional_classes(self) -> NamedItemList[FunctionalClass]:
         """The functional classes referenced by this job.
         This is None iff the references were not resolved.
         """
@@ -173,9 +172,16 @@ class SingleEcuJob(IdentifiableElement):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
-        for obj in chain(self.prog_codes, self.input_params, self.output_params,
-                         self.neg_output_params, self.sdgs):
-            result.update(obj._build_odxlinks())
+        for prog_code in self.prog_codes:
+            result.update(prog_code._build_odxlinks())
+        for input_param in self.input_params:
+            result.update(input_param._build_odxlinks())
+        for output_param in self.output_params:
+            result.update(output_param._build_odxlinks())
+        for neg_output_param in self.neg_output_params:
+            result.update(neg_output_param._build_odxlinks())
+        for sdg in self.sdgs:
+            result.update(sdg._build_odxlinks())
 
         if self.admin_data:
             result.update(self.admin_data._build_odxlinks())
@@ -198,9 +204,16 @@ class SingleEcuJob(IdentifiableElement):
             else:
                 logger.warning(f"Functional class ID {fc_ref!r} resolved to {fc!r}.")
 
-        for obj in chain(self.prog_codes, self.input_params, self.output_params,
-                         self.neg_output_params, self.sdgs):
-            obj._resolve_odxlinks(odxlinks)
+        for prog_code in self.prog_codes:
+            prog_code._resolve_odxlinks(odxlinks)
+        for input_param in self.input_params:
+            input_param._resolve_odxlinks(odxlinks)
+        for output_param in self.output_params:
+            output_param._resolve_odxlinks(odxlinks)
+        for neg_output_param in self.neg_output_params:
+            neg_output_param._resolve_odxlinks(odxlinks)
+        for sdg in self.sdgs:
+            sdg._resolve_odxlinks(odxlinks)
 
         # Resolve references of admin data
         if self.admin_data:
@@ -211,9 +224,16 @@ class SingleEcuJob(IdentifiableElement):
             self.audience._resolve_odxlinks(odxlinks)
 
     def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        for obj in chain(self.prog_codes, self.input_params, self.output_params,
-                         self.neg_output_params, self.sdgs):
-            obj._resolve_snrefs(diag_layer)
+        for prog_code in self.prog_codes:
+            prog_code._resolve_snrefs(diag_layer)
+        for input_param in self.input_params:
+            input_param._resolve_snrefs(diag_layer)
+        for output_param in self.output_params:
+            output_param._resolve_snrefs(diag_layer)
+        for neg_output_param in self.neg_output_params:
+            neg_output_param._resolve_snrefs(diag_layer)
+        for sdg in self.sdgs:
+            sdg._resolve_snrefs(diag_layer)
 
         # Resolve references of admin data
         if self.admin_data:
@@ -231,7 +251,7 @@ class SingleEcuJob(IdentifiableElement):
             f"Single ECU jobs are completely executed on the tester and thus cannot be decoded."
             f" You tried to decode a response for the job {self.odx_id}.")
 
-    def encode_request(self, **params):
+    def encode_request(self, **params: ParameterValue) -> bytes:
         """This function's signature matches `DiagService.encode_request`
         and only raises an informative error.
         """
@@ -239,7 +259,10 @@ class SingleEcuJob(IdentifiableElement):
             f"Single ECU jobs are completely executed on the tester and thus cannot be encoded."
             f" You tried to encode a request for the job {self.odx_id}.")
 
-    def encode_positive_response(self, coded_request, response_index=0, **params):
+    def encode_positive_response(self,
+                                 coded_request: bytes,
+                                 response_index: int = 0,
+                                 **params: ParameterValue) -> bytes:
         """This function's signature matches `DiagService.encode_positive_response`
         and only raises an informative error.
         """
@@ -247,7 +270,10 @@ class SingleEcuJob(IdentifiableElement):
             f"Single ECU jobs are completely executed on the tester and thus cannot be encoded."
             f" You tried to encode a response for the job {self.odx_id}.")
 
-    def encode_negative_response(self, coded_request, response_index=0, **params):
+    def encode_negative_response(self,
+                                 coded_request: bytes,
+                                 response_index: int = 0,
+                                 **params: ParameterValue) -> bytes:
         """This function's signature matches `DiagService.encode_negative_response`
         and only raises an informative error.
         """
@@ -255,7 +281,7 @@ class SingleEcuJob(IdentifiableElement):
             f"Single ECU jobs are completely executed on the tester and thus cannot be encoded."
             f" You tried to encode the job {self.odx_id}.")
 
-    def __call__(self, **params) -> bytes:
+    def __call__(self, **params: ParameterValue) -> bytes:
         raise EncodeError(
             f"Single ECU jobs are completely executed on the tester and thus cannot be encoded."
             f" You tried to call the job {self.odx_id}.")

odxtools/standardlengthtype.py

@@ -1,6 +1,6 @@
 # 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
@@ -20,7 +20,7 @@ class StandardLengthType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "STANDARD-LENGTH-TYPE"
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         if self.bit_mask is not None:
             maskable_types = (DataType.A_UINT32, DataType.A_INT32, DataType.A_BYTEFIELD)
             odxassert(
@@ -43,6 +43,9 @@ class StandardLengthType(DiagCodedType):
         odxraise(f'Can not apply a bit_mask on a value of type {type(internal_value)}')
         return internal_value
 
+    def get_static_bit_length(self) -> Optional[int]:
+        return self.bit_length
+
     def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
                                   bit_position: int) -> bytes:
         return self._to_bytes(
@@ -53,14 +56,16 @@ class StandardLengthType(DiagCodedType):
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-    def convert_bytes_to_internal(self, decode_state: DecodeState, bit_position: int = 0):
-        internal_value, next_byte_position = self._extract_internal(
+    def convert_bytes_to_internal(self,
+                                  decode_state: DecodeState,
+                                  bit_position: int = 0) -> Tuple[AtomicOdxType, int]:
+        internal_value, cursor_position = self._extract_internal(
             decode_state.coded_message,
-            decode_state.next_byte_position,
+            decode_state.cursor_position,
             bit_position,
             self.bit_length,
             self.base_data_type,
             self.is_highlow_byte_order,
         )
         internal_value = self.__apply_mask(internal_value)
-        return internal_value, next_byte_position
+        return internal_value, cursor_position

odxtools/uds.py

@@ -49,7 +49,7 @@ class UDSSID(IntEnum):
 
 
 # add the OBD SIDs to the ones from UDS
-SID = IntEnum("UdsSID", ((i.name, i.value) for i in chain(obd.SID, UDSSID)))  # type: ignore
+SID = IntEnum("UdsSID", ((i.name, i.value) for i in chain(obd.SID, UDSSID)))  # type: ignore[misc]
 
 
 class NegativeResponseCodes(IntEnum):

odxtools/unit.py

@@ -60,7 +60,7 @@ class Unit(IdentifiableElement):
     offset_si_to_unit: Optional[float]
     physical_dimension_ref: Optional[OdxLinkRef]
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self._physical_dimension = None
 
     @staticmethod
@@ -69,9 +69,9 @@ class Unit(IdentifiableElement):
         oid = et_element.get("OID")
         display_name = odxrequire(et_element.findtext("DISPLAY-NAME"))
 
-        def read_optional_float(element, name):
-            if element.findtext(name):
-                return float(element.findtext(name))
+        def read_optional_float(element: ElementTree.Element, name: str) -> Optional[float]:
+            if (elem_str := element.findtext(name)) is not None:
+                return float(elem_str)
             else:
                 return None
 
@@ -89,7 +89,7 @@ class Unit(IdentifiableElement):
             **kwargs)
 
     @property
-    def physical_dimension(self) -> PhysicalDimension:
+    def physical_dimension(self) -> Optional[PhysicalDimension]:
         return self._physical_dimension
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:

odxtools/unitgroup.py

@@ -30,7 +30,7 @@ class UnitGroup(NamedElement):
     unit_refs: List[OdxLinkRef]
     oid: Optional[str]
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self._units = NamedItemList[Unit]()
 
     @staticmethod

odxtools/unitspec.py

@@ -33,13 +33,13 @@ class UnitSpec:
     physical_dimensions: Union[NamedItemList[PhysicalDimension], List[PhysicalDimension]]
     sdgs: List[SpecialDataGroup]
 
-    def __post_init__(self):
+    def __post_init__(self) -> None:
         self.unit_groups = NamedItemList(self.unit_groups)
         self.units = NamedItemList(self.units)
         self.physical_dimensions = NamedItemList(self.physical_dimensions)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]):
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitSpec":
 
         unit_groups = [
             UnitGroup.from_et(el, doc_frags) for el in et_element.iterfind("UNIT-GROUPS/UNIT-GROUP")

odxtools/version.py

@@ -1,6 +1,16 @@
 # file generated by setuptools_scm
 # don't change, don't track in version control
-from __future__ import annotations
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple, Union
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
 
-__version__ = version = '5.3.1'  # type: str
-__version_tuple__ = version_tuple = (5, 3, 1)  # type: tuple[int | str, ...]
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '6.0.1'
+__version_tuple__ = version_tuple = (6, 0, 1)

odxtools/write_pdx_file.py

@@ -42,7 +42,7 @@ __templates_dir = os.path.sep.join([os.path.dirname(__module_filename), "templat
 def write_pdx_file(
     output_file_name: str,
     database: Database,
-    auxiliary_content_specifiers: List[Tuple[str, bytes]] = [],
+    auxiliary_content_specifiers: Optional[List[Tuple[str, bytes]]] = None,
     templates_dir: str = __templates_dir,
 ) -> bool:
     """
@@ -50,13 +50,16 @@ def write_pdx_file(
     """
     global odxdatabase
 
+    if auxiliary_content_specifiers is None:
+        auxiliary_content_specifiers = []
+
     odxdatabase = database
 
-    file_index = list()
+    file_index = []
     with zipfile.ZipFile(output_file_name, mode="w", compression=zipfile.ZIP_DEFLATED) as zf:
 
         # write all files in the templates directory
-        for root, dir, files in os.walk(templates_dir):
+        for root, _, files in os.walk(templates_dir):
             for template_file_name in files:
                 # we are not interested in the autosave garbage of
                 # editors...
@@ -81,7 +84,7 @@ def write_pdx_file(
                 elif template_file_name.endswith(".odx-d"):
                     template_file_mime_type = "application/x-asam.odx.odx-d"
 
-                in_path = list([root])
+                in_path = [root]
                 in_path.append(template_file_name)
                 in_file_name = os.path.sep.join(in_path)