odxtools 9.7.0__py3-none-any.whl → 10.1.0__py3-none-any.whl

odxtools/request.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from dataclasses import dataclass, field
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -14,7 +14,8 @@ from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue, ParameterValueDict
 from .parameters.createanyparameter import create_any_parameter_from_et
 from .parameters.parameter import Parameter
@@ -23,40 +24,38 @@ from .specialdatagroup import SpecialDataGroup
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Request(IdentifiableElement):
     """Represents all information related to an UDS request
 
     This class implements the `CompositeCodec` interface.
     """
-    admin_data: Optional[AdminData]
-    parameters: NamedItemList[Parameter]
-    sdgs: List[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    parameters: NamedItemList[Parameter] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @property
-    def required_parameters(self) -> List[Parameter]:
+    def required_parameters(self) -> list[Parameter]:
         return composite_codec_get_required_parameters(self)
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         return composite_codec_get_free_parameters(self)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Request":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Request":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
         parameters = NamedItemList([
-            create_any_parameter_from_et(et_parameter, doc_frags)
+            create_any_parameter_from_et(et_parameter, context)
             for et_parameter in et_element.iterfind("PARAMS/PARAM")
         ])
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         return Request(admin_data=admin_data, parameters=parameters, sdgs=sdgs, **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:
@@ -96,7 +95,7 @@ class Request(IdentifiableElement):
         context.request = None
         context.parameters = None
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return composite_codec_get_static_bit_length(self)
 
     def print_free_parameters_info(self) -> None:
@@ -123,7 +122,7 @@ class Request(IdentifiableElement):
 
         return cast(ParameterValueDict, param_values)
 
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         composite_codec_encode_into_pdu(self, physical_value, encode_state)
 

odxtools/response.py

@@ -1,7 +1,7 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, cast
 from xml.etree import ElementTree
 
 from .admindata import AdminData
@@ -15,7 +15,8 @@ from .element import IdentifiableElement
 from .encodestate import EncodeState
 from .exceptions import odxraise
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue, ParameterValueDict
 from .parameters.createanyparameter import create_any_parameter_from_et
 from .parameters.parameter import Parameter
@@ -30,7 +31,7 @@ class ResponseType(Enum):
     GLOBAL_NEGATIVE = "GLOBAL-NEG-RESPONSE"
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Response(IdentifiableElement):
     """Represents all information related to an UDS response
 
@@ -39,14 +40,14 @@ class Response(IdentifiableElement):
 
     response_type: ResponseType
 
-    admin_data: Optional[AdminData]
-    parameters: NamedItemList[Parameter]
-    sdgs: List[SpecialDataGroup]
+    admin_data: AdminData | None = None
+    parameters: NamedItemList[Parameter] = field(default_factory=NamedItemList)
+    sdgs: list[SpecialDataGroup] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Response":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Response":
         """Reads a response."""
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         try:
             response_type = ResponseType(et_element.tag)
@@ -54,14 +55,12 @@ class Response(IdentifiableElement):
             response_type = cast(ResponseType, None)
             odxraise(f"Encountered unknown response type '{et_element.tag}'")
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
+        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), context)
         parameters = NamedItemList([
-            create_any_parameter_from_et(et_parameter, doc_frags)
+            create_any_parameter_from_et(et_parameter, context)
             for et_parameter in et_element.iterfind("PARAMS/PARAM")
         ])
-        sdgs = [
-            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
-        ]
+        sdgs = [SpecialDataGroup.from_et(sdge, context) for sdge in et_element.iterfind("SDGS/SDG")]
 
         return Response(
             response_type=response_type,
@@ -70,7 +69,7 @@ class Response(IdentifiableElement):
             sdgs=sdgs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         if self.admin_data is not None:
@@ -110,7 +109,7 @@ class Response(IdentifiableElement):
         context.response = None
         context.parameters = None
 
-    def encode(self, coded_request: Optional[bytes] = None, **kwargs: ParameterValue) -> bytearray:
+    def encode(self, coded_request: bytes | None = None, **kwargs: ParameterValue) -> bytearray:
         encode_state = EncodeState(triggering_request=coded_request, is_end_of_pdu=True)
 
         self.encode_into_pdu(physical_value=kwargs, encode_state=encode_state)
@@ -126,22 +125,22 @@ class Response(IdentifiableElement):
 
         return cast(ParameterValueDict, param_values)
 
-    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+    def encode_into_pdu(self, physical_value: ParameterValue | None,
                         encode_state: EncodeState) -> None:
         composite_codec_encode_into_pdu(self, physical_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         return composite_codec_decode_from_pdu(self, decode_state)
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         return composite_codec_get_static_bit_length(self)
 
     @property
-    def required_parameters(self) -> List[Parameter]:
+    def required_parameters(self) -> list[Parameter]:
         return composite_codec_get_required_parameters(self)
 
     @property
-    def free_parameters(self) -> List[Parameter]:
+    def free_parameters(self) -> list[Parameter]:
         return composite_codec_get_free_parameters(self)
 
     def print_free_parameters_info(self) -> None:

odxtools/scaleconstr.py

@@ -1,37 +1,36 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .compumethods.limit import Limit
 from .description import Description
 from .exceptions import odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import DataType
 from .validtype import ValidType
 
 
-@dataclass
+@dataclass(kw_only=True)
 class ScaleConstr:
     """This class represents a SCALE-CONSTR.
     """
 
-    short_label: Optional[str]
-    description: Optional[Description]
+    short_label: str | None = None
+    description: Description | None = None
     lower_limit: Limit
     upper_limit: Limit
     validity: ValidType
     value_type: DataType
 
     @staticmethod
-    def scale_constr_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+    def scale_constr_from_et(et_element: ElementTree.Element, context: OdxDocContext, *,
                              value_type: DataType) -> "ScaleConstr":
         short_label = et_element.findtext("SHORT-LABEL")
-        description = Description.from_et(et_element.find("DESC"), doc_frags)
+        description = Description.from_et(et_element.find("DESC"), context)
         lower_limit = Limit.limit_from_et(
-            odxrequire(et_element.find("LOWER-LIMIT")), doc_frags, value_type=value_type)
+            odxrequire(et_element.find("LOWER-LIMIT")), context, value_type=value_type)
         upper_limit = Limit.limit_from_et(
-            odxrequire(et_element.find("UPPER-LIMIT")), doc_frags, value_type=value_type)
+            odxrequire(et_element.find("UPPER-LIMIT")), context, value_type=value_type)
 
         validity_str = odxrequire(et_element.get("VALIDITY"))
         try:

odxtools/servicebinner.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Iterable, Iterator
 from io import StringIO
-from typing import Dict, Iterable, Iterator, Optional
 
 from . import obd, uds
 from .diagservice import DiagService
@@ -21,7 +21,7 @@ class ServiceBinner:
     """
 
     def __init__(self, services: Iterable[DiagService]):
-        service_groups: Dict[Optional[int], NamedItemList[DiagService]] = {}
+        service_groups: dict[int | None, NamedItemList[DiagService]] = {}
         for service in services:
             SID = self.__extract_sid(service)
 
@@ -32,7 +32,7 @@ class ServiceBinner:
 
         self._service_groups = service_groups
 
-    def __extract_sid(self, service: DiagService) -> Optional[int]:
+    def __extract_sid(self, service: DiagService) -> int | None:
         # diagnostic services without requests are possible; just like
         # aircraft without wings...
         if service.request is None:
@@ -96,10 +96,10 @@ class ServiceBinner:
 
         return result.getvalue()
 
-    def __iter__(self) -> Iterator[Optional[int]]:
+    def __iter__(self) -> Iterator[int | None]:
         return iter(self._service_groups)
 
-    def __getitem__(self, sid: Optional[int]) -> NamedItemList[DiagService]:
+    def __getitem__(self, sid: int | None) -> NamedItemList[DiagService]:
         if sid is None:
             return self._service_groups.get(sid, NamedItemList())
 

odxtools/singleecujob.py

@@ -1,20 +1,21 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from .diagcomm import DiagComm
 from .inputparam import InputParam
 from .nameditemlist import NamedItemList
 from .negoutputparam import NegOutputParam
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .outputparam import OutputParam
 from .progcode import ProgCode
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SingleEcuJob(DiagComm):
     """A single ECU job is a diagnostic communication primitive.
 
@@ -30,30 +31,30 @@ class SingleEcuJob(DiagComm):
     standard.
     """
 
-    prog_codes: List[ProgCode]
-    input_params: NamedItemList[InputParam]
-    output_params: NamedItemList[OutputParam]
-    neg_output_params: NamedItemList[NegOutputParam]
+    prog_codes: list[ProgCode] = field(default_factory=list)
+    input_params: NamedItemList[InputParam] = field(default_factory=NamedItemList)
+    output_params: NamedItemList[OutputParam] = field(default_factory=NamedItemList)
+    neg_output_params: NamedItemList[NegOutputParam] = field(default_factory=NamedItemList)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SingleEcuJob":
-        kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SingleEcuJob":
+        kwargs = dataclass_fields_asdict(DiagComm.from_et(et_element, context))
 
         prog_codes = [
-            ProgCode.from_et(pc_elem, doc_frags)
+            ProgCode.from_et(pc_elem, context)
             for pc_elem in et_element.iterfind("PROG-CODES/PROG-CODE")
         ]
 
         input_params = NamedItemList([
-            InputParam.from_et(el, doc_frags)
+            InputParam.from_et(el, context)
             for el in et_element.iterfind("INPUT-PARAMS/INPUT-PARAM")
         ])
         output_params = NamedItemList([
-            OutputParam.from_et(el, doc_frags)
+            OutputParam.from_et(el, context)
             for el in et_element.iterfind("OUTPUT-PARAMS/OUTPUT-PARAM")
         ])
         neg_output_params = NamedItemList([
-            NegOutputParam.from_et(el, doc_frags)
+            NegOutputParam.from_et(el, context)
             for el in et_element.iterfind("NEG-OUTPUT-PARAMS/NEG-OUTPUT-PARAM")
         ])
 
@@ -64,7 +65,7 @@ class SingleEcuJob(DiagComm):
             neg_output_params=neg_output_params,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = super()._build_odxlinks()
 
         for prog_code in self.prog_codes:

odxtools/snrefcontext.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
     from .database import Database
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
     from .statechart import StateChart
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SnRefContext:
     """Represents the context for which a short name reference ought
     to be resolved
@@ -25,5 +25,5 @@ class SnRefContext:
     single_ecu_job: Optional["SingleEcuJob"] = None
     request: Optional["Request"] = None
     response: Optional["Response"] = None
-    parameters: Optional[List["Parameter"]] = None
+    parameters: list["Parameter"] | None = None
     state_chart: Optional["StateChart"] = None

odxtools/specialdata.py

@@ -1,21 +1,22 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SpecialData:
     """This corresponds to the SD XML tag"""
-    semantic_info: Optional[str]  # the "SI" attribute
-    text_identifier: Optional[str]  # the "TI" attribute, specifies the language used
+    semantic_info: str | None = None  # the "SI" attribute
+    text_identifier: str | None = None  # the "TI" attribute, specifies the language used
     value: str
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SpecialData":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SpecialData":
         semantic_info = et_element.get("SI")
         text_identifier = et_element.get("TI")
         value = et_element.text or ""
@@ -23,7 +24,7 @@ class SpecialData:
         return SpecialData(
             semantic_info=semantic_info, text_identifier=text_identifier, value=value)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/specialdatagroup.py

@@ -1,43 +1,43 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from dataclasses import dataclass, field
+from typing import Any, Union
 from xml.etree import ElementTree
 
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .snrefcontext import SnRefContext
 from .specialdata import SpecialData
 from .specialdatagroupcaption import SpecialDataGroupCaption
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SpecialDataGroup:
     """This corresponds to the SDG XML tag"""
-    sdg_caption: Optional[SpecialDataGroupCaption]
-    sdg_caption_ref: Optional[OdxLinkRef]
-    values: List[Union["SpecialDataGroup", SpecialData]]
-    semantic_info: Optional[str]  # the "SI" attribute
+    sdg_caption: SpecialDataGroupCaption | None = None
+    sdg_caption_ref: OdxLinkRef | None = None
+    values: list[Union["SpecialDataGroup", SpecialData]] = field(default_factory=list)
+    semantic_info: str | None = None  # the "SI" attribute
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SpecialDataGroup":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SpecialDataGroup":
 
         sdg_caption = None
         if caption_elem := et_element.find("SDG-CAPTION"):
-            sdg_caption = SpecialDataGroupCaption.from_et(caption_elem, doc_frags)
+            sdg_caption = SpecialDataGroupCaption.from_et(caption_elem, context)
 
         sdg_caption_ref = None
         if (caption_ref_elem := et_element.find("SDG-CAPTION-REF")) is not None:
-            sdg_caption_ref = OdxLinkRef.from_et(caption_ref_elem, doc_frags)
+            sdg_caption_ref = OdxLinkRef.from_et(caption_ref_elem, context)
 
         semantic_info = et_element.get("SI")
 
-        values: List[Union[SpecialData, SpecialDataGroup]] = []
+        values: list[SpecialData | SpecialDataGroup] = []
         for value_elem in et_element:
-            next_entry: Optional[Union[SpecialData, SpecialDataGroup]] = None
+            next_entry: SpecialData | SpecialDataGroup | None = None
             if value_elem.tag == "SDG":
-                next_entry = SpecialDataGroup.from_et(value_elem, doc_frags)
+                next_entry = SpecialDataGroup.from_et(value_elem, context)
             elif value_elem.tag == "SD":
-                next_entry = SpecialData.from_et(value_elem, doc_frags)
+                next_entry = SpecialData.from_et(value_elem, context)
 
             if next_entry is not None:
                 values.append(next_entry)
@@ -49,7 +49,7 @@ class SpecialDataGroup:
             values=values,
         )
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         if self.sdg_caption_ref is None and self.sdg_caption is not None:

odxtools/specialdatagroupcaption.py

@@ -1,25 +1,26 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SpecialDataGroupCaption(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SpecialDataGroupCaption":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+                context: OdxDocContext) -> "SpecialDataGroupCaption":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         return SpecialDataGroupCaption(**kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
         result[self.odx_id] = self

odxtools/standardlengthtype.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Literal, Optional
+from typing import Literal
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,17 +9,17 @@ from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import AtomicOdxType, BytesTypes, DataType, odxstr_to_bool
 from .utils import dataclass_fields_asdict, read_hex_binary
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StandardLengthType(DiagCodedType):
 
     bit_length: int
-    bit_mask: Optional[int]
-    is_condensed_raw: Optional[bool]
+    bit_mask: int | None = None
+    is_condensed_raw: bool | None = None
 
     @property
     def dct_type(self) -> DctType:
@@ -31,9 +31,8 @@ class StandardLengthType(DiagCodedType):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "StandardLengthType":
-        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StandardLengthType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, context))
 
         bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
         bit_mask = read_hex_binary(et_element.find("BIT-MASK"))
@@ -50,7 +49,7 @@ class StandardLengthType(DiagCodedType):
                 'Can not apply a bit_mask on a value of type {self.base_data_type}',
             )
 
-    def __get_used_mask(self, internal_value: AtomicOdxType) -> Optional[bytes]:
+    def __get_used_mask(self, internal_value: AtomicOdxType) -> bytes | None:
         """Returns a byte field where all bits that are used by the
         DiagCoded type are set and all unused ones are not set.
 
@@ -72,11 +71,7 @@ class StandardLengthType(DiagCodedType):
         if self.is_condensed:
             # if a condensed bitmask is specified, the number of bits
             # set to one in the bit mask are used in the PDU
-
-            # TODO: this is pretty slow. replace it by
-            # `self.bit_mask.bit_count()` once we require python >=
-            # 3.10.
-            bit_sz = bin(self.bit_mask).count("1")
+            bit_sz = self.bit_mask.bit_count()
             used_mask = (1 << bit_sz) - 1
 
             return used_mask.to_bytes((bit_sz + 7) // 8, endianness)
@@ -118,7 +113,7 @@ class StandardLengthType(DiagCodedType):
                 mask_bit += 1
 
             if isinstance(internal_value, BytesTypes):
-                return result.to_bytes(len(internal_value), 'big')
+                return result.to_bytes(len(bytes(internal_value)), 'big')
 
             return result
 
@@ -156,7 +151,7 @@ class StandardLengthType(DiagCodedType):
                 mask_bit += 1
 
             if isinstance(raw_value, BytesTypes):
-                return result.to_bytes(len(raw_value), 'big')
+                return result.to_bytes(len(bytes(raw_value)), 'big')
 
             return result
         if isinstance(raw_value, int):
@@ -164,17 +159,14 @@ class StandardLengthType(DiagCodedType):
         if isinstance(raw_value, BytesTypes):
             int_value = int.from_bytes(raw_value, 'big')
             int_value &= self.bit_mask
-            return int_value.to_bytes(len(raw_value), 'big')
+            return int_value.to_bytes(len(bytes(raw_value)), 'big')
 
         odxraise(f'Can not apply a bit_mask on a value of type {type(raw_value)}')
         return raw_value
 
-    def get_static_bit_length(self) -> Optional[int]:
+    def get_static_bit_length(self) -> int | None:
         if self.bit_mask is not None and self.is_condensed:
-            # TODO: this is pretty slow. replace it by
-            # `self.bit_mask.bit_count()` once we require python >=
-            # 3.10.
-            return bin(self.bit_mask).count("1")
+            return self.bit_mask.bit_count()
 
         return self.bit_length
 

odxtools/state.py

@@ -1,27 +1,28 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Dict, List
+from typing import Any
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class State(IdentifiableElement):
     """
     Corresponds to STATE.
     """
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "State":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "State":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         return State(**kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {self.odx_id: self}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None: