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

odxtools/statechart.py

@@ -1,40 +1,41 @@
 # 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 .element import IdentifiableElement
 from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .snrefcontext import SnRefContext
 from .state import State
 from .statetransition import StateTransition
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateChart(IdentifiableElement):
     """
     Corresponds to STATE-CHART.
     """
     semantic: str
-    state_transitions: List[StateTransition]
+    state_transitions: list[StateTransition] = field(default_factory=list)
     start_state_snref: str
-    states: NamedItemList[State]
+    states: NamedItemList[State] = field(default_factory=NamedItemList)
 
     @property
     def start_state(self) -> State:
         return self._start_state
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StateChart":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StateChart":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         semantic: str = odxrequire(et_element.findtext("SEMANTIC"))
 
         state_transitions = [
-            StateTransition.from_et(st_elem, doc_frags)
+            StateTransition.from_et(st_elem, context)
             for st_elem in et_element.iterfind("STATE-TRANSITIONS/STATE-TRANSITION")
         ]
 
@@ -42,7 +43,7 @@ class StateChart(IdentifiableElement):
         start_state_snref = start_state_snref_elem.attrib["SHORT-NAME"]
 
         states = [
-            State.from_et(st_elem, doc_frags) for st_elem in et_element.iterfind("STATES/STATE")
+            State.from_et(st_elem, context) for st_elem in et_element.iterfind("STATES/STATE")
         ]
 
         return StateChart(
@@ -52,7 +53,7 @@ class StateChart(IdentifiableElement):
             states=NamedItemList(states),
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
         for strans in self.state_transitions:

odxtools/statemachine.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Generator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Generator, Union
+from typing import TYPE_CHECKING, Any
 
 from .exceptions import odxraise
 from .odxtypes import ParameterValueDict
@@ -12,7 +13,7 @@ if TYPE_CHECKING:
     from .diagservice import DiagService
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateMachine:
     """Objects of this class represent the runtime state of a state chart
 
@@ -97,7 +98,7 @@ class StateMachine:
         self._active_state = state_chart.start_state
 
     def execute(self, service: "DiagService", **service_params: Any
-               ) -> Generator[bytes, Union[bytes, bytearray, ParameterValueDict], None]:
+               ) -> Generator[bytes, bytes | bytearray | ParameterValueDict, None]:
         """Run a diagnostic service and update the state machine
         depending on the outcome.
 

odxtools/statetransition.py

@@ -1,25 +1,26 @@
 # 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 .element import IdentifiableElement
 from .exceptions import odxrequire
 from .externalaccessmethod import ExternalAccessMethod
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .snrefcontext import SnRefContext
 from .state import State
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateTransition(IdentifiableElement):
     """
     Corresponds to STATE-TRANSITION.
     """
     source_snref: str
     target_snref: str
-    external_access_method: Optional[ExternalAccessMethod]
+    external_access_method: ExternalAccessMethod | None = None
 
     @property
     def source_state(self) -> State:
@@ -30,10 +31,9 @@ class StateTransition(IdentifiableElement):
         return self._target_state
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "StateTransition":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StateTransition":
 
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         source_snref_elem = odxrequire(et_element.find("SOURCE-SNREF"))
         source_snref = odxrequire(source_snref_elem.attrib["SHORT-NAME"])
@@ -43,14 +43,14 @@ class StateTransition(IdentifiableElement):
 
         external_access_method = None
         if (eam_elem := et_element.find("EXTERNAL-ACCESS-METHOD")) is not None:
-            external_access_method = ExternalAccessMethod.from_et(eam_elem, doc_frags)
+            external_access_method = ExternalAccessMethod.from_et(eam_elem, context)
         return StateTransition(
             source_snref=source_snref,
             target_snref=target_snref,
             external_access_method=external_access_method,
             **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:

odxtools/statetransitionref.py

@@ -1,12 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Union
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxassert, odxraise, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import ParameterValue, ParameterValueDict
 from .parameters.codedconstparameter import CodedConstParameter
 from .parameters.parameter import Parameter
@@ -27,11 +28,11 @@ if TYPE_CHECKING:
 
 
 def _resolve_in_param(
-    in_param_if_snref: Optional[str],
-    in_param_if_snpathref: Optional[str],
-    params: List[Parameter],
+    in_param_if_snref: str | None,
+    in_param_if_snpathref: str | None,
+    params: list[Parameter],
     param_dict: ParameterValueDict,
-) -> Tuple[Optional[Parameter], Optional[ParameterValue]]:
+) -> tuple[Parameter | None, ParameterValue | None]:
 
     if in_param_if_snref is not None:
         path_chunks = [in_param_if_snref]
@@ -44,10 +45,10 @@ def _resolve_in_param(
 
 
 def _resolve_in_param_helper(
-    params: List[Parameter],
+    params: list[Parameter],
     param_dict: ParameterValueDict,
-    path_chunks: List[str],
-) -> Tuple[Optional[Parameter], Optional[ParameterValue]]:
+    path_chunks: list[str],
+) -> tuple[Parameter | None, ParameterValue | None]:
 
     inner_param = resolve_snref(path_chunks[0], params, Parameter, lenient=True)
     if inner_param is None:
@@ -90,7 +91,7 @@ def _resolve_in_param_helper(
 
 def _check_applies(ref: Union["StateTransitionRef",
                               "PreConditionStateRef"], state_machine: "StateMachine",
-                   params: List[Parameter], param_value_dict: ParameterValueDict) -> bool:
+                   params: list[Parameter], param_value_dict: ParameterValueDict) -> bool:
     if state_machine.active_state != ref.state:
         # if the active state of the state machine is not the
         # specified one, the precondition does not apply
@@ -146,7 +147,7 @@ def _check_applies(ref: Union["StateTransitionRef",
     return True
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StateTransitionRef(OdxLinkRef):
     """Describes a state transition that is to be potentially taken if
     a diagnostic communication is executed
@@ -155,10 +156,10 @@ class StateTransitionRef(OdxLinkRef):
     may also be conditional on the observed response of the ECU.
 
     """
-    value: Optional[str]
+    value: str | None = None
 
-    in_param_if_snref: Optional[str]
-    in_param_if_snpathref: Optional[str]
+    in_param_if_snref: str | None = None
+    in_param_if_snpathref: str | None = None
 
     @property
     def state_transition(self) -> StateTransition:
@@ -170,9 +171,8 @@ class StateTransitionRef(OdxLinkRef):
 
     @staticmethod
     def from_et(  # type: ignore[override]
-            et_element: ElementTree.Element,
-            doc_frags: List[OdxDocFragment]) -> "StateTransitionRef":
-        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, doc_frags))
+            et_element: ElementTree.Element, context: OdxDocContext) -> "StateTransitionRef":
+        kwargs = dataclass_fields_asdict(OdxLinkRef.from_et(et_element, context))
 
         value = et_element.findtext("VALUE")
 
