odxtools 9.5.0__py3-none-any.whl → 9.6.0__py3-none-any.whl

odxtools/additionalaudience.py

@@ -18,9 +18,9 @@ class AdditionalAudience(IdentifiableElement):
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "AdditionalAudience":
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
 
-        return AdditionalAudience(
-            **dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags)))
+        return AdditionalAudience(**kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return {self.odx_id: self}

odxtools/admindata.py

@@ -43,6 +43,9 @@ class AdminData:
         for cdi in self.company_doc_infos:
             result.update(cdi._build_odxlinks())
 
+        for dr in self.doc_revisions:
+            result.update(dr._build_odxlinks())
+
         return result
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:

odxtools/audience.py

@@ -16,31 +16,27 @@ class Audience:
     disabled_audience_refs: List[OdxLinkRef]
 
     is_supplier_raw: Optional[bool]
+    is_development_raw: Optional[bool]
+    is_manufacturing_raw: Optional[bool]
+    is_aftersales_raw: Optional[bool]
+    is_aftermarket_raw: Optional[bool]
 
     @property
     def is_supplier(self) -> bool:
         return self.is_supplier_raw in [None, True]
 
-    is_development_raw: Optional[bool]
-
     @property
     def is_development(self) -> bool:
         return self.is_development_raw in [None, True]
 
-    is_manufacturing_raw: Optional[bool]
-
     @property
     def is_manufacturing(self) -> bool:
         return self.is_manufacturing_raw in [None, True]
 
-    is_aftersales_raw: Optional[bool]
-
     @property
     def is_aftersales(self) -> bool:
         return self.is_aftersales_raw in [None, True]
 
-    is_aftermarket_raw: Optional[bool]
-
     @property
     def is_aftermarket(self) -> bool:
         return self.is_aftermarket_raw in [None, True]
@@ -66,11 +62,11 @@ class Audience:
             for ref in et_element.iterfind("DISABLED-AUDIENCE-REFS/"
                                            "DISABLED-AUDIENCE-REF")
         ]
