odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/comparamspec.py

@@ -1,66 +1,39 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List
 from xml.etree import ElementTree
 
-from .admindata import AdminData
-from .companydata import CompanyData
-from .createcompanydatas import create_company_datas_from_et
-from .createsdgs import create_sdgs_from_et
-from .element import IdentifiableElement
-from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .protstack import ProtStack
-from .specialdatagroup import SpecialDataGroup
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+    from .database import Database
 
 
 @dataclass
-class ComparamSpec(IdentifiableElement):
-    admin_data: Optional[AdminData]
-    company_datas: NamedItemList[CompanyData]
-    sdgs: List[SpecialDataGroup]
+class ComparamSpec(OdxCategory):
     prot_stacks: NamedItemList[ProtStack]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "ComparamSpec":
 
-        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
-        doc_frags = [OdxDocFragment(short_name, str(et_element.tag))]
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="COMPARAM-SPEC")
+        doc_frags = cat.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(cat)
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        company_datas = create_company_datas_from_et(et_element.find("COMPANY-DATAS"), doc_frags)
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
         prot_stacks = NamedItemList([
             ProtStack.from_et(dl_element, doc_frags)
             for dl_element in et_element.iterfind("PROT-STACKS/PROT-STACK")
         ])
 
-        return ComparamSpec(
-            admin_data=admin_data,
-            company_datas=company_datas,
-            sdgs=sdgs,
-            prot_stacks=prot_stacks,
-            **kwargs)
+        return ComparamSpec(prot_stacks=prot_stacks, **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        odxlinks: Dict[OdxLinkId, Any] = {}
-        if self.odx_id is not None:
-            odxlinks[self.odx_id] = self
-
-        if self.admin_data is not None:
-            odxlinks.update(self.admin_data._build_odxlinks())
-
-        for cd in self.company_datas:
-            odxlinks.update(cd._build_odxlinks())
-
-        for sdg in self.sdgs:
-            odxlinks.update(sdg._build_odxlinks())
+        odxlinks = super()._build_odxlinks()
 
         for ps in self.prot_stacks:
             odxlinks.update(ps._build_odxlinks())
@@ -68,27 +41,16 @@ class ComparamSpec(IdentifiableElement):
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
-        if self.admin_data is not None:
-            self.admin_data._resolve_odxlinks(odxlinks)
-
-        for cd in self.company_datas:
-            cd._resolve_odxlinks(odxlinks)
-
-        for sdg in self.sdgs:
-            sdg._resolve_odxlinks(odxlinks)
+        super()._resolve_odxlinks(odxlinks)
 
         for ps in self.prot_stacks:
             ps._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(diag_layer)
-
-        for cd in self.company_datas:
-            cd._resolve_snrefs(diag_layer)
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
 
-        for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
         for ps in self.prot_stacks:
-            ps._resolve_snrefs(diag_layer)
+            ps._resolve_snrefs(context)

odxtools/comparamsubset.py

@@ -3,49 +3,39 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .admindata import AdminData
-from .companydata import CompanyData
 from .comparam import Comparam
 from .complexcomparam import ComplexComparam
-from .createcompanydatas import create_company_datas_from_et
-from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
-from .element import IdentifiableElement
-from .exceptions import odxrequire
 from .nameditemlist import NamedItemList
+from .odxcategory import OdxCategory
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
-from .specialdatagroup import SpecialDataGroup
+from .snrefcontext import SnRefContext
 from .unitspec import UnitSpec
 from .utils import dataclass_fields_asdict
 
 if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+    from .database import Database
 
 
 @dataclass
-class ComparamSubset(IdentifiableElement):
-    # mandatory in ODX 2.2, but non existent in ODX 2.0
+class ComparamSubset(OdxCategory):
+    # mandatory in ODX 2.2, but non-existent in ODX 2.0
     category: Optional[str]
-    data_object_props: NamedItemList[DataObjectProperty]
+
     comparams: NamedItemList[Comparam]
     complex_comparams: NamedItemList[ComplexComparam]
+    data_object_props: NamedItemList[DataObjectProperty]
     unit_spec: Optional[UnitSpec]
-    admin_data: Optional[AdminData]
-    company_datas: NamedItemList[CompanyData]
-    sdgs: List[SpecialDataGroup]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "ComparamSubset":
 
-        category = et_element.get("CATEGORY")
-
-        short_name = odxrequire(et_element.findtext("SHORT-NAME"))
-        doc_frags = [OdxDocFragment(short_name, str(et_element.tag))]
-        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+        cat = OdxCategory.category_from_et(et_element, doc_frags, doc_type="COMPARAM-SUBSET")
+        doc_frags = cat.odx_id.doc_fragments
+        kwargs = dataclass_fields_asdict(cat)
 
-        admin_data = AdminData.from_et(et_element.find("ADMIN-DATA"), doc_frags)
-        company_datas = create_company_datas_from_et(et_element.find("COMPANY-DATAS"), doc_frags)
+        category = et_element.get("CATEGORY")
 
         data_object_props = NamedItemList([
             DataObjectProperty.from_et(el, doc_frags)
@@ -62,23 +52,16 @@ class ComparamSubset(IdentifiableElement):
         else:
             unit_spec = None
 
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
-
         return ComparamSubset(
             category=category,
-            admin_data=admin_data,
-            company_datas=company_datas,
             data_object_props=data_object_props,
             comparams=comparams,
             complex_comparams=complex_comparams,
             unit_spec=unit_spec,
-            sdgs=sdgs,
             **kwargs)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
-        odxlinks: Dict[OdxLinkId, Any] = {}
-        if self.odx_id is not None:
-            odxlinks[self.odx_id] = self
+        odxlinks = super()._build_odxlinks()
 
         for dop in self.data_object_props:
             odxlinks[dop.odx_id] = dop
@@ -92,19 +75,11 @@ class ComparamSubset(IdentifiableElement):
         if self.unit_spec:
             odxlinks.update(self.unit_spec._build_odxlinks())
 
-        if self.admin_data is not None:
-            odxlinks.update(self.admin_data._build_odxlinks())
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                odxlinks.update(cd._build_odxlinks())
-
-        for sdg in self.sdgs:
-            odxlinks.update(sdg._build_odxlinks())
-
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
         for dop in self.data_object_props:
             dop._resolve_odxlinks(odxlinks)
 
@@ -117,35 +92,20 @@ class ComparamSubset(IdentifiableElement):
         if self.unit_spec:
             self.unit_spec._resolve_odxlinks(odxlinks)
 
-        if self.admin_data is not None:
-            self.admin_data._resolve_odxlinks(odxlinks)
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                cd._resolve_odxlinks(odxlinks)
+    def _finalize_init(self, database: "Database", odxlinks: OdxLinkDatabase) -> None:
+        super()._finalize_init(database, odxlinks)
 
-        for sdg in self.sdgs:
-            sdg._resolve_odxlinks(odxlinks)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
         for dop in self.data_object_props:
-            dop._resolve_snrefs(diag_layer)
+            dop._resolve_snrefs(context)
 
         for comparam in self.comparams:
-            comparam._resolve_snrefs(diag_layer)
+            comparam._resolve_snrefs(context)
 
         for ccomparam in self.complex_comparams:
-            ccomparam._resolve_snrefs(diag_layer)
+            ccomparam._resolve_snrefs(context)
 
         if self.unit_spec:
-            self.unit_spec._resolve_snrefs(diag_layer)
-
-        if self.admin_data is not None:
-            self.admin_data._resolve_snrefs(diag_layer)
-
-        if self.company_datas is not None:
-            for cd in self.company_datas:
-                cd._resolve_snrefs(diag_layer)
-
-        for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            self.unit_spec._resolve_snrefs(context)

odxtools/complexcomparam.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 from xml.etree import ElementTree
 
 from .basecomparam import BaseComparam
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 ComplexValue = List[Union[str, "ComplexValue"]]
 
 
@@ -93,7 +91,7 @@ class ComplexComparam(BaseComparam):
         for subparam in self.subparams:
             subparam._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
         for subparam in self.subparams:
-            subparam._resolve_snrefs(diag_layer)
+            subparam._resolve_snrefs(context)

odxtools/compumethods/compucodecompumethod.py

@@ -0,0 +1,63 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional, cast
+from xml.etree import ElementTree
+
+from ..exceptions import DecodeError, EncodeError, odxassert, odxraise
+from ..odxlink import OdxDocFragment
+from ..odxtypes import AtomicOdxType, DataType
+from ..progcode import ProgCode
+from ..utils import dataclass_fields_asdict
+from .compumethod import CompuCategory, CompuMethod
+
+
+@dataclass
+class CompuCodeCompuMethod(CompuMethod):
+    """A compu method specifies the tranfer functions using Java bytecode
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.9.
+    """
+
+    @property
+    def internal_to_phys_code(self) -> Optional[ProgCode]:
+        if self.compu_internal_to_phys is None:
+            return None
+
+        return self.compu_internal_to_phys.prog_code
+
+    @property
+    def phys_to_internal_code(self) -> Optional[ProgCode]:
+        if self.compu_phys_to_internal is None:
+            return None
+
+        return self.compu_phys_to_internal.prog_code
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType,
+                             physical_type: DataType) -> "CompuCodeCompuMethod":
+        cm = CompuMethod.compu_method_from_et(
+            et_element, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        kwargs = dataclass_fields_asdict(cm)
+
+        return CompuCodeCompuMethod(**kwargs)
+
+    def __post_init__(self) -> None:
+        odxassert(self.category == CompuCategory.COMPUCODE,
+                  "CompuCodeCompuMethod must exhibit COMPUCODE category")
+
+    def convert_internal_to_physical(self, internal_value: AtomicOdxType) -> AtomicOdxType:
+        odxraise(r"CompuCodeCompuMethod cannot be executed by odxtools", DecodeError)
+        return cast(AtomicOdxType, None)
+
+    def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
+        odxraise(r"CompuCodeCompuMethod cannot be executed by odxtools", EncodeError)
+        return cast(AtomicOdxType, None)
+
+    def is_valid_physical_value(self, physical_value: AtomicOdxType) -> bool:
+        # CompuCodeCompuMethod cannot be executed by odxtools
+        return False
+
+    def is_valid_internal_value(self, internal_value: AtomicOdxType) -> bool:
+        # CompuCodeCompuMethod cannot be executed by odxtools
+        return False

odxtools/compumethods/compuconst.py

@@ -0,0 +1,31 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Optional
+from xml.etree import ElementTree
+
+from ..odxtypes import AtomicOdxType, DataType
+
+
+@dataclass
+class CompuConst:
+    v: Optional[str]
+    vt: Optional[str]
+
+    data_type: DataType
+
+    @staticmethod
+    def compuvalue_from_et(et_element: ElementTree.Element, *, data_type: DataType) -> "CompuConst":
+
+        v = et_element.findtext("V")
+        vt = et_element.findtext("VT")
+
+        return CompuConst(v=v, vt=vt, data_type=data_type)
+
+    def __post_init__(self) -> None:
+        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/compudefaultvalue.py

@@ -0,0 +1,27 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Optional
+from xml.etree import ElementTree
+
+from ..odxtypes import DataType
+from ..utils import dataclass_fields_asdict
+from .compuconst import CompuConst
+from .compuinversevalue import CompuInverseValue
+
+
+@dataclass
+class CompuDefaultValue(CompuConst):
+    compu_inverse_value: Optional[CompuInverseValue]
+
+    @staticmethod
+    def compuvalue_from_et(et_element: ElementTree.Element, *,
+                           data_type: DataType) -> "CompuDefaultValue":
+        kwargs = dataclass_fields_asdict(
+            CompuConst.compuvalue_from_et(et_element, data_type=data_type))
+
+        compu_inverse_value = None
+        if (civ_elem := et_element.find("COMPU-INVERSE-VALUE")) is not None:
+            compu_inverse_value = CompuInverseValue.compuvalue_from_et(
+                civ_elem, data_type=data_type)
+
+        return CompuDefaultValue(**kwargs, compu_inverse_value=compu_inverse_value)

odxtools/compumethods/compuinternaltophys.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxtypes import DataType
+from ..progcode import ProgCode
+from ..snrefcontext import SnRefContext
+from .compudefaultvalue import CompuDefaultValue
+from .compuscale import CompuScale
+
+
+@dataclass
+class CompuInternalToPhys:
+    compu_scales: List[CompuScale]
+    prog_code: Optional[ProgCode]
+    compu_default_value: Optional[CompuDefaultValue]
+
+    @staticmethod
+    def compu_internal_to_phys_from_et(et_element: ElementTree.Element,
+                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       physical_type: DataType) -> "CompuInternalToPhys":
+        compu_scales = [
+            CompuScale.compuscale_from_et(
+                cse, doc_frags, domain_type=internal_type, range_type=physical_type)
+            for cse in et_element.iterfind("COMPU-SCALES/COMPU-SCALE")
+        ]
+
+        prog_code = None
+        if (pce := et_element.find("PROG-CODE")) is not None:
+            prog_code = ProgCode.from_et(pce, doc_frags)
+
+        compu_default_value = None
+        if (cdve := et_element.find("COMPU-DEFAULT-VALUE")) is not None:
+            compu_default_value = CompuDefaultValue.compuvalue_from_et(
+                cdve, data_type=physical_type)
+
+        return CompuInternalToPhys(
+            compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.prog_code is not None:
+            result.update(self.prog_code._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.prog_code is not None:
+            self.prog_code._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.prog_code is not None:
+            self.prog_code._resolve_snrefs(context)

odxtools/compumethods/compuinversevalue.py

@@ -0,0 +1,7 @@
+# SPDX-License-Identifier: MIT
+
+from .compuconst import CompuConst
+
+# make CompuInverseValue an alias for CompuConst. The XSD defines two
+# separate but identical groups for this (why?)...
+CompuInverseValue = CompuConst

odxtools/compumethods/compumethod.py

@@ -1,28 +1,107 @@
 # SPDX-License-Identifier: MIT
-import abc
 from dataclasses import dataclass
-from typing import Literal
+from enum import Enum
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
 
+from ..exceptions import odxraise
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType
+from ..snrefcontext import SnRefContext
+from .compuinternaltophys import CompuInternalToPhys
+from .compuphystointernal import CompuPhysToInternal
 
-CompuMethodCategory = Literal[
-    "IDENTICAL",
-    "LINEAR",
-    "SCALE-LINEAR",
-    "TAB-INTP",
-    "TEXTTABLE",
-]
+
+class CompuCategory(Enum):
+    IDENTICAL = "IDENTICAL"
+    LINEAR = "LINEAR"
+    SCALE_LINEAR = "SCALE-LINEAR"
+    TEXTTABLE = "TEXTTABLE"
+    COMPUCODE = "COMPUCODE"
+    TAB_INTP = "TAB-INTP"
+    RAT_FUNC = "RAT-FUNC"
+    SCALE_RAT_FUNC = "SCALE-RAT-FUNC"
 
 
 @dataclass
-class CompuMethod(abc.ABC):
-    internal_type: DataType
+class CompuMethod:
+    """A compu method translates between the internal representation
+    of a value and their physical representation.
+
+    There are many compu methods, but all of them are specified using
+    the same mechanism: The conversion from internal to physical
+    quantities is specified using the COMPU-INTERNAL-TO-PHYS subtag,
+    and the inverse is covered by
+    COMPU-PHYS-TO-INTERNAL. Alternatively to directly specifying the
+    parameters needed for conversion, it is also possible to specify a
+    Java program which does the conversion (doing this excludes using
+    ODX in non-Java contexts, though).
+
+    For details, refer to ASAM specification MCD-2 D (ODX), section 7.3.6.6.
+
+    """
+
+    category: CompuCategory
+    compu_internal_to_phys: Optional[CompuInternalToPhys]
+    compu_phys_to_internal: Optional[CompuPhysToInternal]
+
     physical_type: DataType
+    internal_type: DataType
+
+    @staticmethod
+    def compu_method_from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment], *,
+                             internal_type: DataType, physical_type: DataType) -> "CompuMethod":
+        cat_text = et_element.findtext("CATEGORY")
+        if cat_text is None:
+            odxraise("No category specified for compu method")
+            cat_text = "IDENTICAL"
+
+        try:
+            category = CompuCategory(cat_text)
+        except ValueError:
+            odxraise(f"Encountered compu method of unknown category '{cat_text}'")
+            category = CompuCategory.IDENTICAL
+
+        compu_internal_to_phys = None
+        if (citp_elem := et_element.find("COMPU-INTERNAL-TO-PHYS")) is not None:
+            compu_internal_to_phys = CompuInternalToPhys.compu_internal_to_phys_from_et(
+                citp_elem, doc_frags, internal_type=internal_type, physical_type=physical_type)
+        compu_phys_to_internal = None
+        if (cpti_elem := et_element.find("COMPU-PHYS-TO-INTERNAL")) is not None:
+            compu_phys_to_internal = CompuPhysToInternal.compu_phys_to_internal_from_et(
+                cpti_elem, doc_frags, internal_type=internal_type, physical_type=physical_type)
+
+        return CompuMethod(
+            category=category,
+            compu_internal_to_phys=compu_internal_to_phys,
+            compu_phys_to_internal=compu_phys_to_internal,
+            physical_type=physical_type,
+            internal_type=internal_type)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.compu_internal_to_phys is not None:
+            result.update(self.compu_internal_to_phys._build_odxlinks())
+
+        if self.compu_phys_to_internal is not None:
+            result.update(self.compu_phys_to_internal._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.compu_internal_to_phys is not None:
+            self.compu_internal_to_phys._resolve_odxlinks(odxlinks)
+
+        if self.compu_phys_to_internal is not None:
+            self.compu_phys_to_internal._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.compu_internal_to_phys is not None:
+            self.compu_internal_to_phys._resolve_snrefs(context)
 
-    @property
-    @abc.abstractmethod
-    def category(self) -> CompuMethodCategory:
-        pass
+        if self.compu_phys_to_internal is not None:
+            self.compu_phys_to_internal._resolve_snrefs(context)
 
     def convert_physical_to_internal(self, physical_value: AtomicOdxType) -> AtomicOdxType:
         raise NotImplementedError()

odxtools/compumethods/compuphystointernal.py

@@ -0,0 +1,56 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+from xml.etree import ElementTree
+
+from ..odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from ..odxtypes import DataType
+from ..progcode import ProgCode
+from ..snrefcontext import SnRefContext
+from .compudefaultvalue import CompuDefaultValue
+from .compuscale import CompuScale
+
+
+@dataclass
+class CompuPhysToInternal:
+    compu_scales: List[CompuScale]
+    prog_code: Optional[ProgCode]
+    compu_default_value: Optional[CompuDefaultValue]
+
+    @staticmethod
+    def compu_phys_to_internal_from_et(et_element: ElementTree.Element,
+                                       doc_frags: List[OdxDocFragment], *, internal_type: DataType,
+                                       physical_type: DataType) -> "CompuPhysToInternal":
+        compu_scales = [
+            CompuScale.compuscale_from_et(
+                cse, doc_frags, domain_type=physical_type, range_type=internal_type)
+            for cse in et_element.iterfind("COMPU-SCALES/COMPU-SCALE")
+        ]
+
+        prog_code = None
+        if (pce := et_element.find("PROG-CODE")) is not None:
+            prog_code = ProgCode.from_et(pce, doc_frags)
+
+        compu_default_value = None
+        if (cdve := et_element.find("COMPU-DEFAULT-VALUE")) is not None:
+            compu_default_value = CompuDefaultValue.compuvalue_from_et(
+                cdve, data_type=internal_type)
+
+        return CompuPhysToInternal(
+            compu_scales=compu_scales, prog_code=prog_code, compu_default_value=compu_default_value)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result = {}
+
+        if self.prog_code is not None:
+            result.update(self.prog_code._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        if self.prog_code is not None:
+            self.prog_code._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        if self.prog_code is not None:
+            self.prog_code._resolve_snrefs(context)