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

odxtools/environmentdatadescription.py

@@ -1,36 +1,60 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
+from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
+from .dtcdop import DtcDop
 from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
-from .exceptions import DecodeError, EncodeError, odxrequire
+from .exceptions import odxraise, odxrequire
+from .nameditemlist import NamedItemList
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import ParameterValue
+from .odxtypes import DataType, ParameterValue, ParameterValueDict
+from .parameters.codedconstparameter import CodedConstParameter
+from .parameters.parameter import Parameter
+from .parameters.parameterwithdop import ParameterWithDOP
+from .parameters.physicalconstantparameter import PhysicalConstantParameter
+from .parameters.valueparameter import ValueParameter
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class EnvironmentDataDescription(ComplexDop):
-    """This class represents Environment Data Description, which is a complex DOP
-    that is used to define the interpretation of environment data."""
+    """This class represents environment data descriptions
+
+    An environment data description provides a list of all environment
+    data objects that are potentially applicable to decode a given
+    response. (If a given environment data object is applicable
+    depends on the value of the DtcDOP that is associated with it.)
+
+    """
+
+    param_snref: Optional[str]
+    param_snpathref: Optional[str]
 
     # in ODX 2.0.0, ENV-DATAS seems to be a mandatory
     # sub-element of ENV-DATA-DESC, in ODX 2.2 it is not
     # present
-    env_datas: List[EnvironmentData]
+    env_datas: NamedItemList[EnvironmentData]
     env_data_refs: List[OdxLinkRef]
-    param_snref: Optional[str]
-    param_snpathref: Optional[str]
 
-    def __post_init__(self) -> None:
-        self.bit_length = None
+    @property
+    def param(self) -> Parameter:
+        # the parameter referenced via SNREF cannot be resolved here
+        # because the relevant list of parameters depends on the
+        # concrete codec object processed, whilst an environment data
+        # description object can be featured in an arbitrary number of
+        # responses. Instead, lookup of the appropriate parameter is
+        # done within the encode and decode methods.
+        odxraise("The parameter of ENV-DATA-DESC objects cannot be resolved "
+                 "because it depends on the context")
+        return cast(None, Parameter)
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -44,16 +68,20 @@ class EnvironmentDataDescription(ComplexDop):
         param_snpathref = None
         if (param_snpathref_elem := et_element.find("PARAM-SNPATHREF")) is not None:
             param_snpathref = odxrequire(param_snpathref_elem.get("SHORT-NAME-PATH"))
+
+        # ODX 2.0 mandates ENV-DATA-DESC to contain a list of
+        # ENV-DATAS and no ENV-DATA-REFS while for ODX 2.2 the
+        # situation is reversed. This means that we will create one
+        # empty and one non-empty list here. (Which is which depends
+        # on the version of the standard used by the file.)
         env_data_refs = [
             odxrequire(OdxLinkRef.from_et(env_data_ref, doc_frags))
             for env_data_ref in et_element.iterfind("ENV-DATA-REFS/ENV-DATA-REF")
         ]
