PySerials 0.0.0.dev4__tar.gz → 0.0.0.dev6__tar.gz

{pyserials-0.0.0.dev4 → pyserials-0.0.0.dev6}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: PySerials
-Version: 0.0.0.dev4
+Version: 0.0.0.dev6
 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: mdit
 Requires-Dist: ansi-sgr
 Requires-Dist: ExceptionMan
+Requires-Dist: jsonpath-ng<2,>=1.6.1

{pyserials-0.0.0.dev4 → pyserials-0.0.0.dev6}/pyproject.toml

@@ -17,15 +17,16 @@ namespaces = true
 # ----------------------------------------- Project Metadata -------------------------------------
 #
 [project]
-version = "0.0.0.dev4"
+version = "0.0.0.dev6"
 name = "PySerials"
 dependencies = [
     "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/,
-    "markitup",
+    "mdit",
     "ansi-sgr",
-    "ExceptionMan"
+    "ExceptionMan",
+    "jsonpath-ng >= 1.6.1, < 2",
 ]
 requires-python = ">=3.10"

{pyserials-0.0.0.dev4 → pyserials-0.0.0.dev6}/src/PySerials.egg-info/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.1
 Name: PySerials
-Version: 0.0.0.dev4
+Version: 0.0.0.dev6
 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: mdit
 Requires-Dist: ansi-sgr
 Requires-Dist: ExceptionMan
+Requires-Dist: jsonpath-ng<2,>=1.6.1

{pyserials-0.0.0.dev4 → pyserials-0.0.0.dev6}/src/PySerials.egg-info/requires.txt

@@ -2,6 +2,7 @@ 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
-markitup
+mdit
 ansi-sgr
 ExceptionMan
+jsonpath-ng<2,>=1.6.1

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

@@ -0,0 +1,26 @@
+"""PySerials base Exception class."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+
+from exceptionman import ReporterException as _ReporterException
+
+if _TYPE_CHECKING:
+    from mdit import Document
+
+
+class PySerialsException(_ReporterException):
+    """Base class for all exceptions raised by PySerials."""
+
+    def __init__(self, report: Document):
+        super().__init__(
+            report=report,
+            sphinx_config={
+                "extensions": ['myst_parser', 'sphinx_togglebutton'],
+                "myst_enable_extensions": ["colon_fence", "fieldlist"],
+                "html_theme": "pydata_sphinx_theme",
+                "html_title": "PySerials Error Report",
+            }
+        )
+        return

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

@@ -0,0 +1,240 @@
+"""Exceptions raised by `pyserials.read` module."""
+
+from __future__ import annotations
+from typing import Literal as _Literal, TYPE_CHECKING as _TYPE_CHECKING
+from pathlib import Path as _Path
+
+import ruamel.yaml as _yaml
+import json as _json
+import mdit as _mdit
+
+from tomlkit.exceptions import TOMLKitError as _TOMLKitError
+
+from pyserials.exception import _base
+
+
+class PySerialsReadException(_base.PySerialsException):
+    """Base class for all exceptions raised by `pyserials.read` module.
+
+    Attributes
+    ----------
+    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,
+        source_type: _Literal["file", "string"],
+        problem,
+        section: dict | None = None,
+        data_type: _Literal["json", "yaml", "toml"] | None = None,
+        filepath: _Path | None = None,
+    ):
+        intro = _mdit.inline_container(
+            "Failed to read ",
+            f"{data_type.upper()} data " if data_type else "data ",
+            "from input ",
+            "string." if source_type == "string" else _mdit.inline_container(
+                "file at ", _mdit.element.code_span(filepath), "."
+            ),
+        )
+        report = _mdit.document(
+            heading="Data Read Error",
+            body={
+                "intro": intro,
+                "problem": problem,
+            },
+            section=section,
+        )
+        super().__init__(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 PySerialsEmptyStringError(PySerialsReadException):
+    """Exception raised when a string to be read is empty."""
+
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"]):
+        problem = f"The string is empty."
+        super().__init__(problem=problem, source_type="string", data_type=data_type)
+        return
+
+
+class PySerialsInvalidFileExtensionError(PySerialsReadException):
+    """Exception raised when a file to be read has an unrecognized extension."""
+
+    def __init__(self, filepath: _Path):
+        problem = _mdit.inline_container(
+            "The file extension must be one of ",
+            _mdit.element.code_span('json'),
+            ", ",
+            _mdit.element.code_span('yaml'),
+            ", ",
+            _mdit.element.code_span('yml'),
+            ", or ",
+            _mdit.element.code_span('.toml'),
+            ", but got ",
+            _mdit.element.code_span(str(filepath.suffix.removeprefix('.'))),
+            ". Please provide the extension explicitly, or rename the file to have a valid extension."
+        )
+        super().__init__(problem=problem, source_type="file", filepath=filepath)
+        return
+
+
+class PySerialsMissingFileError(PySerialsReadException):
+    """Exception raised when a file to be read does not exist."""
+
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"], filepath: _Path):
+        problem = f"The file does not exist."
+        super().__init__(problem=problem, source_type="file", data_type=data_type, filepath=filepath)
+        return
+
+
+class PySerialsEmptyFileError(PySerialsReadException):
+    """Exception raised when a file to be read is empty."""
+
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"], filepath: _Path):
+        problem = f"The file is empty."
+        super().__init__(problem=problem, source_type="file", data_type=data_type, filepath=filepath)
+        return
+
+
+class PySerialsInvalidDataError(PySerialsReadException):
+    """Exception raised when the data is invalid.
+
+    Attributes
+    ----------
+    data : str
+        The input data that was supposed to be read.
+    """
+
+    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.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
+        self.data_type = data_type
+
+        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.removeprefix("<").removesuffix(">")
+            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.removeprefix("<").removesuffix(">")
+        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.extend(
+                [
+                    " at line ",
+                    _mdit.element.code_span(str(self.problem_line)),
+                    ", column ",
+                    _mdit.element.code_span(str(self.problem_column)),
+                ]
+            )
+        description.append(f": {self.problem}.")
+        super().__init__(
+            problem=description,
+            source_type=source_type,
+            section=self._report_content(),
+            data_type=data_type,
+            filepath=filepath
+        )
+        return
+
+    def _report_content(self) -> dict:
+
+        def make_tabel(problem, line, column, data_type):
+            items = [
+                _mdit.element.field_list_item(title=title, description=value) for title, value in [
+                    ["Description", problem],
+                    ["Line Number", line],
+                    ["Column Number", column],
+                    ["Data Type", data_type],
+                ] if value is not None
+            ]
+            return _mdit.element.field_list(items)
+
+        content = {
+            "problem_details": _mdit.element.admonition(
+                type="error",
+                title="Problem",
+                content=make_tabel(self.problem, self.problem_line, self.problem_column, self.problem_data_type)
+            )
+        }
+        if self.context:
+            content["context_details"] = _mdit.element.admonition(
+                type="note",
+                title="Context",
+                content=make_tabel(self.context, self.context_line, self.context_column, self.context_data_type)
+            )
+
+        code_block_full = _mdit.element.code_block(
+            content=self.data,
+            language=self.data_type,
+            caption="Data",
+            line_num=True,
+            emphasize_lines=[line for line in (self.problem_line, self.context_line) if line],
+            degrade_to_diff=True,
+        )
+        content["data_full"] = (code_block_full, "full")
+
+        if not (self.problem_line or self.context_line):
+            code_block_short = _mdit.element.code_block(
+                content=self.data[:1000].strip() + "\n..." if len(self.data) > 1000 else self.data,
+                language=self.data_type,
+                caption="Data" if len(self.data) <= 1000 else "Data (truncated to first 1000 characters)",
+                line_num=True,
+            )
+        else:
+            if self.problem_line and self.context_line:
+                line_start = min(self.problem_line, self.context_line)
+                line_end = max(self.problem_line, self.context_line)
+            else:
+                line_start = self.problem_line or self.context_line
+                line_end = line_start
+            data_lines = self.data.splitlines()
+            selected_lines = data_lines[line_start - 1:line_end]
+            code_block_short = _mdit.element.code_block(
+                content="\n".join(selected_lines),
+                language=self.data_type,
+                caption="Data",
+                line_num=True,
+                line_num_start=line_start,
+                emphasize_lines=list({1, len(selected_lines)}),
+            )
+        content["data_short"] = (code_block_short, ("short", "console"))
+        container = _mdit.block_container(**content)
+        doc = _mdit.document(heading="Error Details", body=container)
+        return {"details": doc}

{pyserials-0.0.0.dev4 → pyserials-0.0.0.dev6}/src/pyserials/exception/update.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 from typing import Any as _Any, Literal as _Literal
 
-from markitup.html import elem as _html
+import mdit as _mdit
 
 from pyserials.exception import _base
 
@@ -26,18 +26,23 @@ class PySerialsUpdateException(_base.PySerialsException):
         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,
+        problem,
+        section: dict | None = None,
     ):
-        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",
+        intro = _mdit.inline_container(
+            "Failed to update data at ",
+            _mdit.element.code_span(path),
+            "."
+        )
+        report = _mdit.document(
+            heading="Data Update Error",
+            body={
+                "intro": intro,
+                "problem": problem,
+            },
+            section=section,
         )
+        super().__init__(report)
         self.path = path
         self.data = data
         self.data_full = data_full
@@ -66,31 +71,25 @@ class PySerialsUpdateDictFromAddonError(PySerialsUpdateException):
     ):
         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),
-            )
-        )
-        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."
+        problem = _mdit.inline_container(
+            "There was a duplicate in the addon dictionary: ",
+            "the value of type",
+            _mdit.element.code_span(self.type_data_addon.__name__),
+            " already exists in the source data."
+        ) if problem_type == "duplicate" else _mdit.inline_container(
+            "There was a type mismatch between the source and addon dictionary values: ",
+            "the value is of type ",
+            _mdit.element.code_span(self.type_data.__name__),
+            " in the source data, ",
+            "but of type ",
+            _mdit.element.code_span(self.type_data_addon.__name__),
+            " 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,
+            problem=problem,
         )
         self.problem_type: _Literal["duplicate", "type_mismatch"] = problem_type
         self.data_addon = data_addon
@@ -124,16 +123,16 @@ class PySerialsUpdateTemplatedDataError(PySerialsUpdateException):
         template_start: str,
         template_end: str,
     ):
-        path_invalid_console, path_invalid_html = _base.format_code(path_invalid.replace("'", ""))
+        self.path_invalid = path_invalid.replace("'", "")
+        self.data_source = data_source
+        self.template_start = template_start
+        self.template_end = template_end
+        parts = description_template.split("{path_invalid}")
+        parts.insert(1, _mdit.element.code_span(self.path_invalid))
         super().__init__(
-            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,
+            problem=_mdit.inline_container(*parts),
         )
-        self.path_invalid = path_invalid
-        self.data_source = data_source
-        self.template_start = template_start
-        self.template_end = template_end
         return

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

