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

odxtools/templates/macros/printSubComponent.xml.jinja2

@@ -0,0 +1,104 @@
+{#- -*- mode: sgml; tab-width: 1; indent-tabs-mode: nil -*-
+#
+# SPDX-License-Identifier: MIT
+-#}
+
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printEcuVariantPattern.xml.jinja2') as pevp %}
+
+{%- macro printSubComponentPattern(pat) %}
+<SUB-COMPONENT-PATTERN>
+  <MATCHING-PARAMETERS>
+    {%- for mp in pat.matching_parameters %}
+    {{ pvp.printMatchingParameter(mp)|indent(4) }}
+    {%- endfor %}
+  </MATCHING-PARAMETERS>
+</SUB-COMPONENT-PATTERN>
+{%- endmacro %}
+
+{%- macro printSubComponentParamConnector(conn) %}
+<SUB-COMPONENT-PARAM-CONNECTOR{#- #} {{-peid.printElementIdAttribs(conn)}}>
+  {{ peid.printElementIdSubtags(conn)|indent(2) }}
+  <DIAG-COMM-SNREF {{- make_xml_attrib("SHORT-NAME", conn.diag_comm_snref ) }} />
+  {%- if conn.out_param_if_refs %}
+  <OUT-PARAM-IF-REFS>
+    {%- for snref in conn.out_param_if_refs %}
+    <OUT-PARAM-IF-SNREF SHORT-NAME="{{snref}}" />
+    {%- endfor %}
+  </OUT-PARAM-IF-REFS>
+  {%- endif %}
+  {%- if conn.in_param_if_refs %}
+  <IN-PARAM-IF-REFS>
+    {%- for snref in conn.in_param_if_refs %}
+    <IN-PARAM-IF-SNREF SHORT-NAME="{{snref}}" />
+    {%- endfor %}
+  </IN-PARAM-IF-REFS>
+  {%- endif %}
+</SUB-COMPONENT-PARAM-CONNECTOR>
+{%- endmacro %}
+
+{%- macro printTableRowConnector(conn) %}
+<TABLE-ROW-CONNECTOR>
+  {{ peid.printElementIdSubtags(conn)|indent(2) }}
+  <TABLE-REF ID-REF="{{ conn.table_ref.ref_id }}" />
+  <TABLE-ROW-SNREF {{- make_xml_attrib("SHORT-NAME", conn.table_row_snref ) }} />
+</TABLE-ROW-CONNECTOR>
+{%- endmacro %}
+
+{%- macro printEnvDataConnector(conn) %}
+<ENV-DATA-CONNECTOR>
+  {{ peid.printElementIdSubtags(conn)|indent(2) }}
+  <ENV-DATA-DESC-REF ID-REF="{{ conn.env_data_desc_ref.ref_id }}" />
+  <ENV-DATA-SNREF {{- make_xml_attrib("SHORT-NAME", conn.env_data_snref ) }} />
+</ENV-DATA-CONNECTOR>
+{%- endmacro %}
+
+{%- macro printDtcConnector(conn) %}
+<DTC-CONNECTOR>
+  {{ peid.printElementIdSubtags(conn)|indent(2) }}
+  <DTC-DOP-REF ID-REF="{{ conn.dtc_dop_ref.ref_id }}" />
+  <DOP-SNREF {{- make_xml_attrib("SHORT-NAME", conn.dtc_snref ) }} />
+</DTC-CONNECTOR>
+{%- endmacro %}
+
+{%- macro printSubComponent(sc) %}
+<SUB-COMPONENT{#- #} {{-peid.printElementIdAttribs(sc)}}
+              {{- make_xml_attrib("SEMANTIC", sc.semantic) }}>
+  {{ peid.printElementIdSubtags(sc)|indent(2) }}
+  {%- if sc.sub_component_patterns %}
+  <SUB-COMPONENT-PATTERNS>
+    {%- for scp in sc.sub_component_patterns %}
+    {{ printSubComponentPattern(scp)|indent(4) }}
+    {%- endfor %}
+  </SUB-COMPONENT-PATTERNS>
+  {%- endif %}
+  {%- if sc.sub_component_param_connectors %}
+  <SUB-COMPONENT-PARAM-CONNECTORS>
+    {%- for conn in sc.sub_component_param_connectors %}
+    {{ printSubComponentParamConnector(conn)|indent(4) }}
+    {%- endfor %}
+  </SUB-COMPONENT-PARAM-CONNECTORS>
+  {%- endif %}
+  {%- if sc.table_row_connectors %}
+  <TABLE-ROW-CONNECTORS>
+    {%- for conn in sc.table_row_connectors %}
+    {{ printTableRowConnector(conn)|indent(4) }}
+    {%- endfor %}
+  </TABLE-ROW-CONNECTORS>
+  {%- endif %}
+  {%- if sc.env_data_connectors %}
+  <ENV-DATA-CONNECTORS>
+    {%- for conn in sc.env_data_connectors %}
+    {{ printEnvDataConnector(conn)|indent(4) }}
+    {%- endfor %}
+  </ENV-DATA-CONNECTORS>
+  {%- endif %}
+  {%- if sc.dtc_connectors %}
+  <DTC-CONNECTORS>
+    {%- for conn in sc.dtc_connectors %}
+    {{ printDtcConnector(conn)|indent(4) }}
+    {%- endfor %}
+  </DTC-CONNECTORS>
+  {%- endif %}
+</SUB-COMPONENT>
+{%- endmacro %}

odxtools/templates/macros/printTable.xml.jinja2

@@ -5,9 +5,10 @@
 
 {%- import('macros/printElementId.xml.jinja2') as peid %}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
 
 {%- macro printTable(table) %}
-<TABLE ID="{{table.odx_id.local_id}}"
+<TABLE {{-peid.printElementIdAttribs(table)}}
        {{-make_xml_attrib("SEMANTIC", table.semantic)}}>
  {{ peid.printElementIdSubtags(table)|indent(1) }}
 {%- if table.key_dop_ref %}
@@ -15,15 +16,13 @@
 {%- endif %}
  {%- for table_row in table.table_rows_raw %}
  {%- if hasattr(table_row, "key") %}
- <TABLE-ROW ID="{{table_row.odx_id.local_id}}"
+ <TABLE-ROW {{-peid.printElementIdAttribs(table_row)}}
             {{-make_xml_attrib("SEMANTIC", table_row.semantic)}}>
   <SHORT-NAME>{{table_row.short_name}}</SHORT-NAME>
   {%- if table_row.long_name %}
   <LONG-NAME>{{table_row.long_name|e}}</LONG-NAME>
   {%- endif %}
-  {%- if table_row.description %}
-  <DESC>{{table_row.description}}</DESC>
-  {%- endif %}
+  {{ pd.printDescription(table_row.description) }}
   <KEY>{{table_row.key|e}}</KEY>
   {%- if table_row.dop_ref %}
   <DATA-OBJECT-PROP-REF ID-REF="{{ table_row.dop_ref.ref_id }}" />

odxtools/templates/macros/printUnitSpec.xml.jinja2

@@ -35,8 +35,7 @@
 
 
 {%- macro printUnit(unit) -%}
-<UNIT ID="{{unit.odx_id.local_id}}"
-      {{-make_xml_attrib("OID", unit.oid)}}>
+<UNIT {{-peid.printElementIdAttribs(unit)}}>
  {{ peid.printElementIdSubtags(unit)|indent(1) }}
  <DISPLAY-NAME>{{ unit.display_name }}</DISPLAY-NAME>
  {%- if unit.factor_si_to_unit is not none %}
@@ -52,7 +51,7 @@
 {%- endmacro -%}
 
 {%- macro printUnitGroup(group) -%}
-<UNIT-GROUP {%- if group.oid %} OID="{{group.oid}}" {%- endif %}>
+<UNIT-GROUP {{-make_xml_attrib("OID", group.oid)}}>
  {{ peid.printElementIdSubtags(group)|indent(1) }}
  <CATEGORY>{{ group.category.value }}</CATEGORY>
  {%- if group.unit_refs %}
@@ -66,8 +65,7 @@
 {%- endmacro -%}
 
 {%- macro printPhysicalDimesion(dim) -%}
-<PHYSICAL-DIMENSION ID="{{dim.odx_id.local_id}}"
-                    {{-make_xml_attrib("OID",dim.oid)}}>
+<PHYSICAL-DIMENSION {{-peid.printElementIdAttribs(dim)}}>
  {{ peid.printElementIdSubtags(dim)|indent(1) }}
  {%- if dim.length_exp %}
  <LENGTH-EXP>{{ dim.length_exp }}</LENGTH-EXP>

odxtools/uds.py

@@ -3,8 +3,6 @@ from enum import IntEnum
 from itertools import chain
 from typing import Optional
 
-from deprecation import deprecated
-
 import odxtools.obd as obd
 
 
@@ -62,13 +60,13 @@ _sid_to_name = {
     0x85: "Control DTC Settings",
     0x86: "Response on Event",
     0x87: "Link Control",
-    0x22: "Read Data by Identifier ",
+    0x22: "Read Data by Identifier",
     0x23: "Read Memory by Address",
     0x24: "Read Scaling Data by Identifier",
     0x2a: "Read Data by Periodic Identifier",
     0x2c: "Dynamically Define Data Identifier",
     0x2e: "Write Data by Identifier",
-    0x3d: "Write Memory by Address ",
+    0x3d: "Write Memory by Address",
     0x14: "Clear Diagnostic Information",
     0x19: "Read DTC Information",
     0x2f: "Input Output Control by Identifier",
@@ -170,9 +168,3 @@ def is_response_pending(telegram_payload: bytes, request_sid: Optional[int] = No
 
     # if all of the above applies, we received a "stay tuned" response
     return True
-
-
-# previous versions of odxtools had a typo here. hit happens!
-@deprecated(details="use is_response_pending()")
-def is_reponse_pending(telegram_payload: bytes, request_sid: Optional[int] = None) -> bool:
-    return is_reponse_pending(telegram_payload, request_sid)

odxtools/unit.py

@@ -1,17 +1,15 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 from .exceptions import odxassert, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
 from .physicaldimension import PhysicalDimension
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Unit(IdentifiableElement):
@@ -55,7 +53,6 @@ class Unit(IdentifiableElement):
     ```
     """
     display_name: str
-    oid: Optional[str]
     factor_si_to_unit: Optional[float]
     offset_si_to_unit: Optional[float]
     physical_dimension_ref: Optional[OdxLinkRef]
@@ -66,7 +63,7 @@ class Unit(IdentifiableElement):
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Unit":
         kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
-        oid = et_element.get("OID")
+
         display_name = odxrequire(et_element.findtext("DISPLAY-NAME"))
 
         def read_optional_float(element: ElementTree.Element, name: str) -> Optional[float]:
@@ -82,7 +79,6 @@ class Unit(IdentifiableElement):
 
         return Unit(
             display_name=display_name,
-            oid=oid,
             factor_si_to_unit=factor_si_to_unit,
             offset_si_to_unit=offset_si_to_unit,
             physical_dimension_ref=physical_dimension_ref,
@@ -104,5 +100,5 @@ class Unit(IdentifiableElement):
                 f"The physical_dimension_ref must be resolved to a PhysicalDimension."
                 f" {self.physical_dimension_ref} referenced {self._physical_dimension}")
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/unitgroup.py

@@ -1,19 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from .element import NamedElement
 from .exceptions import odxraise, odxrequire
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .unit import Unit
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 class UnitGroupCategory(Enum):
     COUNTRY = "COUNTRY"
@@ -57,7 +55,7 @@ class UnitGroup(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._units = NamedItemList[Unit]([odxlinks.resolve(ref) for ref in self.unit_refs])
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property

odxtools/unitspec.py

@@ -1,19 +1,16 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Union
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
-from .createsdgs import create_sdgs_from_et
 from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .physicaldimension import PhysicalDimension
+from .snrefcontext import SnRefContext
 from .specialdatagroup import SpecialDataGroup
 from .unit import Unit
 from .unitgroup import UnitGroup
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class UnitSpec:
@@ -28,9 +25,9 @@ class UnitSpec:
     """
 
     # TODO (?): Why are there type errors...
-    unit_groups: Union[NamedItemList[UnitGroup], List[UnitGroup]]
-    units: Union[NamedItemList[Unit], List[Unit]]
-    physical_dimensions: Union[NamedItemList[PhysicalDimension], List[PhysicalDimension]]
+    unit_groups: NamedItemList[UnitGroup]
+    units: NamedItemList[Unit]
+    physical_dimensions: NamedItemList[PhysicalDimension]
     sdgs: List[SpecialDataGroup]
 
     def __post_init__(self) -> None:
@@ -41,15 +38,18 @@ class UnitSpec:
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "UnitSpec":
 
-        unit_groups = [
+        unit_groups = NamedItemList([
             UnitGroup.from_et(el, doc_frags) for el in et_element.iterfind("UNIT-GROUPS/UNIT-GROUP")
-        ]
-        units = [Unit.from_et(el, doc_frags) for el in et_element.iterfind("UNITS/UNIT")]
-        physical_dimensions = [
+        ])
+        units = NamedItemList(
+            [Unit.from_et(el, doc_frags) for el in et_element.iterfind("UNITS/UNIT")])
+        physical_dimensions = NamedItemList([
             PhysicalDimension.from_et(el, doc_frags)
             for el in et_element.iterfind("PHYSICAL-DIMENSIONS/PHYSICAL-DIMENSION")
+        ])
+        sdgs = [
+            SpecialDataGroup.from_et(sdge, doc_frags) for sdge in et_element.iterfind("SDGS/SDG")
         ]
-        sdgs = create_sdgs_from_et(et_element.find("SDGS"), doc_frags)
 
         return UnitSpec(
             unit_groups=unit_groups,
@@ -76,10 +76,10 @@ class UnitSpec:
         for sdg in self.sdgs:
             sdg._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         for unit in self.units:
-            unit._resolve_snrefs(diag_layer)
+            unit._resolve_snrefs(context)
         for group in self.unit_groups:
-            group._resolve_snrefs(diag_layer)
+            group._resolve_snrefs(context)
         for sdg in self.sdgs:
-            sdg._resolve_snrefs(diag_layer)
+            sdg._resolve_snrefs(context)

odxtools/utils.py

@@ -1,32 +1,50 @@
 # SPDX-License-Identifier: MIT
 import dataclasses
 import re
-from typing import Any, Dict, Optional
-from xml.etree import ElementTree
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:
+    from .database import Database
+    from .diaglayers.diaglayer import DiagLayer
+    from .snrefcontext import SnRefContext
+
+
+def retarget_snrefs(database: "Database",
+                    diag_layer: "DiagLayer",
+                    context: Optional["SnRefContext"] = None) -> None:
+    """Re-resolve the short name references reachable by a
+    DiagLayer to this DiagLayer
+
+    This implies that after the SNREFs have been retargeted, accessing
+    the resolved objects via a different diagnostic layer might not be
+    correct. E.g.: If the ECU variants "V1" and "V2" are derived from
+    the base variant "BV", BV defines a short name reference to a data
+    object property called "Foo" and V1 and V2 both define a "Foo"
+    DOP, the reference in the base variant to Foo ought to be resolved
+    differently depending on whether it is accessed via V1 or
+    V2. Since odxtools resolves all references ahead of time, a fixed
+    variant has to be chosen. This method allows to switch the variant
+    to another one.
 
+    """
+    from .snrefcontext import SnRefContext
 
-def create_description_from_et(et_element: Optional[ElementTree.Element],) -> Optional[str]:
-    """Read a description tag.
-
-    The description is located underneath the DESC tag of an an ODX
-    element."""
-
-    if et_element is None:
-        return None
+    if context is None:
+        context = SnRefContext()
 
-    if et_element.tag != "DESC":
-        raise TypeError(f"Attempted to extract an ODX description from a "
-                        f"'{et_element.tag}' XML node. (Must be a 'DESC' node!)")
+    if context.database is None:
+        context.database = database
 
-    # Extract the contents of the tag as a XHTML string.
-    raw_string = et_element.text or ""
-    for e in et_element:
-        raw_string += ElementTree.tostring(e, encoding="unicode")
+    if context.diag_layer is None:
+        context.diag_layer = diag_layer
 
-    # remove white spaces at the beginning and at the end of lines
-    stripped_lines = [x.strip() for x in raw_string.split("\n")]
+    # retarget the objects "owned" by the layer itself
+    diag_layer._resolve_snrefs(context)
 
-    return "\n".join(stripped_lines).strip()
+    # retarget all parents of the current layer (if any)
+    if (parent_refs := getattr(diag_layer, "parent_refs", None)) is not None:
+        for pr in parent_refs:
+            retarget_snrefs(database, pr.layer, context)
 
 
 def dataclass_fields_asdict(obj: Any) -> Dict[str, Any]:

odxtools/variablegroup.py

@@ -0,0 +1,32 @@
+# SPDX-License-Identifier: MIT
+import typing
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List, runtime_checkable
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement, NamedElement
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment
+from .utils import dataclass_fields_asdict
+
+if TYPE_CHECKING:
+    pass
+
+
+@runtime_checkable
+class HasVariableGroups(typing.Protocol):
+
+    @property
+    def variable_groups(self) -> NamedItemList["VariableGroup"]:
+        ...
+
+
+@dataclass
+class VariableGroup(IdentifiableElement):
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "VariableGroup":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        return VariableGroup(**kwargs)

odxtools/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '6.6.1'
-__version_tuple__ = version_tuple = (6, 6, 1)
+__version__ = version = '9.3.0'
+__version_tuple__ = version_tuple = (9, 3, 0)

odxtools/{write_pdx_file.py → writepdxfile.py}

@@ -1,10 +1,11 @@
 # SPDX-License-Identifier: MIT
 import datetime
 import inspect
+import mimetypes
 import os
 import time
 import zipfile
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, Optional
 
 import jinja2
 
@@ -60,7 +61,6 @@ __templates_dir = os.path.sep.join([os.path.dirname(__module_filename), "templat
 def write_pdx_file(
     output_file_name: str,
     database: Database,
-    auxiliary_content_specifiers: Optional[List[Tuple[str, bytes]]] = None,
     templates_dir: str = __templates_dir,
 ) -> bool:
     """
@@ -68,9 +68,6 @@ def write_pdx_file(
     """
     global odxdatabase
 
-    if auxiliary_content_specifiers is None:
-        auxiliary_content_specifiers = []
-
     odxdatabase = database
 
     file_index = []
@@ -96,12 +93,18 @@ def write_pdx_file(
                     # are written based on the database)
                     continue
 
-                template_file_mime_type = "text/plain"
+                template_file_mime_type = None
                 if template_file_name.endswith(".odx-cs"):
                     template_file_mime_type = "application/x-asam.odx.odx-cs"
                 elif template_file_name.endswith(".odx-d"):
                     template_file_mime_type = "application/x-asam.odx.odx-d"
 
+                guessed_mime_type, guessed_encoding = mimetypes.guess_type(template_file_name)
+                if template_file_mime_type is None and guessed_mime_type is not None:
+                    template_file_mime_type = guessed_mime_type
+                else:
+                    template_file_mime_type = "application/octet-stream"
+
                 in_path = [root]
                 in_path.append(template_file_name)
                 in_file_name = os.path.sep.join(in_path)
@@ -115,22 +118,29 @@ def write_pdx_file(
                     out_file.write(open(in_file_name, "rb").read())
 
         # write the auxiliary files
-        for output_file_name, data in auxiliary_content_specifiers:
+        for output_file_name, data_file in database.auxiliary_files.items():
             file_cdate = datetime.datetime.fromtimestamp(time.time())
             creation_date = file_cdate.strftime("%Y-%m-%dT%H:%M:%S")
 
-            mime_type = "text/plain"
-            if template_file_name.endswith(".odx-cs"):
+            mime_type = None
+            if output_file_name.endswith(".odx-cs"):
                 mime_type = "application/x-asam.odx.odx-cs"
-            elif template_file_name.endswith(".odx-d"):
+            elif output_file_name.endswith(".odx-d"):
                 mime_type = "application/x-asam.odx.odx-d"
 
+            guessed_mime_type, guessed_encoding = mimetypes.guess_type(output_file_name)
+            if mime_type is None and guessed_mime_type is not None:
+                mime_type = guessed_mime_type
+            else:
+                mime_type = "application/octet-stream"
+
             zf_name = os.path.basename(output_file_name)
             with zf.open(zf_name, "w") as out_file:
                 file_index.append((zf_name, creation_date, mime_type))
-                out_file.write(data)  # type: ignore
+                out_file.write(data_file.read())
 
         jinja_env = jinja2.Environment(loader=jinja2.FileSystemLoader(templates_dir))
+        jinja_env.globals["getattr"] = getattr
         jinja_env.globals["hasattr"] = hasattr
         jinja_env.globals["odxraise"] = jinja2_odxraise_helper
         jinja_env.globals["make_xml_attrib"] = make_xml_attrib
@@ -187,7 +197,7 @@ def write_pdx_file(
 
         # write the index.xml file
         vars["file_index"] = file_index
-        index_tpl = jinja_env.get_template("index.xml.xml.jinja2")
+        index_tpl = jinja_env.get_template("index.xml.jinja2")
         text = index_tpl.render(**vars)
         zf.writestr("index.xml", text)
 

odxtools/xdoc.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from .element import NamedElement
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class XDoc(NamedElement):
@@ -45,5 +43,5 @@ class XDoc(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass