PySerials 0.0.0.dev1__tar.gz → 0.0.0.dev3__tar.gz

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: PySerials
-Version: 0.0.0.dev1
+Version: 0.0.0.dev3
 Requires-Python: >=3.10
-Requires-Dist: jsonschema<5,>=4.19
+Requires-Dist: jsonschema<5,>=4.21.0
 Requires-Dist: ruamel.yaml<0.18,>=0.17.32
 Requires-Dist: ruamel.yaml.string<1,>=0.1.1
 Requires-Dist: tomlkit<0.12,>=0.11.8

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/pyproject.toml

@@ -17,10 +17,10 @@ namespaces = true
 # ----------------------------------------- Project Metadata -------------------------------------
 #
 [project]
-version = "0.0.0.dev1"
+version = "0.0.0.dev3"
 name = "PySerials"
 dependencies = [
-    "jsonschema >= 4.19, < 5",
+    "jsonschema >= 4.21.0, < 5",
     "ruamel.yaml >= 0.17.32, < 0.18", # https://yaml.readthedocs.io/en/stable/
     "ruamel.yaml.string >= 0.1.1, < 1",
     "tomlkit >= 0.11.8, < 0.12", # https://tomlkit.readthedocs.io/en/stable/,

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/PySerials.egg-info/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: PySerials
-Version: 0.0.0.dev1
+Version: 0.0.0.dev3
 Requires-Python: >=3.10
-Requires-Dist: jsonschema<5,>=4.19
+Requires-Dist: jsonschema<5,>=4.21.0
 Requires-Dist: ruamel.yaml<0.18,>=0.17.32
 Requires-Dist: ruamel.yaml.string<1,>=0.1.1
 Requires-Dist: tomlkit<0.12,>=0.11.8

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/PySerials.egg-info/SOURCES.txt

@@ -7,9 +7,13 @@ src/PySerials.egg-info/not-zip-safe
 src/PySerials.egg-info/requires.txt
 src/PySerials.egg-info/top_level.txt
 src/pyserials/__init__.py
-src/pyserials/exception.py
 src/pyserials/format.py
 src/pyserials/read.py
 src/pyserials/update.py
 src/pyserials/validate.py
-src/pyserials/write.py
+src/pyserials/write.py
+src/pyserials/exception/__init__.py
+src/pyserials/exception/_base.py
+src/pyserials/exception/read.py
+src/pyserials/exception/update.py
+src/pyserials/exception/validate.py

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/PySerials.egg-info/requires.txt

@@ -1,4 +1,4 @@
-jsonschema<5,>=4.19
+jsonschema<5,>=4.21.0
 ruamel.yaml<0.18,>=0.17.32
 ruamel.yaml.string<1,>=0.1.1
 tomlkit<0.12,>=0.11.8

pyserials-0.0.0.dev3/src/pyserials/exception/__init__.py

@@ -0,0 +1,4 @@
+"""Exceptions raised by PySerials."""
+
+from pyserials.exception._base import PySerialsException
+from pyserials.exception import read, update, validate

pyserials-0.0.0.dev3/src/pyserials/exception/_base.py

@@ -0,0 +1,10 @@
+"""PySerials base Exception class."""
+
+
+class PySerialsException(Exception):
+    """Base class for all exceptions raised by PySerials."""
+
+    def __init__(self, message: str):
+        self.message = message
+        super().__init__(message)
+        return

pyserials-0.0.0.dev3/src/pyserials/exception/read.py

@@ -0,0 +1,119 @@
+"""Exceptions raised by `pyserials.read` module."""
+
+
+from typing import Literal as _Literal
+from pathlib import Path as _Path
+
+from pyserials.exception._base import PySerialsException as _PySerialsException
+
+
+class PySerialsReadException(_PySerialsException):
+    """Base class for all exceptions raised by `pyserials.read` module."""
+
+    def __init__(self, message: str, source_type: _Literal["file", "string"]):
+        super().__init__(message=f"Failed to read data from {source_type}. {message}.")
+        return
+
+
+class PySerialsReadFromFileException(PySerialsReadException):
+    """Base class for all exceptions raised when reading data from a file.
+
+    Attributes
+    ----------
+    filepath : pathlib.Path
+        The path of the input datafile.
+    """
+    def __init__(self, message: str, filepath: _Path):
+        super().__init__(message=message, source_type="file")
+        self.filepath: _Path = filepath
+        return
+
+
+class PySerialsReadFromStringException(PySerialsReadException):
+    """Base class for all exceptions raised when reading data from a string.
+
+    Attributes
+    ----------
+    data_type : {"json", "yaml", "toml"}
+        The type of data.
+    """
+
+    def __init__(self, message: str, data_type: _Literal["json", "yaml", "toml"]):
+        super().__init__(message=message, source_type="string")
+        self.data_type = data_type
+        return
+
+
+class PySerialsInvalidFileExtensionError(PySerialsReadFromFileException):
+    """Exception raised when a file to be read has an unrecognized extension."""
+
+    def __init__(self, filepath: _Path):
+        message = (
+            f"The extension of the file at '{filepath}' is invalid; "
+            f"expected one of 'json', 'yaml', or 'toml', but got '{filepath.suffix.removeprefix('.')}'. "
+            "Please provide the extension explicitly, or rename the file to have a valid extension."
+        )
+        super().__init__(message=message, filepath=filepath)
+        return
+
+
+class PySerialsMissingFileError(PySerialsReadFromFileException):
+    """Exception raised when a file to be read does not exist."""
+
+    def __init__(self, filepath: _Path):
+        message = f"The file at '{filepath}' does not exist."
+        super().__init__(message=message, filepath=filepath)
+        return
+
+
+class PySerialsEmptyFileError(PySerialsReadFromFileException):
+    """Exception raised when a file to be read is empty."""
+
+    def __init__(self, filepath: _Path):
+        message = f"The file at '{filepath}' is empty."
+        super().__init__(message=message, filepath=filepath)
+        return
+
+
+class PySerialsInvalidDataFileError(PySerialsReadFromFileException):
+    """Exception raised when a file to be read is invalid.
+
+    Attributes
+    ----------
+    data : str
+        The input data that was supposed to be read.
+    data_type : {"json", "yaml", "toml"}
+        The type of data.
+    """
+
+    def __init__(self, filepath: _Path, data_type: _Literal["json", "yaml", "toml"], data: str):
+        message = f"The {data_type} file at '{filepath}' is invalid."
+        super().__init__(message=message, filepath=filepath)
+        self.data = data
+        self.data_type = data_type
+        return
+
+
+class PySerialsEmptyStringError(PySerialsReadFromStringException):
+    """Exception raised when a string to be read is empty."""
+
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"]):
+        message = f"The {data_type} string is empty."
+        super().__init__(message=message, data_type=data_type)
+        return
+
+
+class PySerialsInvalidDataStringError(PySerialsReadFromStringException):
+    """Exception raised when a string to be read is invalid.
+
+    Attributes
+    ----------
+    data : str
+        The input data that was supposed to be read.
+    """
+
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"], data: str):
+        message = f"The {data_type} string is invalid."
+        super().__init__(message=message, data_type=data_type)
+        self.data = data
+        return

pyserials-0.0.0.dev3/src/pyserials/exception/update.py

@@ -0,0 +1,131 @@
+"""Exceptions raised by `pyserials.update` module."""
+
+from typing import Any as _Any
+
+from pyserials.exception._base import PySerialsException as _PySerialsException
+
+
+class PySerialsUpdateException(_PySerialsException):
+    """Base class for all exceptions raised by `pyserials.update` module."""
+
+    def __init__(self, message: str):
+        super().__init__(f"Failed to update data. {message}.")
+        return
+
+
+class PySerialsUpdateDictFromAddonException(PySerialsUpdateException):
+    """Base class for all exceptions raised by `pyserials.update.dict_from_addon`.
+
+    Attributes
+    ----------
+    address : str
+        The address of the data that failed to update.
+    value_data : Any
+        The value of the data in the source dictionary.
+    value_addon : Any
+        The value of the data in the addon dictionary.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        address: str,
+        value_data: _Any,
+        value_addon: _Any,
+    ):
+        super().__init__(message=message)
+        self.address = address
+        self.value_data = value_data
+        self.value_addon = value_addon
+        return
+
+
+class PySerialsUpdateTemplatedDataException(PySerialsUpdateException):
+    """Base class for all exceptions raised by `pyserials.update.templated_data_from_source`.
+
+    Attributes
+    ----------
+    templated_data : str
+        The templated data that failed to update.
+    source_data : dict
+        The data that was used to update the template.
+    template_start : str
+        The start marker of the template.
+    template_end : str
+        The end marker of the template.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        templated_data: str,
+        source_data: dict,
+        template_start: str,
+        template_end: str
+    ):
+        super().__init__(message=message)
+        self.templated_data = templated_data
+        self.source_data = source_data
+        self.template_start = template_start
+        self.template_end = template_end
+        return
+
+
+class PySerialsDictUpdateTypeMismatchError(PySerialsUpdateDictFromAddonException):
+    """Exception raised when a dict update fails due to a type mismatch."""
+
+    def __init__(self, address: str, value_data: _Any, value_addon: _Any):
+        message = (
+            f"There was a type mismatch between the source and addon dictionary values at '{address}'; "
+            f"the value is of type '{type(value_data).__name__}' in the source data, "
+            f"but of type '{type(value_addon).__name__}' in the addon data"
+        )
+        super().__init__(message=message, address=address, value_data=value_data, value_addon=value_addon)
+        return
+
+
+class PySerialsDictUpdateDuplicationError(PySerialsUpdateDictFromAddonException):
+    """Exception raised when a dict update fails due to a duplication."""
+
+    def __init__(self, address: str, value_data: _Any, value_addon: _Any):
+        message = (
+            f"There was a duplication in the addon dictionary at '{address}'; "
+            f"the value of type '{type(value_addon).__name__}' already exists in the source data"
+        )
+        super().__init__(message=message, address=address, value_data=value_data, value_addon=value_addon)
+        return
+
+
+class PySerialsTemplateUpdateMissingSourceError(PySerialsUpdateTemplatedDataException):
+    """Exception raised when a templated data update fails due to a missing key in source data.
+
+    Attributes
+    ----------
+    address_full : str
+        The full address in the source data where the key/index is missing.
+    address_missing : str
+        The key/index that is missing in the source data at `address_full`.
+    """
+
+    def __init__(
+        self,
+        address_full: str,
+        address_missing: str,
+        templated_data: str,
+        source_data: dict,
+        template_start: str,
+        template_end: str
+    ):
+        message = (
+            f"The key/index '{address_missing}' is missing in the source data at '{address_full}'"
+        )
+        super().__init__(
+            message=message,
+            templated_data=templated_data,
+            source_data=source_data,
+            template_start=template_start,
+            template_end=template_end
+        )
+        self.address_full = address_full
+        self.address_missing = address_missing
+        return