@@ -0,0 +1,216 @@
+"""Exceptions raised by `pyserials.validate` module."""
+
+from __future__ import annotations
+from typing import Any as _Any
+
+import jsonschema as _jsonschema
+import mdit as _mdit
+from pyprotocol import Stringable
+
+from pyserials import write as _write
+from pyserials.exception import _base
+
+
+class PySerialsValidateException(_base.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,
+        problem: str,
+        data: dict | list | str | int | float | bool,
+        schema: dict,
+        validator: _Any,
+        registry: _Any = None,
+        section: dict | None = None,
+    ):
+        intro = _mdit.inline_container(
+            "Failed to validate data against schema using validator ",
+            _mdit.element.code_span(validator.__class__.__name__),
+            "."
+        )
+        report = _mdit.document(
+            heading="Schema Validation Error",
+            body={
+                "intro": intro,
+                "problem": problem,
+            },
+            section=section,
+        )
+        super().__init__(report)
+        self.data = data
+        self.schema = schema
+        self.validator = validator
+        self.registry = registry
+        return
+
+
+class PySerialsInvalidJsonSchemaError(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,
+        registry: _Any = None,
+    ):
+        super().__init__(
+            problem="The schema is invalid.",
+            data=data,
+            schema=schema,
+            validator=validator,
+            registry=registry,
+        )
+        return
+
+
+class PySerialsJsonSchemaValidationError(PySerialsValidateException):
+    """Exception raised when data validation fails due to the data being invalid against the schema."""
+
+    def __init__(
+        self,
+        causes: list[_jsonschema.exceptions.ValidationError],
+        data: dict | list | str | int | float | bool,
+        schema: dict,
+        validator: _Any,
+        registry: _Any = None,
+    ):
+        self.causes = causes
+        super().__init__(
+            problem=self._generate_problem_statement(),
+            section={idx: self._generate_error_report(error) for idx, error in enumerate(self.causes)},
+            data=data,
+            schema=schema,
+            validator=validator,
+            registry=registry,
+        )
+        return
+
+    def _generate_problem_statement(self):
+        error_paths = [_mdit.element.code_span(error.json_path) for error in self.causes]
+        error_paths_str = self._join_list(error_paths)
+        count_errors = len(error_paths)
+        problem = _mdit.inline_container(
+            "Found ",
+            "an error " if count_errors == 1 else f"{count_errors} errors ",
+            "in the data at ",
+            error_paths_str,
+            "."
+        )
+        return problem
+
+    def _generate_error_report(
+        self,
+        error: _jsonschema.exceptions.ValidationError,
+    ) -> _mdit.Document:
+        problem = self._parse_error_message(error)
+        short_ver_fieldlist_items = [
+            _mdit.element.field_list_item("Problem", problem),
+            _mdit.element.field_list_item(
+                "Validator Path", _mdit.element.code_span(self._create_path(error.absolute_schema_path))
+            ),
+        ]
+        full_ver_items = [
+            _mdit.inline_container(problem),
+            self._make_yaml_code_admo(
+                admo_type="error",
+                title="Validator",
+                title_details=str(error.validator),
+                content=error.validator_value,
+            ),
+            self._make_yaml_code_admo(
+                admo_type="error",
+                title="Schema",
+                title_details=self._create_path(error.absolute_schema_path),
+                content=error.schema,
+            ),
+            self._make_yaml_code_admo(
+                admo_type="error",
+                title="Instance",
+                title_details=self._create_path(error.absolute_path),
+                content=error.instance,
+            ),
+        ]
+        section = {}
+        if error.context:
+            context_paths = []
+            for idx, sub_error in enumerate(sorted(error.context, key=lambda x: len(x.context))):
+                section[idx] = self._generate_error_report(sub_error)
+                context_paths.append(_mdit.element.code_span(sub_error.json_path))
+            context_paths_joined = self._join_list(context_paths)
+            short_ver_fieldlist_items.insert(
+                1,
+                _mdit.element.field_list_item(
+                    f"Context Path{'s' if len(context_paths) > 1 else ''}",
+                    context_paths_joined
+                )
+            )
+            err = "an error" if len(context_paths) == 1 else f"{len(context_paths)} errors"
+            full_ver_items[0].append(
+                f" This was caused by {err} at {context_paths_joined}.",
+            )
+        doc = _mdit.document(
+            heading=_mdit.element.code_span(error.json_path),
+            body={
+                "short": (_mdit.element.field_list(short_ver_fieldlist_items), ("short", "console")),
+                "full": (_mdit.element.field_list(full_ver_items), "full"),
+            },
+            section=section,
+        )
+        return doc
+
+    @staticmethod
+    def _make_yaml_code_admo(admo_type: str, title: str, title_details: str, content: dict) -> _mdit.element.Admonition:
+        code_block = _mdit.element.code_block(
+            content=_write.to_yaml_string(content, end_of_file_newline=False),
+            language="yaml",
+        )
+        admo = _mdit.element.admonition(
+            type=admo_type,
+            title=_mdit.inline_container(f"**{title}**: ", _mdit.element.code_span(title_details)),
+            content=code_block,
+            dropdown=True,
+        )
+        return admo
+
+    @staticmethod
+    def _parse_error_message(error: _jsonschema.exceptions.ValidationError) -> str:
+        instance_str = str(error.instance)
+        if error.message.startswith(instance_str):
+            msg = error.message.removeprefix(str(error.instance)).strip()
+            problem = f"Data {msg}"
+        else:
+            problem = error.message
+        return f"{problem.removeprefix(".")}."
+
+    @staticmethod
+    def _create_path(path):
+        return "$." + ".".join(str(path_component) for path_component in path)
+
+    @staticmethod
+    def _join_list(
+        items: list,
+        sep: Stringable = ", ",
+        sep_last: Stringable = ", and ",
+        sep_pair: Stringable = " and ",
+    ) -> Stringable:
+        if len(items) == 1:
+            return items[0]
+        elif len(items) == 2:
+            return _mdit.inline_container(items[0], sep_pair, items[1])
+        container = []
+        for item in items[:-1]:
+            container.extend([item, sep])
+        container.pop()
+        container.extend([sep_last, items[-1]])
+        return _mdit.inline_container(*container)

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

