odxtools 7.1.1__py3-none-any.whl → 7.3.0__py3-none-any.whl

odxtools/dynamicendmarkerfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -13,11 +13,9 @@ from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequir
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DynamicEndmarkerField(Field):
@@ -49,8 +47,8 @@ class DynamicEndmarkerField(Field):
 
         self._termination_value = tv_physical
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
 
     @property
     def dyn_end_dop(self) -> DataObjectProperty:
@@ -81,8 +79,17 @@ class DynamicEndmarkerField(Field):
         encode_state.is_end_of_pdu = orig_is_end_of_pdu
 
         if not encode_state.is_end_of_pdu:
-            # only add an endmarker if we are not at the end of the PDU
+            # only add an endmarker if we are not at the end of the
+            # PDU. note that since section 7.3.6.10.5 of the MCD-2
+            # specification states that the data used by the endmarker
+            # ought to be considered to be not consumed (why?!), we
+            # need to keep the cursor where it is before adding the
+            # endmarker. (we still consider its bits to be used
+            # "used", in order to produce a warning if it is attempted
+            # to be overridden.)
+            tmp_cursor = encode_state.cursor_byte_position
             self.dyn_end_dop.encode_into_pdu(self.termination_value, encode_state)
+            encode_state.cursor_byte_position = tmp_cursor
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -91,7 +98,6 @@ class DynamicEndmarkerField(Field):
                   "No bit position can be specified for dynamic endmarker fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
         result: List[ParameterValue] = []
@@ -106,6 +112,14 @@ class DynamicEndmarkerField(Field):
             try:
                 tv_candidate = self.dyn_end_dop.decode_from_pdu(decode_state)
                 if tv_candidate == self.termination_value:
+                    # note that section 7.3.6.10.5 of the MCD-2
+                    # specification states that the bytes occupied by
+                    # the endmarker ought to be considered to be not
+                    # consumed (why?!), i.e., we need to keep the
+                    # cursor where it is before adding the
+                    # endmarker. (we still consider its to be used
+                    # "used", though.)
+                    decode_state.cursor_byte_position = tmp_cursor
                     break
             except DecodeError:
                 pass
@@ -114,6 +128,5 @@ class DynamicEndmarkerField(Field):
             result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/dynamiclengthfield.py

@@ -1,6 +1,6 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Sequence
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -12,11 +12,9 @@ from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequir
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DynamicLengthField(Field):
@@ -45,9 +43,9 @@ class DynamicLengthField(Field):
         super()._resolve_odxlinks(odxlinks)
         self.determine_number_of_items._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-        self.determine_number_of_items._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+        self.determine_number_of_items._resolve_snrefs(context)
 
     @override
     def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
@@ -61,7 +59,6 @@ class DynamicLengthField(Field):
                 f"got {type(physical_value)}", EncodeError)
 
         # move the origin to the cursor position
-        orig_cursor = encode_state.cursor_byte_position
         orig_origin = encode_state.origin_byte_position
         encode_state.origin_byte_position = encode_state.cursor_byte_position
 
@@ -92,7 +89,6 @@ class DynamicLengthField(Field):
 
         # move cursor and origin positions
         encode_state.origin_byte_position = orig_origin
-        encode_state.cursor_byte_position = max(orig_cursor, encode_state.cursor_byte_position)
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
@@ -101,7 +97,6 @@ class DynamicLengthField(Field):
                   "No bit position can be specified for dynamic length fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
 
         det_num_items = self.determine_number_of_items
         decode_state.origin_byte_position = decode_state.cursor_byte_position
@@ -125,6 +120,5 @@ class DynamicLengthField(Field):
             result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/element.py

@@ -2,16 +2,17 @@ from dataclasses import dataclass
 from typing import List, Optional
 from xml.etree import ElementTree
 
+from .description import Description
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkId
-from .utils import create_description_from_et, dataclass_fields_asdict
+from .utils import dataclass_fields_asdict
 
 
 @dataclass
 class NamedElement:
     short_name: str
     long_name: Optional[str]
