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

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

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: PySerials
-Version: 0.0.0.dev5
+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.dev5.dist-info → PySerials-0.0.0.dev6.dist-info}/RECORD

@@ -7,11 +7,11 @@ 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/exception/_base.py,sha256=Juns3cyAEV9bZ4_nYuefQnPOrXvpQTY_7peXnoCjlgI,765
+pyserials/exception/read.py,sha256=4_OQ6SUvxR61TN0_1v5SK5MgBeJlgYz8j9vJb_6abNY,9275
+pyserials/exception/update.py,sha256=P0js2-iY2fgO_KLdqedgWE3TTS5Xz15cusZY_wuKIW4,4222
+pyserials/exception/validate.py,sha256=gsvbq1bIHHKlIf-KJc7-PSzDZmYDxUFWiYEApJgcm74,7465
+PySerials-0.0.0.dev6.dist-info/METADATA,sha256=-o3uQuTjzfx7Q7zLSCi9CRHLgDIKtYKAtnLK6HVqzxc,357
+PySerials-0.0.0.dev6.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+PySerials-0.0.0.dev6.dist-info/top_level.txt,sha256=SAks7WjSjdkv3i9Hvt4gY_P7VQbhhYJN5mf5dqx1aao,10
+PySerials-0.0.0.dev6.dist-info/RECORD,,

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

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

pyserials/exception/_base.py

@@ -1,58 +1,26 @@
 """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
 
+from typing import TYPE_CHECKING as _TYPE_CHECKING
+
+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"),
-}
+if _TYPE_CHECKING:
+    from mdit import Document
 
 
 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",
-    ):
+    def __init__(self, report: Document):
         super().__init__(
-            message=message,
-            description=description,
-            message_html=message_html,
-            description_html=description_html,
-            report_heading=report_heading,
+            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
-
-
-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,19 +1,19 @@
 """Exceptions raised by `pyserials.read` module."""
 
 from __future__ import annotations
-from typing import Literal as _Literal
+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 markitup import html as _html, md as _md
 from tomlkit.exceptions import TOMLKitError as _TOMLKitError
 
-from pyserials.exception._base import PySerialsException as _PySerialsException
+from pyserials.exception import _base
 
 
-class PySerialsReadException(_PySerialsException):
+class PySerialsReadException(_base.PySerialsException):
     """Base class for all exceptions raised by `pyserials.read` module.
 
     Attributes
@@ -29,25 +29,28 @@ class PySerialsReadException(_PySerialsException):
     def __init__(
         self,
         source_type: _Literal["file", "string"],
-        description: str,
-        description_html: str | _html.Element | None = None,
+        problem,
+        section: dict | 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",
+        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
@@ -58,8 +61,8 @@ 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)
+        problem = f"The string is empty."
+        super().__init__(problem=problem, source_type="string", data_type=data_type)
         return
 
 
@@ -67,12 +70,20 @@ 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."
+        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__(description=description, source_type="file", filepath=filepath)
+        super().__init__(problem=problem, source_type="file", filepath=filepath)
         return
 
 
@@ -80,8 +91,8 @@ 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)
+        problem = f"The file does not exist."
+        super().__init__(problem=problem, source_type="file", data_type=data_type, filepath=filepath)
         return
 
 
@@ -89,8 +100,8 @@ 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)
+        problem = f"The file is empty."
+        super().__init__(problem=problem, source_type="file", data_type=data_type, filepath=filepath)
         return
 
 
@@ -121,17 +132,18 @@ class PySerialsInvalidDataError(PySerialsReadException):
         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
+            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
+                self.context_data_type = cause.context_mark.name.removeprefix("<").removesuffix(">")
         elif isinstance(cause, _json.JSONDecodeError):
             self.problem = cause.msg
             self.problem_line = cause.lineno
@@ -141,71 +153,88 @@ class PySerialsInvalidDataError(PySerialsReadException):
             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"
+        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)
+            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, mode: _Literal["full", "short"], md: bool) -> _html.elem.Ul:
+    def _report_content(self) -> dict:
 
         def make_tabel(problem, line, column, data_type):
-            rows = [
-                [title, value] for title, value in [
+            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 _html.elem.table_from_rows(rows_body=rows)
+            return _mdit.element.field_list(items)
 
-        content_list = [
-            _html.elem.details(
-                [
-                    _html.elem.summary("❌ Problem"),
-                    make_tabel(self.problem, self.problem_line, self.problem_column, self.problem_data_type)
-                ]
-            ),
-        ]
+        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_list.append(
-                _html.elem.details(
-                    [
-                        _html.elem.summary("🔍 Context"),
-                        make_tabel(self.context, self.context_line, self.context_column, self.context_data_type)
-                    ]
-                ),
+            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,
             )
-        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])
+            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/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/exception/validate.py

@@ -1,11 +1,12 @@
 """Exceptions raised by `pyserials.validate` module."""
 
 from __future__ import annotations
-from typing import Any as _Any, Literal as _Literal
+from typing import Any as _Any
 
 import jsonschema as _jsonschema
-from markitup.html import elem as _html
-from markitup.md import elem as _md
+import mdit as _mdit
+from pyprotocol import Stringable
+
 from pyserials import write as _write
 from pyserials.exception import _base
 
@@ -25,23 +26,27 @@ class PySerialsValidateException(_base.PySerialsException):
 
     def __init__(
         self,
-        description: str,
+        problem: str,
         data: dict | list | str | int | float | bool,
         schema: dict,
         validator: _Any,
         registry: _Any = None,
-        description_html: str | _html.Element | None = None,
+        section: dict | 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",
+        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
@@ -60,7 +65,7 @@ class PySerialsInvalidJsonSchemaError(PySerialsValidateException):
         registry: _Any = None,
     ):
         super().__init__(
-            description="The schema is invalid.",
+            problem="The schema is invalid.",
             data=data,
             schema=schema,
             validator=validator,
@@ -81,10 +86,9 @@ class PySerialsJsonSchemaValidationError(PySerialsValidateException):
         registry: _Any = None,
     ):
         self.causes = causes
-        description, description_html = self._parse_errors()
         super().__init__(
-            description=description,
-            description_html=description_html,
+            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,
@@ -92,133 +96,92 @@ class PySerialsJsonSchemaValidationError(PySerialsValidateException):
         )
         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 _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 _parse_error(
+    def _generate_error_report(
         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}",
+    ) -> _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))
+            ),
         ]
-        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),
+        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:
-            contexts = []
+            context_paths = []
             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,
+                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
                 )
-                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,
+            )
+            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
 
-    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,
+    @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",
         )
-
-    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,
+        admo = _mdit.element.admonition(
+            type=admo_type,
+            title=_mdit.inline_container(f"**{title}**: ", _mdit.element.code_span(title_details)),
+            content=code_block,
+            dropdown=True,
         )
-
-    @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
+        return admo
 
     @staticmethod
     def _parse_error_message(error: _jsonschema.exceptions.ValidationError) -> str:
@@ -228,16 +191,26 @@ class PySerialsJsonSchemaValidationError(PySerialsValidateException):
             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]
+        return f"{problem.removeprefix(".")}."
 
     @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)}"
+    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)