-
-        # ODX 2.0.0 says ENV-DATA-DESC could contain a list of ENV-DATAS
-        env_datas = [
+        env_datas = NamedItemList([
             EnvironmentData.from_et(env_data_elem, doc_frags)
             for env_data_elem in et_element.iterfind("ENV-DATAS/ENV-DATA")
-        ]
+        ])
 
         return EnvironmentDataDescription(
             param_snref=param_snref,
@@ -65,8 +93,9 @@ class EnvironmentDataDescription(ComplexDop):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
-        for ed in self.env_datas:
-            odxlinks.update(ed._build_odxlinks())
+        if not self.env_data_refs:
+            for ed in self.env_datas:
+                odxlinks.update(ed._build_odxlinks())
 
         return odxlinks
 
@@ -74,35 +103,166 @@ class EnvironmentDataDescription(ComplexDop):
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
-            self.env_datas = [odxlinks.resolve(x) for x in self.env_data_refs]
+            self.env_datas = NamedItemList([odxlinks.resolve(x) for x in self.env_data_refs])
         else:
             for ed in self.env_datas:
                 ed._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         # ODX 2.0 specifies environment data objects here, ODX 2.2
         # uses references
         if self.env_data_refs:
             for ed in self.env_datas:
-                ed._resolve_snrefs(diag_layer)
-
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
-        """Convert the physical value into bytes.
+                ed._resolve_snrefs(context)
 
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an EncodeError exception.
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        """Convert a physical value into bytes and emplace them into a PDU.
         """
-        raise EncodeError("EnvironmentDataDescription DOPs cannot be encoded or decoded")
 
-    def convert_bytes_to_physical(self,
-                                  decode_state: DecodeState,
-                                  bit_position: int = 0) -> Tuple[ParameterValue, int]:
-        """Extract the bytes from the PDU and convert them to the physical value.
+        # retrieve the DTC as a numerical value from the referenced
+        # parameter (which must be located somewhere before the
+        # parameter using the environment data description)
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        numerical_dtc_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(encode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                numerical_dtc_value = self._get_numerical_dtc_from_parameter(
+                    prev_param, prev_param_value)
+                break
+
+        if numerical_dtc_value is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced parameter.")
+            return
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc_value in env_data.dtc_values:
+                tmp = encode_state.allow_unknown_parameters
+                encode_state.allow_unknown_parameters = True
+                env_data.encode_into_pdu(physical_value, encode_state)
+                encode_state.allow_unknown_parameters = tmp
+                break
 
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an DecodeError exception.
+    @override
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+        """Extract the bytes from a PDU and convert them to a physical value.
         """
-        raise DecodeError("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the DTC as a numerical value from the referenced
+        # parameter (which must be located somewhere before the
+        # parameter using the environment data description)
+        if self.param_snref is None:
+            odxraise("Specifying the DTC parameter for environment data "
+                     "descriptions via SNPATHREF is not supported yet")
+            return None
+
+        numerical_dtc_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(decode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                numerical_dtc_value = self._get_numerical_dtc_from_parameter(
+                    prev_param, prev_param_value)
+                break
+
+        if numerical_dtc_value is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced parameter.")
+            return
+
+        result: ParameterValueDict = {}
+
+        # deal with the "all value" environment data. This holds
+        # parameters that are common to all DTCs. Be aware that the
+        # specification mandates that there is at most one such
+        # environment data object
+        for env_data in self.env_datas:
+            if env_data.all_value:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        # find the environment data corresponding to the given trouble
+        # code
+        for env_data in self.env_datas:
+            if numerical_dtc_value in env_data.dtc_values:
+                tmp = env_data.decode_from_pdu(decode_state)
+                if not isinstance(tmp, dict):
+                    odxraise()
+                result.update(tmp)
+                break
+
+        return result
+
+    def _get_numerical_dtc_from_parameter(self, param: Parameter,
+                                          param_value: Optional[ParameterValue]) -> int:
+        if isinstance(param, ParameterWithDOP):
+            dop = param.dop
+            if not isinstance(dop, (DataObjectProperty, DtcDop)):
+                odxraise(f"The DOP of the parameter referenced by environment data descriptions "
+                         f"must use either be DataObjectProperty or a DtcDop (encountered "
+                         f"{type(param).__name__} for parameter '{self.param.short_name}' "
+                         f"of ENV-DATA-DESC '{self.short_name}')")
+                return 0
+
+            if dop.diag_coded_type.base_data_type != DataType.A_UINT32:
+                odxraise(f"The data type used by the DOP of the parameter referenced "
+                         f"by environment data descriptions must be A_UINT32 "
+                         f"(encountered '{dop.diag_coded_type.base_data_type.value}')")
+
+            if param_value is None:
+                if isinstance(param, ValueParameter):
+                    param_value = param.physical_default_value
+                elif isinstance(param, PhysicalConstantParameter):
+                    param_value = param.physical_constant_value
+                else:
+                    odxraise()  # make mypy happy...
+                    return
+
+            if isinstance(dop, DtcDop):
+                return dop.convert_to_numerical_trouble_code(odxrequire(param_value))
+            elif isinstance(dop, DataObjectProperty):
+                return int(dop.compu_method.convert_physical_to_internal(
+                    param_value))  # type: ignore[arg-type]
+
+            odxraise()  # not reachable...
+
+        elif isinstance(param, CodedConstParameter):
+            if param.diag_coded_type.base_data_type != DataType.A_UINT32:
+                odxraise(f"The data type used by the parameter referenced "
+                         f"by environment data descriptions must be A_UINT32 "
+                         f"(encountered '{param.diag_coded_type.base_data_type.value}')")
+
+                return param.coded_value
+
+            if not isinstance(param.coded_value, int):
+                odxraise()
+
+            return param.coded_value
+
+        else:
+            odxraise(f"The parameter referenced by environment data descriptions "
+                     f"must be a parameter that either specifies a DOP or a constant "
+                     f"(encountered {type(param).__name__} for reference '{self.param_snref}' of "
+                     f"ENV-DATA-DESC '{self.short_name}')")
+            return 0

odxtools/exceptions.py

@@ -9,13 +9,22 @@ class OdxError(Exception):
 
 
 class EncodeError(Warning, OdxError):
-    """Encoding of a message to raw data failed."""
+    """Encoding of a message to raw data failed"""
 
 
 class DecodeError(Warning, OdxError):
     """Decoding raw data failed."""
 
 
+class DecodeMismatch(DecodeError):
+    """Decoding failed because some parameters exhibit an incorrect value
+
+    This is can happen if NRC-CONST or environment data descriptions
+    are present.
+
+    """
+
+
 class OdxWarning(Warning):
     """Any warning that happens during interacting with diagnostic objects."""
 
@@ -40,7 +49,7 @@ def odxraise(message: Optional[str] = None, error_type: Type[Exception] = OdxErr
         else:
             raise error_type(message)
     elif message is not None:
-        logger.warn(message)
+        logger.warning(message)
 
 
 def odxassert(condition: bool,

odxtools/field.py

@@ -1,18 +1,17 @@
+# SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional
+from typing import List, Optional
 from xml.etree import ElementTree
 
 from .basicstructure import BasicStructure
 from .complexdop import ComplexDop
 from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class Field(ComplexDop):
@@ -80,12 +79,13 @@ class Field(ComplexDop):
             self._env_data_desc = odxlinks.resolve(self.env_data_desc_ref,
                                                    EnvironmentDataDescription)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         """Recursively resolve any short-name references"""
+        ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
+
         if self.structure_snref is not None:
-            structures = diag_layer.diag_data_dictionary_spec.structures
-            self._structure = odxrequire(structures.get(self.structure_snref))
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
 
         if self.env_data_desc_snref is not None:
-            env_data_descs = diag_layer.diag_data_dictionary_spec.env_data_descs
-            self._env_data_desc = odxrequire(env_data_descs.get(self.env_data_desc_snref))
+            self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddds.env_data_descs,
+                                                EnvironmentDataDescription)

odxtools/functionalclass.py

@@ -1,15 +1,13 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List
 from xml.etree import ElementTree
 
 from .element import IdentifiableElement
 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 FunctionalClass(IdentifiableElement):
@@ -31,5 +29,5 @@ class FunctionalClass(IdentifiableElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         pass
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass

odxtools/inputparam.py

@@ -1,19 +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 deprecation import deprecated
-
 from .dopbase import DopBase
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class InputParam(NamedElement):
@@ -44,15 +40,10 @@ class InputParam(NamedElement):
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         self._dop_base = odxlinks.resolve(self.dop_base_ref, DopBase)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
         pass
 
     @property
     def dop_base(self) -> DopBase:
         """The data object property describing this parameter."""
         return self._dop_base
-
-    @property
-    @deprecated(details="use .dop_base")  # type: ignore[misc]
-    def dop(self) -> DopBase:
-        return self._dop_base

odxtools/leadinglengthinfotype.py

@@ -1,12 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Any, Optional
+from typing import List
+from xml.etree import ElementTree
+
+from typing_extensions import override
 
 from .decodestate import DecodeState
 from .diagcodedtype import DctType, DiagCodedType
 from .encodestate import EncodeState
-from .exceptions import odxassert, odxraise
+from .exceptions import EncodeError, odxassert, odxraise, odxrequire
+from .odxlink import OdxDocFragment
 from .odxtypes import AtomicOdxType, DataType
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
@@ -18,6 +23,16 @@ class LeadingLengthInfoType(DiagCodedType):
     #: object.
     bit_length: int
 
+    @staticmethod
+    @override
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "LeadingLengthInfoType":
+        kwargs = dataclass_fields_asdict(DiagCodedType.from_et(et_element, doc_frags))
+
+        bit_length = int(odxrequire(et_element.findtext("BIT-LENGTH")))
+
+        return LeadingLengthInfoType(bit_length=bit_length, **kwargs)
+
     def __post_init__(self) -> None:
         odxassert(self.bit_length > 0,
                   "A Leading length info type with bit length == 0 does not make sense.")
@@ -35,36 +50,40 @@ class LeadingLengthInfoType(DiagCodedType):
     def dct_type(self) -> DctType:
         return "LEADING-LENGTH-INFO-TYPE"
 
-    def get_static_bit_length(self) -> Optional[int]:
-        # note that self.bit_length is just the length of the length
-        # specifier field. This is then followed by the same number of
-        # bytes as the value of this field, i.e., the length of this
-        # DCT is dynamic!
-        return None
+    @override
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
 
-    def convert_internal_to_bytes(self, internal_value: Any, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+        if not isinstance(internal_value, (str, bytes)):
+            odxraise(
+                f"LEADING-LENGTH-INFO types can only be used for strings and byte fields, "
+                f"not {type(internal_value).__name__}", EncodeError)
+            return
 
         byte_length = self._minimal_byte_length_of(internal_value)
 
-        length_bytes = self._encode_internal_value(
-            byte_length,
-            bit_position=bit_position,
+        used_mask = None
+        bit_pos = encode_state.cursor_bit_position
+        if encode_state.cursor_bit_position != 0 or (bit_pos + self.bit_length) % 8 != 0:
+            used_mask = (1 << self.bit_length) - 1
+            used_mask <<= bit_pos
+
+        encode_state.emplace_atomic_value(
+            internal_value=byte_length,
+            used_mask=None,
             bit_length=self.bit_length,
             base_data_type=DataType.A_UINT32,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        value_bytes = self._encode_internal_value(
-            internal_value,
-            bit_position=0,
+        encode_state.emplace_atomic_value(
+            internal_value=internal_value,
+            used_mask=None,
             bit_length=8 * byte_length,
             base_data_type=self.base_data_type,
             is_highlow_byte_order=self.is_highlow_byte_order,
         )
 
-        return length_bytes + value_bytes
-
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
 
         # Extract length of the parameter value

odxtools/library.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, cast
+from xml.etree import ElementTree
+
+from .element import IdentifiableElement
+from .exceptions import odxraise, odxrequire
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class Library(IdentifiableElement):
+    """
+    A library defines a shared library used for single ECU jobs etc.
+
+    It this is basically equivalent to ProgCode.
+    """
+
+    code_file: str
+    encryption: Optional[str]
+    syntax: str
+    revision: str
+    entrypoint: Optional[str]
+
+    @property
+    def code(self) -> bytes:
+        return self._code
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "Library":
+
+        kwargs = dataclass_fields_asdict(IdentifiableElement.from_et(et_element, doc_frags))
+
+        code_file = odxrequire(et_element.findtext("CODE-FILE"))
+        encryption = et_element.findtext("ENCRYPTION")
+        syntax = odxrequire(et_element.findtext("SYNTAX"))
+        revision = odxrequire(et_element.findtext("REVISION"))
+        entrypoint = et_element.findtext("ENTRYPOINT")
+
+        return Library(
+            code_file=code_file,
+            encryption=encryption,
+            syntax=syntax,
+            revision=revision,
+            entrypoint=entrypoint,
+            **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {self.odx_id: self}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        pass
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        aux_file = odxrequire(context.database).auxiliary_files.get(self.code_file)
+
+        if aux_file is None:
+            odxraise(f"Reference to auxiliary file '{self.code_file}' "
+                     f"could not be resolved")
+            self._code: bytes = cast(bytes, None)
+            return
+
+        self._code = aux_file.read()
+        aux_file.seek(0)

odxtools/loadfile.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: MIT
+import os
+from pathlib import Path
+from typing import Union
+
+from .database import Database
+
+
+def load_pdx_file(pdx_file: Union[str, Path]) -> Database:
+    db = Database()
+    db.add_pdx_file(str(pdx_file))
+    db.refresh()
+    return db
+
+
+def load_odx_d_file(odx_d_file_name: Union[str, Path]) -> Database:
+    db = Database()
+    db.add_odx_file(str(odx_d_file_name))
+    db.refresh()
+
+    return db
+
+
+def load_file(file_name: Union[str, Path]) -> Database:
+    if str(file_name).lower().endswith(".pdx"):
+        return load_pdx_file(str(file_name))
+    elif str(file_name).lower().endswith(".odx-d"):
+        return load_odx_d_file(str(file_name))
+    else:
+        raise RuntimeError(f"Could not guess the file format of file '{file_name}'!")
+
+
+def load_files(*file_names: Union[str, Path]) -> Database:
+    db = Database()
+    for file_name in file_names:
+        p = Path(file_name)
+        if p.suffix.lower() == ".pdx":
+            db.add_pdx_file(str(file_name))
+        elif p.suffix.lower().startswith(".odx"):
+            db.add_odx_file(str(file_name))
+        elif p.name.lower() != "index.xml":
+            db.add_auxiliary_file(str(file_name))
+
+    db.refresh()
+    return db
+
+
+def load_directory(dir_name: Union[str, Path]) -> Database:
+    db = Database()
+    for file_name in os.listdir(str(dir_name)):
+        p = Path(dir_name) / file_name
+
+        if not p.is_file():
+            continue
+
+        if p.suffix.lower() == ".pdx":
+            db.add_pdx_file(str(p))
+        elif p.suffix.lower().startswith(".odx"):
+            db.add_odx_file(str(p))
+        elif p.name.lower() != "index.xml":
+            db.add_auxiliary_file(p.name, open(str(p), "rb"))
+
+    db.refresh()
+    return db