@@ -1,58 +0,0 @@
-"""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
-
-
-_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,
-        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-0.0.0.dev4/src/pyserials/exception/read.py

@@ -1,211 +0,0 @@
-"""Exceptions raised by `pyserials.read` module."""
-
-from __future__ import annotations
-from typing import Literal as _Literal
-from pathlib import Path as _Path
-
-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
-
-from pyserials.exception._base import PySerialsException as _PySerialsException
-
-
-class PySerialsReadException(_PySerialsException):
-    """Base class for all exceptions raised by `pyserials.read` module.
-
-    Attributes
-    ----------
-    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,
-        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 PySerialsEmptyStringError(PySerialsReadException):
-    """Exception raised when a string to be read is empty."""
-
-    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(PySerialsReadException):
-    """Exception raised when a file to be read has an unrecognized extension."""
-
-    def __init__(self, filepath: _Path):
-        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__(description=description, source_type="file", filepath=filepath)
-        return
-
-
-class PySerialsMissingFileError(PySerialsReadException):
-    """Exception raised when a file to be read does not exist."""
-
-    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(PySerialsReadException):
-    """Exception raised when a file to be read is empty."""
-
-    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 PySerialsInvalidDataError(PySerialsReadException):
-    """Exception raised when the data is invalid.
-
-    Attributes
-    ----------
-    data : str
-        The input data that was supposed to be read.
-    """
-
-    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.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
-
-    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-0.0.0.dev4/src/pyserials/exception/validate.py

