PySerials 0.0.0.dev3__py3-none-any.whl → 0.0.0.dev5__py3-none-any.whl

{PySerials-0.0.0.dev3.dist-info → PySerials-0.0.0.dev5.dist-info}/METADATA

@@ -1,9 +1,13 @@
 Metadata-Version: 2.1
 Name: PySerials
-Version: 0.0.0.dev3
+Version: 0.0.0.dev5
 Requires-Python: >=3.10
 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
+Requires-Dist: markitup
+Requires-Dist: ansi-sgr
+Requires-Dist: ExceptionMan
+Requires-Dist: jsonpath-ng <2,>=1.6.1
 

PySerials-0.0.0.dev5.dist-info/RECORD

@@ -0,0 +1,17 @@
+pyserials/__init__.py,sha256=-ySdqDuoUXdi2Pa8uuFa5m1CTAtbZS3SWc5qzaOdR5o,142
+pyserials/compare.py,sha256=j62A1UIiAm08_xONlbZmU2EcH1GMEpDyEQH66dZ2YMM,1297
+pyserials/format.py,sha256=dTukpab6WHSyVRQ9SteY5fhr3GFjWFboEl-1cw_udVY,1729
+pyserials/nested_dict.py,sha256=8cPs4LykXh4stFpaLINPjrAeSyaOyyTdhg0FZZ2YOYA,3361
+pyserials/read.py,sha256=uucYQH1V4GStwRgRZ2eQIXkH4ukB5qz0EA885grwi68,6592
+pyserials/update.py,sha256=GfrFgc1a2qYqR8zs04cngVKcXE0124o20xiJQiSMIxg,9259
+pyserials/validate.py,sha256=Ocs0x0BAV9zwRCgg_J5BGU2kEZV6vVjfDBsR3M9Teus,3564
+pyserials/write.py,sha256=pN8w78qVsKJjZd_jvPUcZjYp_RJkP7uQzpiXvPOv4lM,1776
+pyserials/exception/__init__.py,sha256=ZhbggwJUMlTyBhifAivC8ZQxP1Na6lJAwzZs7_YjOSU,151
+pyserials/exception/_base.py,sha256=JFg1XFOlTfn3HX_AjaM7lCat1M49rnow8pT8WZwH1gk,1956
+pyserials/exception/read.py,sha256=Hvz-Hp2I83WyM8m7JAEa2iVn8o3fOcMhSzG0FvyX1GU,8841
+pyserials/exception/update.py,sha256=LZ8_fX9UvqwHIZdANsp9NUaxOEoMHTuOQ6LPff79k3I,4885
+pyserials/exception/validate.py,sha256=j-WT2F67NEFitv7mQJhvqzj4duvcgSCbzqioE6iJTDo,9683
+PySerials-0.0.0.dev5.dist-info/METADATA,sha256=nmJja_tGErd652uk1PlynTmQ7U-P60uhZyy3vKCCSBY,361
+PySerials-0.0.0.dev5.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
+PySerials-0.0.0.dev5.dist-info/top_level.txt,sha256=SAks7WjSjdkv3i9Hvt4gY_P7VQbhhYJN5mf5dqx1aao,10
+PySerials-0.0.0.dev5.dist-info/RECORD,,