-    description: Optional[str]
+    description: Optional[Description]
 
     @staticmethod
     def from_et(
@@ -22,7 +23,7 @@ class NamedElement:
         return NamedElement(
             short_name=odxrequire(et_element.findtext("SHORT-NAME")),
             long_name=et_element.findtext("LONG-NAME"),
-            description=create_description_from_et(et_element.find("DESC")),
+            description=Description.from_et(et_element.find("DESC"), doc_frags),
         )
 
 

odxtools/encodestate.py

@@ -1,16 +1,19 @@
 # SPDX-License-Identifier: MIT
 import warnings
 from dataclasses import dataclass, field
-from typing import Dict, Optional, SupportsBytes
+from typing import TYPE_CHECKING, Dict, List, Optional, SupportsBytes, Tuple
 
 from .exceptions import EncodeError, OdxWarning, odxassert, odxraise
-from .odxtypes import AtomicOdxType, DataType
+from .odxtypes import AtomicOdxType, DataType, ParameterValue
 
 try:
     import bitstruct.c as bitstruct
 except ImportError:
     import bitstruct
 
+if TYPE_CHECKING:
+    from .parameters.parameter import Parameter
+
 
 @dataclass
 class EncodeState:
@@ -56,6 +59,15 @@ class EncodeState:
     #: (needed for MinMaxLengthType, EndOfPduField, etc.)
     is_end_of_pdu: bool = True
 
+    #: list of parameters that have been encoded so far. The journal
+    #: is used by some types of parameters which depend on the values of
+    #: other parameters; e.g., environment data description parameters
+    journal: List[Tuple["Parameter", Optional[ParameterValue]]] = field(default_factory=list)
+
+    #: If this is True, specifying unknown parameters for encoding
+    #: will raise an OdxError exception in strict mode.
+    allow_unknown_parameters = False
+
     def __post_init__(self) -> None:
         # if a coded message has been specified, but no used_mask, we
         # assume that all of the bits of the coded message are

odxtools/endofpdufield.py

@@ -72,7 +72,6 @@ class EndOfPduField(Field):
                   "No bit position can be specified for end-of-pdu fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
         decode_state.origin_byte_position = decode_state.cursor_byte_position
 
         result: List[ParameterValue] = []
@@ -84,6 +83,5 @@ class EndOfPduField(Field):
             result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result

odxtools/environmentdatadescription.py

@@ -1,22 +1,22 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
 from typing_extensions import override
 
 from .complexdop import ComplexDop
 from .decodestate import DecodeState
+from .dtcdop import DtcDop
 from .encodestate import EncodeState
 from .environmentdata import EnvironmentData
 from .exceptions import odxraise, odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
-from .odxtypes import ParameterValue
+from .odxtypes import ParameterValue, ParameterValueDict
+from .parameters.parameter import Parameter
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class EnvironmentDataDescription(ComplexDop):
@@ -29,16 +29,26 @@ class EnvironmentDataDescription(ComplexDop):
 
     """
 
+    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_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,
@@ -87,28 +97,136 @@ class EnvironmentDataDescription(ComplexDop):
             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)
+                ed._resolve_snrefs(context)
 
     @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.
-
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an EncodeError exception.
         """
-        odxraise("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the relevant DTC parameter which must be located in
+        # front of 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
+
+        dtc_param: Optional[Parameter] = None
+        dtc_dop: Optional[DtcDop] = None
+        dtc_param_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(encode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                dtc_param = prev_param
+                prev_dop = getattr(prev_param, "dop", None)
+                if not isinstance(prev_dop, DtcDop):
+                    odxraise(f"The DOP of the parameter referenced by environment data "
+                             f"descriptions must be a DTC-DOP (is '{type(prev_dop).__name__}')")
+                    return
+                dtc_dop = prev_dop
+                dtc_param_value = prev_param_value
+                break
+
+        if dtc_param is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced value parameter.")
+            return
+
+        if dtc_param_value is None or dtc_dop is None:
+            # this should never happen
+            odxraise()
+            return
+
+        numerical_dtc = dtc_dop.convert_to_numerical_trouble_code(dtc_param_value)
+
+        # 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 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
 
     @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """Extract the bytes from a PDU and convert them to a physical value.
-
-        Since environmental data is supposed to never appear on the
-        wire, this method just raises an DecodeError exception.
         """
-        odxraise("EnvironmentDataDescription DOPs cannot be encoded or decoded")
+
+        # retrieve the relevant DTC parameter which must be located in
+        # front of 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
+
+        dtc_param: Optional[Parameter] = None
+        dtc_dop: Optional[DtcDop] = None
+        dtc_param_value: Optional[ParameterValue] = None
+        for prev_param, prev_param_value in reversed(decode_state.journal):
+            if prev_param.short_name == self.param_snref:
+                dtc_param = prev_param
+                prev_dop = getattr(prev_param, "dop", None)
+                if not isinstance(prev_dop, DtcDop):
+                    odxraise(f"The DOP of the parameter referenced by environment data "
+                             f"descriptions must be a DTC-DOP (is '{type(prev_dop).__name__}')")
+                    return
+                dtc_dop = prev_dop
+                dtc_param_value = prev_param_value
+                break
+
+        if dtc_param is None:
+            odxraise("Environment data description parameters are only allowed following "
+                     "the referenced value parameter.")
+            return
+
+        if dtc_param_value is None or dtc_dop is None:
+            # this should never happen
+            odxraise()
+            return
+
+        numerical_dtc = dtc_dop.convert_to_numerical_trouble_code(dtc_param_value)
+
+        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 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

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,5 +1,6 @@
+# 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
@@ -8,11 +9,9 @@ from .environmentdatadescription import EnvironmentDataDescription
 from .exceptions import odxassert, odxrequire
 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,13 +79,14 @@ 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"""
+        ddd_spec = 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 = resolve_snref(self.structure_snref, structures, BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddd_spec.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 = resolve_snref(self.env_data_desc_snref, env_data_descs,
+            self._env_data_desc = resolve_snref(self.env_data_desc_snref, ddd_spec.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,6 +1,6 @@
 # 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
@@ -9,11 +9,9 @@ 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,7 +42,7 @@ 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

odxtools/leadinglengthinfotype.py

@@ -1,14 +1,17 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import Optional
+from typing import List, Optional
+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 EncodeError, 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
@@ -20,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.")

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