@@ -195,7 +195,7 @@ class StateTransitionRef(OdxLinkRef):
             odxassert(self.in_param_if_snref is not None or self.in_param_if_snref is not None,
                       "If VALUE is specified, a parameter must be referenced")
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
@@ -204,7 +204,7 @@ class StateTransitionRef(OdxLinkRef):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    def execute(self, state_machine: StateMachine, params: List[Parameter],
+    def execute(self, state_machine: StateMachine, params: list[Parameter],
                 param_value_dict: ParameterValueDict) -> bool:
         """Update a StateMachine object if the state transition ought
         to be executed based on the response received after executing a

odxtools/staticfield.py

@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: MIT
+from collections.abc import Sequence
 from dataclasses import dataclass
-from typing import Any, Dict, List, Sequence
+from typing import Any
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -9,13 +10,14 @@ from .decodestate import DecodeState
 from .encodestate import EncodeState
 from .exceptions import odxassert, odxraise, odxrequire
 from .field import Field
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class StaticField(Field):
     """Array of a fixed number of structure objects"""
     fixed_number_of_items: int
@@ -23,8 +25,8 @@ class StaticField(Field):
 
     @staticmethod
     @override
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "StaticField":
-        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "StaticField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, context))
 
         fixed_number_of_items = int(odxrequire(et_element.findtext('FIXED-NUMBER-OF-ITEMS')))
         item_byte_size = int(odxrequire(et_element.findtext('ITEM-BYTE-SIZE')))
@@ -33,7 +35,7 @@ class StaticField(Field):
             fixed_number_of_items=fixed_number_of_items, item_byte_size=item_byte_size, **kwargs)
 
     @override
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
         return odxlinks
 
@@ -89,7 +91,7 @@ class StaticField(Field):
         orig_origin = decode_state.origin_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
-        result: List[ParameterValue] = []
+        result: list[ParameterValue] = []
         for _ in range(self.fixed_number_of_items):
             orig_cursor = decode_state.cursor_byte_position
 

odxtools/structure.py

@@ -1,26 +1,25 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .odxtypes import odxstr_to_bool
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class Structure(BasicStructure):
-    is_visible_raw: Optional[bool]
+    is_visible_raw: bool | None = None
 
     @property
     def is_visible(self) -> bool:
         return self.is_visible_raw in (True, None)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Structure":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "Structure":
         """Read a STRUCTURE element from XML."""
-        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, doc_frags))
+        kwargs = dataclass_fields_asdict(BasicStructure.from_et(et_element, context))
 
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 

odxtools/subcomponent.py

@@ -1,13 +1,14 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from dataclasses import dataclass, field
+from typing import Any
 from xml.etree import ElementTree
 
 from .dtcconnector import DtcConnector
 from .element import IdentifiableElement
 from .envdataconnector import EnvDataConnector
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId
 from .snrefcontext import SnRefContext
 from .subcomponentparamconnector import SubComponentParamConnector
 from .subcomponentpattern import SubComponentPattern
@@ -15,7 +16,7 @@ from .tablerowconnector import TableRowConnector
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SubComponent(IdentifiableElement):
     """Sub-components describe collections of related diagnostic variables
 
@@ -25,38 +26,39 @@ class SubComponent(IdentifiableElement):
 
     """
 
-    sub_component_patterns: List[SubComponentPattern]
-    sub_component_param_connectors: NamedItemList[SubComponentParamConnector]
-    table_row_connectors: NamedItemList[TableRowConnector]
-    env_data_connectors: NamedItemList[EnvDataConnector]
-    dtc_connectors: NamedItemList[DtcConnector]
+    sub_component_patterns: list[SubComponentPattern] = field(default_factory=list)
+    sub_component_param_connectors: NamedItemList[SubComponentParamConnector] = field(
+        default_factory=NamedItemList)
+    table_row_connectors: NamedItemList[TableRowConnector] = field(default_factory=NamedItemList)
+    env_data_connectors: NamedItemList[EnvDataConnector] = field(default_factory=NamedItemList)
+    dtc_connectors: NamedItemList[DtcConnector] = field(default_factory=NamedItemList)
 
-    semantic: Optional[str]
+    semantic: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SubComponent":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SubComponent":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         semantic = et_element.get("SEMANTIC")
 
         sub_component_patterns = [
-            SubComponentPattern.from_et(el, doc_frags)
+            SubComponentPattern.from_et(el, context)
             for el in et_element.iterfind("SUB-COMPONENT-PATTERNS/SUB-COMPONENT-PATTERN")
         ]
         sub_component_param_connectors = [
-            SubComponentParamConnector.from_et(el, doc_frags) for el in et_element.iterfind(
+            SubComponentParamConnector.from_et(el, context) for el in et_element.iterfind(
                 "SUB-COMPONENT-PARAM-CONNECTORS/SUB-COMPONENT-PARAM-CONNECTOR")
         ]
         table_row_connectors = [
-            TableRowConnector.from_et(el, doc_frags)
+            TableRowConnector.from_et(el, context)
             for el in et_element.iterfind("TABLE-ROW-CONNECTORS/TABLE-ROW-CONNECTOR")
         ]
         env_data_connectors = [
-            EnvDataConnector.from_et(el, doc_frags)
+            EnvDataConnector.from_et(el, context)
             for el in et_element.iterfind("ENV-DATA-CONNECTORS/ENV-DATA-CONNECTOR")
         ]
         dtc_connectors = [
-            DtcConnector.from_et(el, doc_frags)
+            DtcConnector.from_et(el, context)
             for el in et_element.iterfind("DTC-CONNECTORS/DTC-CONNECTOR")
         ]
 
@@ -69,7 +71,7 @@ class SubComponent(IdentifiableElement):
             dtc_connectors=NamedItemList(dtc_connectors),
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
 
         for scp in self.sub_component_patterns:

odxtools/subcomponentparamconnector.py

@@ -1,25 +1,26 @@
 # 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 .diagservice import DiagService
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, resolve_snref
+from .odxdoccontext import OdxDocContext
+from .odxlink import OdxLinkDatabase, OdxLinkId, resolve_snref
 from .parameters.parameter import Parameter
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SubComponentParamConnector(IdentifiableElement):
     diag_comm_snref: str
 
     # TODO: we currently only support SNREFs, not SNPATHREFs
-    out_param_if_refs: List[str]
-    in_param_if_refs: List[str]
+    out_param_if_refs: list[str] = field(default_factory=list)
+    in_param_if_refs: list[str] = field(default_factory=list)
 
     @property
     def service(self) -> DiagService:
@@ -35,8 +36,8 @@ class SubComponentParamConnector(IdentifiableElement):
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SubComponentParamConnector":
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+                context: OdxDocContext) -> "SubComponentParamConnector":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, context))
 
         diag_comm_snref = odxrequire(
             odxrequire(et_element.find("DIAG-COMM-SNREF")).get("SHORT-NAME"))
@@ -65,7 +66,7 @@ class SubComponentParamConnector(IdentifiableElement):
             in_param_if_refs=in_param_if_refs,
             **kwargs)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/subcomponentpattern.py

@@ -1,32 +1,32 @@
 # SPDX-License-Identifier: MIT
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, 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
 
 if TYPE_CHECKING:
     from .matchingparameter import MatchingParameter
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SubComponentPattern:
-    matching_parameters: List["MatchingParameter"]
+    matching_parameters: list["MatchingParameter"] = field(default_factory=list)
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element,
-                doc_frags: List[OdxDocFragment]) -> "SubComponentPattern":
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SubComponentPattern":
         from .matchingparameter import MatchingParameter
 
         matching_parameters = [
-            MatchingParameter.from_et(el, doc_frags)
+            MatchingParameter.from_et(el, context)
             for el in et_element.iterfind("MATCHING-PARAMETERS/MATCHING-PARAMETER")
         ]
 
         return SubComponentPattern(matching_parameters=matching_parameters)
 
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+    def _build_odxlinks(self) -> dict[OdxLinkId, Any]:
         result = {}
         for mp in self.matching_parameters:
             result.update(mp._build_odxlinks())

odxtools/swvariable.py

@@ -1,21 +1,20 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import List, Optional
 from xml.etree import ElementTree
 
 from .element import NamedElement
-from .odxlink import OdxDocFragment
+from .odxdoccontext import OdxDocContext
 from .utils import dataclass_fields_asdict
 
 
-@dataclass
+@dataclass(kw_only=True)
 class SwVariable(NamedElement):
-    origin: Optional[str]
-    oid: Optional[str]
+    origin: str | None = None
+    oid: str | None = None
 
     @staticmethod
-    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SwVariable":
-        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+    def from_et(et_element: ElementTree.Element, context: OdxDocContext) -> "SwVariable":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, context))
 
         origin = et_element.findtext("ORIGIN")
         oid = et_element.attrib.get("OID")