{PySerials-0.0.0.dev3.dist-info → PySerials-0.0.0.dev5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pyserials/__init__.py

@@ -1,3 +1,4 @@
 """PySerials"""
 
-from pyserials import exception, update, validate, read, write, format
+from pyserials import exception, update, validate, read, write, format, compare
+from pyserials.nested_dict import NestedDict

pyserials/compare.py

@@ -0,0 +1,29 @@
+def items(source, target, path: str = "$"):
+    def recursive_compare(src, trg, curr_path):
+        if type(src) is not type(trg):
+            comp["modified"].append(curr_path)
+            return
+        if isinstance(src, dict):
+            for key in src:
+                if key not in trg:
+                    comp["added"].append(f"{curr_path}.{key}")
+                    continue
+                recursive_compare(src[key], trg[key], f"{curr_path}.{key}")
+            for key in trg:
+                if key not in src:
+                    comp["removed"].append(f"{curr_path}.{key}")
+            return
+        if isinstance(src, (list, tuple)):
+            len_src = len(src)
+            len_trg = len(trg)
+            min_len = min(len_src, len_trg)
+            for i in range(min_len):
+                recursive_compare(src[i], trg[i], f"{curr_path}[{i}]")
+            for i in range(min_len, max(len_src, len_trg)):
+                comp["added" if len_src > len_trg else "removed"].append(f"{curr_path}[{i}]")
+            return
+        comp["unchanged" if src == trg else "modified"].append(curr_path)
+        return
+    comp = {"added": [], "removed": [], "modified": [], "unchanged": []}
+    recursive_compare(source, target, path)
+    return {key: sorted(comp[key]) for key in comp}

pyserials/exception/_base.py

@@ -1,10 +1,58 @@
 """PySerials base Exception class."""
 
+from __future__ import annotations
+from typing import Literal as _Literal
+import ansi_sgr as _sgr
+from markitup import html as _html, doc as _doc
+from exceptionman import ReporterException as _ReporterException
 
-class PySerialsException(Exception):
+
+_ANSI_HEADING_STYLE = {
+    1: _sgr.style(text_styles="bold", background_color="red"),
+    2: _sgr.style(text_styles="bold", background_color="yellow"),
+    3: _sgr.style(text_styles="bold", background_color="green"),
+    4: _sgr.style(text_styles="bold", background_color="blue"),
+    5: _sgr.style(text_styles="bold", background_color="magenta"),
+    6: _sgr.style(text_styles="bold", background_color="cyan"),
+}
+
+
+class PySerialsException(_ReporterException):
     """Base class for all exceptions raised by PySerials."""
 
-    def __init__(self, message: str):
-        self.message = message
-        super().__init__(message)
+    def __init__(
+        self,
+        message: str,
+        description: str | None = None,
+        message_html: str | _html.Element | None = None,
+        description_html: str | _html.Element | None = None,
+        report_heading: str = "PySerials Error Report",
+    ):
+        super().__init__(
+            message=message,
+            description=description,
+            message_html=message_html,
+            description_html=description_html,
+            report_heading=report_heading,
+        )
         return
+
+
+def ansi_heading(section: list[int], title: str) -> str:
+    """Get an ANSI SGR formatted heading."""
+    sec = ".".join(str(n) for n in section)
+    sec_level = min(len(section), 6)
+    heading = f" {sec}. {title} "
+    return _sgr.format(heading, control_sequence=_ANSI_HEADING_STYLE[sec_level])
+
+
+def ansi_bold(text: str) -> str:
+    return _sgr.format(text, control_sequence=_sgr.style(text_styles="bold"))
+
+
+def format_code(code: str) -> tuple[str, str]:
+    console = _sgr.format(
+        code, control_sequence=_sgr.style(text_color=(220, 220, 220), background_color=(20, 20, 20))
+    )
+    html = str(_html.elem.code(code))
+    return console, html

pyserials/exception/read.py

@@ -1,119 +1,211 @@
 """Exceptions raised by `pyserials.read` module."""
 
-
+from __future__ import annotations
 from typing import Literal as _Literal
 from pathlib import Path as _Path
 
-from pyserials.exception._base import PySerialsException as _PySerialsException
+import ruamel.yaml as _yaml
+import json as _json
 
+from markitup import html as _html, md as _md
+from tomlkit.exceptions import TOMLKitError as _TOMLKitError
 
-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
+from pyserials.exception._base import PySerialsException as _PySerialsException
 
 
-class PySerialsReadFromFileException(PySerialsReadException):
-    """Base class for all exceptions raised when reading data from a file.
+class PySerialsReadException(_PySerialsException):
+    """Base class for all exceptions raised by `pyserials.read` module.
 
     Attributes
     ----------
-    filepath : pathlib.Path
-        The path of the input datafile.
+    source_type : {"file", "string"}
+        Type of source from which data was read.
+    data_type : {"json", "yaml", "toml"} or None
+        Type of input data, if known.
+    filepath : pathlib.Path or None
+        Path to the input datafile, if data was read from a file.
     """
-    def __init__(self, message: str, filepath: _Path):
-        super().__init__(message=message, source_type="file")
-        self.filepath: _Path = filepath
-        return
 
+    def __init__(
+        self,
+        source_type: _Literal["file", "string"],
+        description: str,
+        description_html: str | _html.Element | None = None,
+        data_type: _Literal["json", "yaml", "toml"] | None = None,
+        filepath: _Path | None = None,
+    ):
+        if source_type == "string":
+            source = source_html = "string"
+        else:
+            source = f"file at '{filepath}'"
+            source_html = f"file at <code>{filepath}</code>"
+        data_ = f"{data_type.upper()} data" if data_type else "data"
+        message_template = f"Failed to read {data_} from input {{source}}."
+        super().__init__(
+            message=message_template.format(source=source),
+            message_html=message_template.format(source=source_html),
+            description=description,
+            description_html=description_html,
+            report_heading="PySerials Read Error Report",
+        )
+        self.source_type: _Literal["file", "string"] = source_type
+        self.data_type: _Literal["json", "yaml", "toml"] | None = data_type
+        self.filepath: _Path | None = 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.
-    """
+class PySerialsEmptyStringError(PySerialsReadException):
+    """Exception raised when a string to be read is empty."""
 
-    def __init__(self, message: str, data_type: _Literal["json", "yaml", "toml"]):
-        super().__init__(message=message, source_type="string")
-        self.data_type = data_type
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"]):
+        description = f"The string is empty."
+        super().__init__(description=description, source_type="string", data_type=data_type)
         return
 
 
-class PySerialsInvalidFileExtensionError(PySerialsReadFromFileException):
+class PySerialsInvalidFileExtensionError(PySerialsReadException):
     """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('.')}'. "
+        description = (
+            f"The file extension must be one of 'json', 'yaml', 'yml', or '.toml', "
+            f"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)
+        super().__init__(description=description, source_type="file", filepath=filepath)
         return
 
 
-class PySerialsMissingFileError(PySerialsReadFromFileException):
+class PySerialsMissingFileError(PySerialsReadException):
     """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)
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"], filepath: _Path):
+        description = f"The file does not exist."
+        super().__init__(description=description, source_type="file", data_type=data_type, filepath=filepath)
         return
 
 