pyserials-0.0.0.dev3/src/pyserials/exception/validate.py

@@ -0,0 +1,73 @@
+"""Exceptions raised by `pyserials.validate` module."""
+
+
+from typing import Any as _Any
+
+from pyserials.exception._base import PySerialsException as _PySerialsException
+
+
+class PySerialsValidateException(_PySerialsException):
+    """Base class for all exceptions raised by `pyserials.validate` module.
+
+    Attributes
+    ----------
+    data : dict | list | str | int | float | bool
+        The data that failed validation.
+    schema : dict
+        The schema that the data failed to validate against.
+    validator : Any
+        The validator that was used to validate the data against the schema.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        data: dict | list | str | int | float | bool,
+        schema: dict,
+        validator: _Any,
+    ):
+        message = (
+            "Failed to validate data against schema "
+            f"using validator '{validator.__class__.__name__}'; {message}."
+        )
+        super().__init__(message=message)
+        self.data = data
+        self.schema = schema
+        self.validator = validator
+        return
+
+
+class PySerialsSchemaValidationError(PySerialsValidateException):
+    """Exception raised when data validation fails due to the data being invalid against the schema."""
+
+    def __init__(
+        self,
+        data: dict | list | str | int | float | bool,
+        schema: dict,
+        validator: _Any,
+    ):
+        super().__init__(
+            message="the data is invalid",
+            data=data,
+            schema=schema,
+            validator=validator,
+        )
+        return
+
+
+class PySerialsInvalidSchemaError(PySerialsValidateException):
+    """Exception raised when data validation fails due to the schema being invalid."""
+
+    def __init__(
+        self,
+        data: dict | list | str | int | float | bool,
+        schema: dict,
+        validator: _Any,
+    ):
+        super().__init__(
+            message="the schema is invalid",
+            data=data,
+            schema=schema,
+            validator=validator,
+        )
+        return

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/pyserials/read.py

@@ -21,11 +21,7 @@ def from_file(
         if data_type == "yml":
             data_type = "yaml"
         if data_type not in ("json", "yaml", "toml"):
-            raise _exception.ReadError(
-                error_type=_exception.ReadErrorType.EXTENSION_INVALID,
-                source_type="file",
-                filepath=path,
-            )
+            raise _exception.read.PySerialsInvalidFileExtensionError(filepath=path)
     if data_type == "json":
         return json_from_file(path=path, strict=json_strict)
     if data_type == "yaml":
@@ -139,18 +135,16 @@ def _read_from_file(
     exception,
 ):
     path = _Path(path).resolve()
-    common_error_args = {"source_type": "file", "data_type": data_type, "filepath": path}
     if not path.is_file():
-        raise _exception.ReadError(error_type=_exception.ReadErrorType.FILE_MISSING, **common_error_args)
+        raise _exception.read.PySerialsMissingFileError(filepath=path)
     data = path.read_text()
-    common_error_args["data"] = data
     if data.strip() == "":
-        raise _exception.ReadError(error_type=_exception.ReadErrorType.FILE_EMPTY, **common_error_args)
+        raise _exception.read.PySerialsEmptyFileError(filepath=path)
     try:
         content = loader(data)
     except exception as e:
-        raise _exception.ReadError(
-            error_type=_exception.ReadErrorType.DATA_INVALID, **common_error_args
+        raise _exception.read.PySerialsInvalidDataFileError(
+            filepath=path, data_type=data_type, data=data
         ) from e
     return content
 
@@ -161,13 +155,10 @@ def _read_from_string(
     loader,
     exception,
 ):
-    common_error_args = {"source_type": "string", "data": data, "data_type": data_type}
     if not data.strip():
-        raise _exception.ReadError(error_type=_exception.ReadErrorType.STRING_EMPTY, **common_error_args)
+        raise _exception.read.PySerialsEmptyStringError(data_type=data_type)
     try:
         content = loader(data)
     except exception as e:
-        raise _exception.ReadError(
-            error_type=_exception.ReadErrorType.DATA_INVALID, **common_error_args
-        ) from e
+        raise _exception.read.PySerialsInvalidDataStringError(data_type=data_type, data=data) from e
     return content

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/pyserials/update.py

@@ -14,8 +14,7 @@ def dict_from_addon(
     def recursive(source: dict, add: dict, path: str, log: dict):
 
         def raise_duplication_error():
-            raise _exception.DictUpdateError(
-                error_type=_exception.UpdateErrorType.DUPLICATION,
+            raise _exception.update.PySerialsDictUpdateDuplicationError(
                 address=fullpath,
                 value_data=source[key],
                 value_addon=value,
@@ -28,8 +27,7 @@ def dict_from_addon(
                 source[key] = value
                 continue
             if type(source[key]) is not type(value):
-                raise _exception.DictUpdateError(
-                    error_type=_exception.UpdateErrorType.TYPE_MISMATCH,
+                raise _exception.update.PySerialsDictUpdateTypeMismatchError(
                     address=fullpath,
                     value_data=source[key],
                     value_addon=value,
@@ -91,6 +89,8 @@ class _TemplateFiller:
     ):
         self._data = templated_data
         self._source = source_data
+        self._template_start = template_start
+        self._template_end = template_end
         marker_start = _re.escape(template_start)
         marker_end = _re.escape(template_end)
         self._pattern_template_whole = _re.compile(rf"^{marker_start}([\w\.\:\-\[\] ]+){marker_end}$")
@@ -128,12 +128,20 @@ class _TemplateFiller:
             except (TypeError, KeyError, IndexError) as e:
                 try:
                     next_layer = self._recursive_subst(obj)[curr_add]
-                except (TypeError, KeyError, IndexError) as e2:
-                    raise KeyError(f"Object '{obj}' has no element '{curr_add}'") from e
+                except (TypeError, KeyError, IndexError):
+                    raise _exception.update.PySerialsTemplateUpdateMissingSourceError(
+                        address_full=address_full,
+                        address_missing=curr_add,
+                        templated_data=self._data,
+                        source_data=self._source,
+                        template_start=self._template_start,
+                        template_end=self._template_end,
+                    ) from e
             return recursive_retrieve(next_layer, address)
 
+        address_full = match.strip()
         parsed_address = []
-        for add in match.strip().split("."):
+        for add in address_full.split("."):
             name = self._pattern_address_name.match(add).group()
             indices = self._pattern_address_indices.findall(add)
             parsed_address.append(name)

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/pyserials/validate.py

@@ -6,9 +6,39 @@ import pyserials.exception as _exception
 def jsonschema(
     data: dict | list | str | int | float | bool,
     schema: dict,
-    validator: _jsonschema.validators.Validator = _jsonschema.Draft202012Validator,
+    validator: _jsonschema.protocols.Validator = _jsonschema.Draft202012Validator,
     fill_defaults: bool = True,
-) -> None:
+    raise_invalid_data: bool = True,
+) -> bool:
+    """
+    Validate data against a JSON schema.
+
+    Parameters
+    ----------
+    data : dict | list | str | int | float | bool
+        The data to validate.
+    schema : dict
+        The schema to validate the data against.
+    validator : jsonschema.protocols.Validator, default: jsonschema.Draft202012Validator
+        The JSON schema validator to use.
+    fill_defaults : bool, default: True
+        Whether to fill in the data with default values from the schema,
+        when they are not present.
+    raise_invalid_data : bool, default: True
+        Whether to raise an exception when the data is invalid against the schema.
+
+    Returns
+    -------
+    valid : bool
+        Whether the data is valid against the schema.
+
+    Raises
+    ------
+    pyserials.exception.PySerialsInvalidSchemaError
+        If the schema is invalid.
+    pyserials.exception.PySerialsSchemaValidationError
+        If the data is invalid against the schema and `raise_invalid_data` is `True`.
+    """
     def _extend_with_default(validator_class):
         # https://python-jsonschema.readthedocs.io/en/stable/faq/#why-doesn-t-my-schema-s-default-property-set-the-default-on-my-instance
 
@@ -30,22 +60,18 @@ def jsonschema(
         return _jsonschema.validators.extend(validator_class, {"properties": set_defaults})
 
     validator = _extend_with_default(validator) if fill_defaults else validator
-    common_error_args = {"data": data, "schema": schema, "validator": validator}
+    error_args = {"data": data, "schema": schema, "validator": validator}
     try:
         validator(schema).validate(data)
-    except (_jsonschema.exceptions.ValidationError, _jsonschema.exceptions.FormatError) as e:
-        raise _exception.ValidationError(
-            error_type=_exception.ValidationErrorType.DATA_INVALID,
-            **common_error_args,
-        ) from e
     except (
         _jsonschema.exceptions.SchemaError,
         _jsonschema.exceptions.UndefinedTypeCheck,
         _jsonschema.exceptions.UnknownType,
         _UnresolvableReferencingError,
     ) as e:
-        raise _exception.ValidationError(
-            error_type=_exception.ValidationErrorType.SCHEMA_INVALID,
-            **common_error_args,
-        ) from e
-    return
+        raise _exception.validate.PySerialsInvalidSchemaError(**error_args) from e
+    except (_jsonschema.exceptions.ValidationError, _jsonschema.exceptions.FormatError) as e:
+        if raise_invalid_data:
+            raise _exception.validate.PySerialsSchemaValidationError(**error_args) from e
+        return False
+    return True

{PySerials-0.0.0.dev1 → pyserials-0.0.0.dev3}/src/pyserials/write.py

@@ -1,5 +1,5 @@
 from pathlib import Path as _Path
-
+import json as _json
 import ruamel.yaml as _yaml
 import tomlkit as _tomlkit
 
@@ -28,3 +28,11 @@ def to_toml_string(
     sort_keys: bool = True,
 ) -> str:
     return _tomlkit.dumps(data, sort_keys=sort_keys)
+
+
+def to_json_string(
+    data: dict | list | str | int | float | bool | _yaml.CommentedMap | _yaml.CommentedSeq,
+    sort_keys: bool = True,
+    indent: int | None = None,
+) -> str:
+    return _json.dumps(data, indent=indent, sort_keys=sort_keys)

PySerials-0.0.0.dev1/src/pyserials/exception.py

@@ -1,140 +0,0 @@
-from typing import Literal as _Literal, Any as _Any
-from pathlib import Path as _Path
-from enum import Enum as _Enum
-
-
-class ReadErrorType(_Enum):
-    """Enumeration of all possible read error types."""
-
-    FILE_MISSING = "the file does not exist"
-    FILE_EMPTY = "the file is empty"
-    STRING_EMPTY = "the string is empty"
-    DATA_INVALID = "the data is invalid"
-    EXTENSION_INVALID = "the file extension is invalid"
-
-
-class ValidationErrorType(_Enum):
-    """Enumeration of all possible validation error types."""
-
-    SCHEMA_INVALID = "the schema is invalid"
-    DATA_INVALID = "the data is invalid"
-
-
-class UpdateErrorType(_Enum):
-    """Enumeration of all possible update error types."""
-
-    TYPE_MISMATCH = (
-        "type mismatch; the value of '{address}' is of type '{type_source}' in the source data, "
-        "but of type '{type_addon}' in the addon data"
-    )
-    DUPLICATION = (
-        "duplication; the value of '{address}' with type {type_source} already exists in the source data"
-    )
-
-
-class PySerialsError(Exception):
-    """Base class for all PySerials errors."""
-
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(message)
-        return
-
-
-class ReadError(PySerialsError):
-    """Base class for all PySerials read errors."""
-
-    def __init__(
-        self,
-        error_type: ReadErrorType,
-        source_type: _Literal["file", "string"],
-        data_type: _Literal["json", "yaml", "toml"] | None = None,
-        filepath: _Path | None = None,
-        data: str | None = None,
-    ):
-        self._type = error_type
-        self._source_type = source_type
-        self._data_type = data_type
-        self._filepath = filepath
-        self._data = data
-
-        message = f"Failed to read {data_type} data from {source_type}; {error_type.value}."
-        super().__init__(message)
-        return
-
-    @property
-    def type(self) -> ReadErrorType:
-        """The type of error."""
-        return self._type
-
-    @property
-    def source_type(self) -> _Literal["file", "string"]:
-        """Source of the data; either 'string' or 'file'."""
-        return self._source_type
-
-    @property
-    def data_type(self) -> _Literal["json", "yaml", "toml"] | None:
-        """The type of data; either 'json', 'yaml', 'toml', or None, in case of an invalid extension error."""
-        return self._data_type
-
-    @property
-    def filepath(self) -> _Path | None:
-        """The path of the input datafile; available only when source-type is file."""
-        return self._filepath
-
-    @property
-    def data(self) -> str | None:
-        """The input data;
-        available only when source-type is string, or when the input file was read successfully."""
-        return self._data
-
-
-class ValidationError(PySerialsError):
-    """Base class for all PySerials validation errors."""
-
-    def __init__(
-        self,
-        error_type: ValidationErrorType,
-        data: dict | list | str | int | float | bool,
-        schema: dict,
-        validator: _Any,
-    ):
-        self._type = error_type
-        self._data = data
-        self._schema = schema
-        self._validator = validator
-
-        message = f"Failed to validate data against schema using validator '{validator}'; {error_type.value}."
-        super().__init__(message)
-        return
-
-
-class UpdateError(PySerialsError):
-    """Base class for all PySerials update errors."""
-
-    def __init__(self, message: str):
-        super().__init__(message)
-        return
-
-
-class DictUpdateError(UpdateError):
-    """Base class for all PySerials dict update errors."""
-
-    def __init__(
-        self,
-        error_type: UpdateErrorType,
-        address: str,
-        value_data: _Any,
-        value_addon: _Any,
-    ):
-        self._type = error_type
-        self._address = address
-        self._value_data = value_data
-        self._value_addon = value_addon
-
-        error_details = error_type.value.format(
-            address=address, type_source=type(value_data), type_addon=type(value_addon)
-        )
-        message = f"Failed to update dictionary due to {error_details}."
-        super().__init__(message)
-        return