@@ -1,243 +0,0 @@
-"""Exceptions raised by `pyserials.validate` module."""
-
-from __future__ import annotations
-from typing import Any as _Any, Literal as _Literal
-
-import jsonschema as _jsonschema
-from markitup.html import elem as _html
-from markitup.md import elem as _md
-from pyserials import write as _write
-from pyserials.exception import _base
-
-
-class PySerialsValidateException(_base.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,
-        description: str,
-        data: dict | list | str | int | float | bool,
-        schema: dict,
-        validator: _Any,
-        registry: _Any = None,
-        description_html: str | _html.Element | None = None,
-    ):
-        validator_name = validator.__class__.__name__
-        message_template = "Failed to validate data against schema using validator {validator_name}."
-        validator_name_console, validator_name_html = _base.format_code(validator_name)
-        super().__init__(
-            message=message_template.format(validator_name=validator_name_console),
-            message_html=message_template.format(validator_name=validator_name_html),
-            description=description,
-            description_html=description_html,
-            report_heading="PySerials Schema Validation Error Report",
-        )
-        self.data = data
-        self.schema = schema
-        self.validator = validator
-        self.registry = registry
-        return
-
-
-class PySerialsInvalidJsonSchemaError(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,
-        registry: _Any = None,
-    ):
-        super().__init__(
-            description="The schema is invalid.",
-            data=data,
-            schema=schema,
-            validator=validator,
-            registry=registry,
-        )
-        return
-
-
-class PySerialsJsonSchemaValidationError(PySerialsValidateException):
-    """Exception raised when data validation fails due to the data being invalid against the schema."""
-
-    def __init__(
-        self,
-        causes: list[_jsonschema.exceptions.ValidationError],
-        data: dict | list | str | int | float | bool,
-        schema: dict,
-        validator: _Any,
-        registry: _Any = None,
-    ):
-        self.causes = causes
-        description, description_html = self._parse_errors()
-        super().__init__(
-            description=description,
-            description_html=description_html,
-            data=data,
-            schema=schema,
-            validator=validator,
-            registry=registry,
-        )
-        return
-
-    def _report_content(
-        self, mode: _Literal["full", "short"], md: bool
-    ) -> list[str | _html.Element] | str | _html.Element | None:
-        html_details = []
-        for idx, error in enumerate(self.causes):
-            section_html = self._report_error(error, section=[idx + 1], mode=mode, md=md)
-            html_details.append(section_html)
-        return _html.ul([_html.li(detail) for detail in html_details])
-
-    def _parse_errors(self) -> tuple[str, str]:
-        count_errors = len(self.causes)
-        errors = "an error" if count_errors == 1 else f"{count_errors} errors"
-        intro = intro_html = f"Found {errors} in the data at "
-        reports = []
-        errors_loc = []
-        errors_loc_html = []
-        for idx, error in enumerate(self.causes):
-            error_loc, error_loc_html = _base.format_code(error.json_path)
-            errors_loc.append(error_loc)
-            errors_loc_html.append(error_loc_html)
-            section_console = self._parse_error(error, section=[idx + 1])
-            reports.extend(section_console)
-        reports_str = "\n".join(reports)
-        if len(errors_loc) == 1:
-            errors_loc_str = errors_loc[0]
-            errors_loc_html_str = errors_loc_html[0]
-        elif len(errors_loc) == 2:
-            errors_loc_str = " and ".join(errors_loc)
-            errors_loc_html_str = " and ".join(errors_loc_html)
-        else:
-            errors_loc_str = ", ".join(errors_loc[:-1]) + " and " + errors_loc[-1]
-            errors_loc_html_str = ", ".join(errors_loc_html[:-1]) + " and " + errors_loc_html[-1]
-        intro += f"{errors_loc_str}:\n\n{reports_str}"
-        intro_html += f"{errors_loc_html_str}."
-        return intro, intro_html
-
-    def _parse_error(
-        self,
-        error: _jsonschema.exceptions.ValidationError,
-        section: list[int]
-    ) -> list:
-        schema_path = self._create_path(error.absolute_schema_path)
-        title, _ = _base.format_code(error.json_path)
-        console = [
-            _base.ansi_heading(section, title),
-            f"- {_base.ansi_bold('Problem')}: {self._parse_error_message(error)}",
-            f"- {_base.ansi_bold("Validator Path")}: {schema_path}",
-        ]
-        if error.context:
-            console.append(f"- {_base.ansi_bold("Context")}:")
-            for idx, sub_error in enumerate(sorted(error.context, key=lambda x: len(x.context))):
-                sub_console = self._parse_error(
-                    sub_error,
-                    section=section + [idx+1]
-                )
-                console.extend(self._indent(sub_console, 2))
-        return console
-
-    def _report_error(
-        self,
-        error: _jsonschema.exceptions.ValidationError,
-        section: list[int],
-        mode: _Literal["full", "short"],
-        md: bool
-    ) -> _html.Details:
-        details = [
-            _html.p(f"{_html.b("Problem")}: {self._parse_error_message(error)}"),
-            self._create_validator_details(error, mode=mode, md=md),
-            self._create_schema_details(error, mode=mode, md=md),
-            self._create_instance_details(error, mode=mode, md=md),
-        ]
-        if error.context:
-            contexts = []
-            for idx, sub_error in enumerate(sorted(error.context, key=lambda x: len(x.context))):
-                sub_html = self._report_error(
-                    sub_error,
-                    section=section + [idx+1],
-                    mode=mode,
-                    md=md,
-                )
-                contexts.append(sub_html)
-            context_list = _html.ul([_html.li(context) for context in contexts])
-            details.append(f"{_html.b("Context")}: {context_list}")
-        _, title = _base.format_code(error.json_path)
-        html = _html.details(
-            [_html.summary(title), _html.ul([_html.li(elem) for elem in details])]
-        )
-        return html
-
-    def _create_validator_details(self, error: _jsonschema.exceptions.ValidationError, mode: _Literal["full", "short"], md: bool) -> _html.Details:
-        summary = self._create_details_summary("Validator", str(error.validator))
-        return summary if mode == "short" else self._make_details(
-            content=error.validator_value,
-            summary=summary,
-            md=md,
-        )
-
-    def _create_schema_details(self, error: _jsonschema.exceptions.ValidationError, mode: _Literal["full", "short"], md: bool) -> _html.Details:
-        summary = self._create_details_summary("Schema", self._create_path(error.absolute_schema_path))
-        return summary if mode == "short" else self._make_details(
-            content=error.schema,
-            summary=summary,
-            md=md,
-        )
-
-    def _create_instance_details(self, error: _jsonschema.exceptions.ValidationError, mode: _Literal["full", "short"], md: bool) -> _html.Details:
-        summary = self._create_details_summary("Instance", self._create_path(error.absolute_path))
-        return summary if mode == "short" else self._make_details(
-            content=error.instance,
-            summary=summary,
-            md=md,
-        )
-
-    @staticmethod
-    def _make_details(content: dict, summary: str, md: bool) -> _html.Details:
-        yaml = _write.to_yaml_string(content, end_of_file_newline=False)
-        details_summary = _html.summary(summary)
-        details_content = _html.pre(
-            _html.code(yaml, {"class": "language-yaml"})
-        ) if not md else _md.code_fence(yaml, info="yaml")
-        return _html.details([details_summary, details_content])
-
-    def _create_title(self, error: _jsonschema.exceptions.ValidationError) -> tuple[str, str]:
-        problem = self._parse_error_message(error)
-        title_shell = f"'{error.json_path}': {problem}"
-        title_html = f"{_html.code(error.json_path)}: {problem}"
-        return title_shell, title_html
-
-    @staticmethod
-    def _parse_error_message(error: _jsonschema.exceptions.ValidationError) -> str:
-        instance_str = str(error.instance)
-        if error.message.startswith(instance_str):
-            msg = error.message.removeprefix(str(error.instance)).strip()
-            problem = f"Data {msg}"
-        else:
-            problem = error.message
-        return problem
-
-    @staticmethod
-    def _indent(text: list, indent: int = 2) -> list:
-        return [f"{' ' * indent}{line}" for line in text]
-
-    @staticmethod
-    def _create_path(path):
-        return "$." + ".".join(str(path_component) for path_component in path)
-
-    @staticmethod
-    def _create_details_summary(title: str, code: str) -> str:
-        return f"{_html.b(title)}: {_html.code(code)}"