-class PySerialsEmptyFileError(PySerialsReadFromFileException):
+class PySerialsEmptyFileError(PySerialsReadException):
     """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)
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"], filepath: _Path):
+        description = f"The file is empty."
+        super().__init__(description=description, source_type="file", data_type=data_type, filepath=filepath)
         return
 
 
-class PySerialsInvalidDataFileError(PySerialsReadFromFileException):
-    """Exception raised when a file to be read is invalid.
+class PySerialsInvalidDataError(PySerialsReadException):
+    """Exception raised when the data 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)
+    def __init__(
+        self,
+        source_type: _Literal["file", "string"],
+        data_type: _Literal["json", "yaml", "toml"],
+        data: str,
+        cause: Exception,
+        filepath: _Path | None = None,
+    ):
         self.data = data
-        self.data_type = data_type
+        self.cause = cause
+        self.problem: str = str(cause)
+        self.problem_line: int | None = None
+        self.problem_column: int | None = None
+        self.problem_data_type: str | None = None
+        self.context: str | None = None
+        self.context_line: int | None = None
+        self.context_column: int | None = None
+        self.context_data_type: str | None = None
+
+        if isinstance(cause, _yaml.YAMLError):
+            self.problem_line = cause.problem_mark.line + 1
+            self.problem_column = cause.problem_mark.column + 1
+            self.problem_data_type = cause.problem_mark.name
+            self.problem = cause.problem.strip()
+            if cause.context:
+                self.context = cause.context.strip()
+                self.context_line = cause.context_mark.line + 1
+                self.context_column = cause.context_mark.column + 1
+                self.context_data_type = cause.context_mark.name
+        elif isinstance(cause, _json.JSONDecodeError):
+            self.problem = cause.msg
+            self.problem_line = cause.lineno
+            self.problem_column = cause.colno
+        elif isinstance(cause, _TOMLKitError):
+            self.problem_line = cause.line
+            self.problem_column = cause.col
+            self.problem = cause.args[0].removesuffix(f" at line {self.problem_line} col {self.problem_column}")
+        self.problem = self.problem.strip().capitalize().removesuffix(".")
+        description = "The data is not valid"
+        if self.problem_line:
+            description += f" at line {self.problem_line}, column {self.problem_column}"
+        description += f": {self.problem}."
+        super().__init__(description=description, source_type=source_type, data_type=data_type, filepath=filepath)
         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
+    def _report_content(self, mode: _Literal["full", "short"], md: bool) -> _html.elem.Ul:
+
+        def make_tabel(problem, line, column, data_type):
+            rows = [
+                [title, value] for title, value in [
+                    ["Description", problem],
+                    ["Line Number", line],
+                    ["Column Number", column],
+                    ["Data Type", data_type],
+                ] if value is not None
+            ]
+            return _html.elem.table_from_rows(rows_body=rows)
+
+        content_list = [
+            _html.elem.details(
+                [
+                    _html.elem.summary("❌ Problem"),
+                    make_tabel(self.problem, self.problem_line, self.problem_column, self.problem_data_type)
+                ]
+            ),
+        ]
+        if self.context:
+            content_list.append(
+                _html.elem.details(
+                    [
+                        _html.elem.summary("🔍 Context"),
+                        make_tabel(self.context, self.context_line, self.context_column, self.context_data_type)
+                    ]
+                ),
+            )
+        data_lines = self.data.splitlines()
+        if self.problem_line:
+            line_idx = self.problem_line - 1
+            problem_line = data_lines[line_idx]
+            if md:
+                problem_line = f"- {problem_line}"
+            else:
+                if self.problem_column:
+                    col_idx = self.problem_column - 1
+                    prob_col = problem_line[col_idx]
+                    prob_col_highlight = _html.elem.span(prob_col, {"class": "highlight-char"})
+                    problem_line = f"{problem_line[:col_idx]}{prob_col_highlight}{problem_line[col_idx+1:]}"
+                problem_line = str(_html.elem.span(problem_line, {"class": "highlight-line"}))
+            data_lines[line_idx] = problem_line
+        if mode == "short":
+            if self.problem_line is not None:
+                problem_line_idx = self.problem_line - 1
+                start_line = max(0, problem_line_idx)
+                end_line = min(len(data_lines), problem_line_idx + 1)
+                if self.context_line is not None:
+                    context_line_idx = self.context_line - 1
+                    start_line = max(0, context_line_idx, problem_line_idx)
+                    end_line = min(len(data_lines), context_line_idx + 1, problem_line_idx + 1)
+                data_lines = data_lines[start_line:end_line]
+        data = "\n".join(data_lines)
+        if md:
+            code_block = _md.elem.code_fence(data, info="diff")
+        else:
+            code_block = _html.elem.pre(_html.elem.code(data, {"class": f"language-{self.data_type}"}))
+        content_list.append(_html.elem.details([_html.elem.summary("📄 Data"), code_block]))
+        return _html.elem.ul([_html.elem.li(content) for content in content_list])

pyserials/exception/update.py

@@ -1,131 +1,139 @@
 """Exceptions raised by `pyserials.update` module."""
 
-from typing import Any as _Any
+from __future__ import annotations
+from typing import Any as _Any, Literal as _Literal
 
-from pyserials.exception._base import PySerialsException as _PySerialsException
+from markitup.html import elem as _html
 
+from pyserials.exception import _base
 
-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`.
+class PySerialsUpdateException(_base.PySerialsException):
+    """Base class for all exceptions raised by `pyserials.update` module.
 
     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.