-        is_supplier_raw = odxstr_to_bool(et_element.get("IS-SUPPLIER"))
-        is_development_raw = odxstr_to_bool(et_element.get("IS-DEVELOPMENT"))
-        is_manufacturing_raw = odxstr_to_bool(et_element.get("IS-MANUFACTURING"))
-        is_aftersales_raw = odxstr_to_bool(et_element.get("IS-AFTERSALES"))
-        is_aftermarket_raw = odxstr_to_bool(et_element.get("IS-AFTERMARKET"))
+        is_supplier_raw = odxstr_to_bool(et_element.attrib.get("IS-SUPPLIER"))
+        is_development_raw = odxstr_to_bool(et_element.attrib.get("IS-DEVELOPMENT"))
+        is_manufacturing_raw = odxstr_to_bool(et_element.attrib.get("IS-MANUFACTURING"))
+        is_aftersales_raw = odxstr_to_bool(et_element.attrib.get("IS-AFTERSALES"))
+        is_aftermarket_raw = odxstr_to_bool(et_element.attrib.get("IS-AFTERMARKET"))
 
         return Audience(
             enabled_audience_refs=enabled_audience_refs,

odxtools/basecomparam.py

@@ -29,9 +29,8 @@ class Usage(Enum):
 class BaseComparam(IdentifiableElement):
     param_class: str
     cptype: StandardizationLevel
-    # Required in ODX 2.2, missing in ODX 2.0
-    cpusage: Optional[Usage]
     display_level: Optional[int]
+    cpusage: Optional[Usage]  # Required in ODX 2.2, missing in ODX 2.0
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "BaseComparam":

odxtools/basevariantpattern.py

@@ -19,11 +19,6 @@ class BaseVariantPattern(VariantPattern):
     """
     matching_base_variant_parameters: List[MatchingBaseVariantParameter]
 
-    @override
-    def get_matching_parameters(
-            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
-        return self.matching_base_variant_parameters
-
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "BaseVariantPattern":
@@ -36,3 +31,8 @@ class BaseVariantPattern(VariantPattern):
 
         odxassert(len(matching_base_variant_parameters) > 0)  # required by ISO 22901-1 Figure 141
         return BaseVariantPattern(matching_base_variant_parameters=matching_base_variant_parameters)
+
+    @override
+    def get_matching_parameters(
+            self) -> Union[List[MatchingParameter], List[MatchingBaseVariantParameter]]:
+        return self.matching_base_variant_parameters

odxtools/basicstructure.py

@@ -29,8 +29,16 @@ class BasicStructure(ComplexDop):
     data objects. All structure-like objects adhere to the
     `CompositeCodec` type protocol.
     """
-    parameters: NamedItemList[Parameter]
     byte_size: Optional[int]
+    parameters: NamedItemList[Parameter]
+
+    @property
+    def required_parameters(self) -> List[Parameter]:
+        return composite_codec_get_required_parameters(self)
+
+    @property
+    def free_parameters(self) -> List[Parameter]:
+        return composite_codec_get_free_parameters(self)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -38,15 +46,37 @@ class BasicStructure(ComplexDop):
         """Read a BASIC-STRUCTURE."""
         kwargs = dataclass_fields_asdict(ComplexDop.from_et(et_element, doc_frags))
 
+        byte_size_str = et_element.findtext("BYTE-SIZE")
+        byte_size = int(byte_size_str) if byte_size_str is not None else None
         parameters = NamedItemList([
             create_any_parameter_from_et(et_parameter, doc_frags)
             for et_parameter in et_element.iterfind("PARAMS/PARAM")
         ])
 
-        byte_size_str = et_element.findtext("BYTE-SIZE")
-        byte_size = int(byte_size_str) if byte_size_str is not None else None
+        return BasicStructure(byte_size=byte_size, parameters=parameters, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = super()._build_odxlinks()
 
-        return BasicStructure(parameters=parameters, byte_size=byte_size, **kwargs)
+        for param in self.parameters:
+            result.update(param._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        for param in self.parameters:
+            param._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        context.parameters = self.parameters
+
+        super()._resolve_snrefs(context)
+        for param in self.parameters:
+            param._resolve_snrefs(context)
+
+        context.parameters = None
 
     def get_static_bit_length(self) -> Optional[int]:
         # Explicit size was specified, so we do not need to look at
@@ -56,14 +86,6 @@ class BasicStructure(ComplexDop):
 
         return composite_codec_get_static_bit_length(self)
 
-    @property
-    def required_parameters(self) -> List[Parameter]:
-        return composite_codec_get_required_parameters(self)
-
-    @property
-    def free_parameters(self) -> List[Parameter]:
-        return composite_codec_get_free_parameters(self)
-
     def print_free_parameters_info(self) -> None:
         """Return a human readable description of the structure's
         free parameters.
@@ -109,26 +131,3 @@ class BasicStructure(ComplexDop):
             decode_state.cursor_byte_position = orig_pos + self.byte_size
 
         return result
-
-    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        result = super()._build_odxlinks()
-
-        for param in self.parameters:
-            result.update(param._build_odxlinks())
-
-        return result
-
-    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        super()._resolve_odxlinks(odxlinks)
-
-        for param in self.parameters:
-            param._resolve_odxlinks(odxlinks)
-
-    def _resolve_snrefs(self, context: SnRefContext) -> None:
-        context.parameters = self.parameters
-
-        super()._resolve_snrefs(context)
-        for param in self.parameters:
-            param._resolve_snrefs(context)
-
-        context.parameters = None

odxtools/commrelation.py

@@ -77,7 +77,7 @@ class CommRelation:
             warnings.warn("SNPATHREFs are not supported by odxtools yet", OdxWarning, stacklevel=1)
 
         value_type_raw = None
-        if (value_type_str := et_element.get("VALUE-TYPE")) is not None:
+        if (value_type_str := et_element.attrib.get("VALUE-TYPE")) is not None:
             try:
                 value_type_raw = CommRelationValueType(value_type_str)
             except ValueError:
@@ -109,6 +109,7 @@ class CommRelation:
         if not isinstance(service, DiagService):
             odxraise(f"DIAG-VARIABLE references non-service {type(service).__name__} "
                      f"diagnostic communication")
+            return
 
         self._in_param_if = None
         if self.in_param_if_snref is not None:

odxtools/companydata.py

@@ -23,10 +23,10 @@ class CompanyData(IdentifiableElement):
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "CompanyData":
 
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
         roles = []
         if (roles_elem := et_element.find("ROLES")) is not None:
             roles = [odxrequire(role.text) for role in roles_elem.iterfind("ROLE")]
-
         team_members = [
             TeamMember.from_et(tm, doc_frags)
             for tm in et_element.iterfind("TEAM-MEMBERS/TEAM-MEMBER")
@@ -46,7 +46,6 @@ class CompanyData(IdentifiableElement):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {self.odx_id: self}
 
-        # team members
         for tm in self.team_members:
             result.update(tm._build_odxlinks())
 

odxtools/companyspecificinfo.py

@@ -31,6 +31,9 @@ class CompanySpecificInfo:
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {}
 
+        for rd in self.related_docs:
+            result.update(rd._build_odxlinks())
+
         for sdg in self.sdgs:
             result.update(sdg._build_odxlinks())
 

odxtools/comparam.py

@@ -7,28 +7,34 @@ from .basecomparam import BaseComparam
 from .dataobjectproperty import DataObjectProperty
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxtypes import AtomicOdxType
 from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 
 @dataclass
 class Comparam(BaseComparam):
+    physical_default_value_raw: str
     dop_ref: OdxLinkRef
-    physical_default_value: str
+
+    @property
+    def physical_default_value(self) -> AtomicOdxType:
+        return self._physical_default_value
+
+    @property
+    def dop(self) -> DataObjectProperty:
+        """The data object property applicable to this parameter."""
+        return self._dop
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Comparam":
         kwargs = dataclass_fields_asdict(BaseComparam.from_et(et_element, doc_frags))
 
+        physical_default_value_raw = odxrequire(et_element.findtext("PHYSICAL-DEFAULT-VALUE"))
         dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DATA-OBJECT-PROP-REF"), doc_frags))
-        physical_default_value = odxrequire(et_element.findtext("PHYSICAL-DEFAULT-VALUE"))
-
-        return Comparam(dop_ref=dop_ref, physical_default_value=physical_default_value, **kwargs)
 
-    @property
-    def dop(self) -> DataObjectProperty:
-        """The data object property describing this parameter."""
-        return self._dop
+        return Comparam(
+            dop_ref=dop_ref, physical_default_value_raw=physical_default_value_raw, **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         return super()._build_odxlinks()
@@ -38,6 +44,8 @@ class Comparam(BaseComparam):
         super()._resolve_odxlinks(odxlinks)
 
         self._dop = odxlinks.resolve(self.dop_ref, DataObjectProperty)
+        self._physical_default_value = self._dop.physical_type.base_data_type.from_string(
+            self.physical_default_value_raw)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)

odxtools/comparaminstance.py

@@ -26,6 +26,14 @@ class ComparamInstance:
     prot_stack_snref: Optional[str]
     spec_ref: OdxLinkRef
 
+    @property
+    def spec(self) -> BaseComparam:
+        return self._spec
+
+    @property
+    def short_name(self) -> str:
+        return self.spec.short_name
+
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "ComparamInstance":
@@ -44,14 +52,14 @@ class ComparamInstance:
 
         description = Description.from_et(et_element.find("DESC"), doc_frags)
 
-        prot_stack_snref = None
-        if (psnref_elem := et_element.find("PROT-STACK-SNREF")) is not None:
-            prot_stack_snref = psnref_elem.get("SHORT-NAME")
-
         protocol_snref = None
         if (psnref_elem := et_element.find("PROTOCOL-SNREF")) is not None:
             protocol_snref = psnref_elem.get("SHORT-NAME")
 
+        prot_stack_snref = None
+        if (psnref_elem := et_element.find("PROT-STACK-SNREF")) is not None:
+            prot_stack_snref = psnref_elem.get("SHORT-NAME")
+
         return ComparamInstance(
             value=value,
             spec_ref=spec_ref,
@@ -69,10 +77,6 @@ class ComparamInstance:
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
-    @property
-    def spec(self) -> BaseComparam:
-        return self._spec
-
     def get_value(self) -> str:
         """Retrieve the value of a simple communication parameter
 
@@ -135,7 +139,3 @@ class ComparamInstance:
             odxraise()
 
         return result
-
-    @property
-    def short_name(self) -> str:
-        return self.spec.short_name

odxtools/comparamspec.py

@@ -22,9 +22,10 @@ class ComparamSpec(OdxCategory):
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ComparamSpec":
 
-        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=DocType.COMPARAM_SPEC)
-        doc_frags = cat.odx_id.doc_fragments
-        kwargs = dataclass_fields_asdict(cat)
+        base_obj = OdxCategory.category_from_et(
+            et_element, doc_frags, doc_type=DocType.COMPARAM_SPEC)
+        doc_frags = base_obj.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(base_obj)
 
         prot_stacks = NamedItemList([
             ProtStack.from_et(dl_element, doc_frags)

odxtools/comparamsubset.py

@@ -29,51 +29,53 @@ class ComparamSubset(OdxCategory):
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "ComparamSubset":
 
-        category = et_element.get("CATEGORY")
+        category_attrib = et_element.attrib.get("CATEGORY")
 
-        # In ODX 2.0, COMPARAM-SPEC is used, whereas in ODX 2.2, it refers to something else and has been replaced by COMPARAM-SUBSET.
-        # - If 'category' is missing (ODX 2.0), use COMPARAM_SPEC,
+        # In ODX 2.0, COMPARAM-SPEC is used, whereas in ODX 2.2, it
+        # refers to something else and has been replaced by
+        # COMPARAM-SUBSET.
+        # - If the 'CATEGORY' attribute is missing (ODX 2.0), use
+        #   COMPARAM_SPEC,
         # - else (ODX 2.2), use COMPARAM_SUBSET.
-        doc_type = DocType.COMPARAM_SUBSET if category else DocType.COMPARAM_SPEC
-        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type=doc_type)
-        doc_frags = cat.odx_id.doc_fragments
-        kwargs = dataclass_fields_asdict(cat)
+        doc_type = DocType.COMPARAM_SUBSET if category_attrib is not None else DocType.COMPARAM_SPEC
+        base_obj = OdxCategory.category_from_et(et_element, doc_frags, doc_type=doc_type)
+        doc_frags = base_obj.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(base_obj)
 
-        data_object_props = NamedItemList([
-            DataObjectProperty.from_et(el, doc_frags)
-            for el in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
-        ])
         comparams = NamedItemList(
             [Comparam.from_et(el, doc_frags) for el in et_element.iterfind("COMPARAMS/COMPARAM")])
         complex_comparams = NamedItemList([
             ComplexComparam.from_et(el, doc_frags)
             for el in et_element.iterfind("COMPLEX-COMPARAMS/COMPLEX-COMPARAM")
         ])
+        data_object_props = NamedItemList([
+            DataObjectProperty.from_et(el, doc_frags)
+            for el in et_element.iterfind("DATA-OBJECT-PROPS/DATA-OBJECT-PROP")
+        ])
+        unit_spec = None
         if (unit_spec_elem := et_element.find("UNIT-SPEC")) is not None:
             unit_spec = UnitSpec.from_et(unit_spec_elem, doc_frags)
-        else:
-            unit_spec = None
 
         return ComparamSubset(
-            category=category,
-            data_object_props=data_object_props,
+            category=category_attrib,
             comparams=comparams,
             complex_comparams=complex_comparams,
+            data_object_props=data_object_props,
             unit_spec=unit_spec,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
-        for dop in self.data_object_props:
-            odxlinks[dop.odx_id] = dop
-
         for comparam in self.comparams:
             odxlinks.update(comparam._build_odxlinks())
 
         for ccomparam in self.complex_comparams:
             odxlinks.update(ccomparam._build_odxlinks())
 
+        for dop in self.data_object_props:
+            odxlinks[dop.odx_id] = dop
+
         if self.unit_spec:
             odxlinks.update(self.unit_spec._build_odxlinks())
 
@@ -82,15 +84,15 @@ class ComparamSubset(OdxCategory):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
-        for dop in self.data_object_props:
-            dop._resolve_odxlinks(odxlinks)
-
         for comparam in self.comparams:
             comparam._resolve_odxlinks(odxlinks)
 
         for ccomparam in self.complex_comparams:
             ccomparam._resolve_odxlinks(odxlinks)
 
+        for dop in self.data_object_props:
+            dop._resolve_odxlinks(odxlinks)
+
         if self.unit_spec:
             self.unit_spec._resolve_odxlinks(odxlinks)
 
@@ -100,14 +102,14 @@ class ComparamSubset(OdxCategory):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         super()._resolve_snrefs(context)
 
-        for dop in self.data_object_props:
-            dop._resolve_snrefs(context)
-
         for comparam in self.comparams:
             comparam._resolve_snrefs(context)
 
         for ccomparam in self.complex_comparams:
             ccomparam._resolve_snrefs(context)
 
+        for dop in self.data_object_props:
+            dop._resolve_snrefs(context)
+
         if self.unit_spec:
             self.unit_spec._resolve_snrefs(context)

odxtools/compumethods/compuconst.py

@@ -13,6 +13,10 @@ class CompuConst:
 
     data_type: DataType
 
+    @property
+    def value(self) -> Optional[AtomicOdxType]:
+        return self._value
+
     @staticmethod
     def compuvalue_from_et(et_element: ElementTree.Element, *, data_type: DataType) -> "CompuConst":
 
@@ -25,7 +29,3 @@ class CompuConst:
         self._value: Optional[AtomicOdxType] = self.vt
         if self.v is not None:
             self._value = self.data_type.from_string(self.v)
-
-    @property
-    def value(self) -> Optional[AtomicOdxType]:
-        return self._value

odxtools/compumethods/limit.py

@@ -21,11 +21,9 @@ class Limit:
     value_type: Optional[DataType]
     interval_type: Optional[IntervalType]
 
-    def __post_init__(self) -> None:
-        self._value: Optional[AtomicOdxType] = None
-
-        if self.value_type is not None:
-            self.set_value_type(self.value_type)
+    @property
+    def value(self) -> Optional[AtomicOdxType]:
+        return self._value
 
     @staticmethod
     @overload
@@ -57,15 +55,17 @@ class Limit:
 
         return Limit(value_raw=value_raw, interval_type=interval_type, value_type=value_type)
 
+    def __post_init__(self) -> None:
+        self._value: Optional[AtomicOdxType] = None
+
+        if self.value_type is not None:
+            self.set_value_type(self.value_type)
+
     def set_value_type(self, value_type: DataType) -> None:
         self.value_type = value_type
         if self.value_raw is not None:
             self._value = value_type.from_string(self.value_raw)
 
-    @property
-    def value(self) -> Optional[AtomicOdxType]:
-        return self._value
-
     def complies_to_upper(self, value: AtomicOdxType) -> bool:
         """Checks if the value is in the range w.r.t. the upper limit.
 

odxtools/compumethods/linearsegment.py

@@ -32,6 +32,14 @@ class LinearSegment:
     internal_type: DataType
     physical_type: DataType
 
+    @property
+    def physical_lower_limit(self) -> Optional[Limit]:
+        return self._physical_lower_limit
+
+    @property
+    def physical_upper_limit(self) -> Optional[Limit]:
+        return self._physical_upper_limit
+
     @staticmethod
     def from_compu_scale(scale: CompuScale, *, internal_type: DataType,
                          physical_type: DataType) -> "LinearSegment":
@@ -64,14 +72,6 @@ class LinearSegment:
             internal_type=internal_type,
             physical_type=physical_type)
 
-    @property
-    def physical_lower_limit(self) -> Optional[Limit]:
-        return self._physical_lower_limit
-
-    @property
-    def physical_upper_limit(self) -> Optional[Limit]:
-        return self._physical_upper_limit
-
     def __post_init__(self) -> None:
         self.__compute_physical_limits()