+    path : str
+        JSONPath to where the update failed.
+    data : dict | list | str | int | float | bool
+        Data that failed to update.
+    data_full : dict | list | str | int | float | bool
+        Full data input.
     """
 
     def __init__(
         self,
-        message: str,
-        address: str,
-        value_data: _Any,
-        value_addon: _Any,
+        path: str,
+        data: dict | list | str | int | float | bool,
+        data_full: dict | list | str | int | float | bool,
+        description: str,
+        description_html: str | _html.Element | None = None,
     ):
-        super().__init__(message=message)
-        self.address = address
-        self.value_data = value_data
-        self.value_addon = value_addon
+        message_template = "Failed to update data at {path}."
+        path_console, path_html = _base.format_code(path)
+        super().__init__(
+            message=message_template.format(path=path_console),
+            message_html=message_template.format(path=path_html),
+            description=description,
+            description_html=description_html,
+            report_heading="PySerials Update Error Report",
+        )
+        self.path = path
+        self.data = data
+        self.data_full = data_full
         return
 
 
-class PySerialsUpdateTemplatedDataException(PySerialsUpdateException):
-    """Base class for all exceptions raised by `pyserials.update.templated_data_from_source`.
+class PySerialsUpdateDictFromAddonError(PySerialsUpdateException):
+    """Base class for all exceptions raised by `pyserials.update.dict_from_addon`.
 
     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.
+    data_addon : Any
+        Value of the failed data in the addon dictionary.
+    data_addon_full : dictionary
+        Full addon input.
     """
 
     def __init__(
         self,
-        message: str,
-        templated_data: str,
-        source_data: dict,
-        template_start: str,
-        template_end: str
+        problem_type: _Literal["duplicate", "type_mismatch"],
+        path: str,
+        data: _Any,
+        data_full: dict,
+        data_addon: _Any,
+        data_addon_full: dict,
     ):
-        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"
+        self.type_data = type(data)
+        self.type_data_addon = type(data_addon)
+        type_data_console, type_data_html = _base.format_code(self.type_data.__name__)
+        type_data_addon_console, type_data_addon_html = _base.format_code(self.type_data_addon.__name__)
+        path_console, path_html = _base.format_code(path)
+        kwargs_console, kwargs_html = (
+            {"path": path, "type_data": type_data, "type_data_addon": type_data_addon}
+            for path, type_data, type_data_addon in zip(
+                (path_console, path_html),
+                (type_data_console, type_data_html),
+                (type_data_addon_console, type_data_addon_html),
+            )
         )
-        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"
+        description_template = (
+            "There was a duplicate in the addon dictionary; "
+            "the value of type {type_data_addon} already exists in the source data."
+        ) if problem_type == "duplicate" else (
+            "There was a type mismatch between the source and addon dictionary values; "
+            "the value is of type {type_data} in the source data, "
+            "but of type {type_data_addon} in the addon data."
+        )
+        super().__init__(
+            description=description_template.format(**kwargs_console),
+            description_html=description_template.format(**kwargs_html),
+            path=path,
+            data=data,
+            data_full=data_full,
         )
-        super().__init__(message=message, address=address, value_data=value_data, value_addon=value_addon)
+        self.problem_type: _Literal["duplicate", "type_mismatch"] = problem_type
+        self.data_addon = data_addon
+        self.data_addon_full = data_addon_full
         return
 
 
-class PySerialsTemplateUpdateMissingSourceError(PySerialsUpdateTemplatedDataException):
-    """Exception raised when a templated data update fails due to a missing key in source data.
+class PySerialsUpdateTemplatedDataError(PySerialsUpdateException):
+    """Exception raised when updating templated data fails.
 
     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`.
+    path_invalid : str
+        JSONPath that caused the update to fail.
+    data_source : dict
+        Source 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,
-        address_full: str,
-        address_missing: str,
-        templated_data: str,
-        source_data: dict,
+        description_template: str,
+        path_invalid: str,
+        path: str,
+        data: str,
+        data_full: dict | list | str | int | float | bool,
+        data_source: dict,
         template_start: str,
-        template_end: str
+        template_end: str,
     ):
-        message = (
-            f"The key/index '{address_missing}' is missing in the source data at '{address_full}'"
-        )
+        path_invalid_console, path_invalid_html = _base.format_code(path_invalid.replace("'", ""))
         super().__init__(
-            message=message,
-            templated_data=templated_data,
-            source_data=source_data,
-            template_start=template_start,
-            template_end=template_end
+            description=description_template.format(path_invalid=path_invalid_console),
+            description_html=description_template.format(path_invalid=path_invalid_html),
+            path=path.replace("'", ""),
+            data=data,
+            data_full=data_full,
         )
-        self.address_full = address_full
-        self.address_missing = address_missing
+        self.path_invalid = path_invalid
+        self.data_source = data_source
+        self.template_start = template_start
+        self.template_end = template_end
         return