PySerials 0.1.2__tar.gz → 0.1.3__tar.gz

{pyserials-0.1.2 → pyserials-0.1.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: PySerials
-Version: 0.1.2
-Requires-Python: >=3.10
+Version: 0.1.3
+Requires-Python: >=3.12
 Requires-Dist: jsonschema<5,>=4.21.0
 Requires-Dist: referencing>=0.35.1
-Requires-Dist: jsonpath-ng<2,>=1.6.1
+Requires-Dist: jsonpath-ng<1.8.0,>=1.6.1
 Requires-Dist: ruamel.yaml>=0.18
 Requires-Dist: ruamel.yaml.string<1,>=0.1.1
 Requires-Dist: tomlkit<0.14,>=0.11.8

{pyserials-0.1.2 → pyserials-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 
 [build-system]
-requires = ["setuptools>=61.0", "versioningit"]
+requires = ["setuptools>=61.0", "versioningit", "mypy>=1.0"]
 build-backend = "setuptools.build_meta"
 
 
@@ -17,12 +17,12 @@ namespaces = true
 # ----------------------------------------- Project Metadata -------------------------------------
 #
 [project]
-version = "0.1.2"
+version = "0.1.3"
 name = "PySerials"
 dependencies = [
     "jsonschema >= 4.21.0, < 5",
     "referencing >= 0.35.1",
-    "jsonpath-ng >= 1.6.1, < 2",
+    "jsonpath-ng >= 1.6.1, < 1.8.0",
     "ruamel.yaml >= 0.18", # https://yaml.readthedocs.io/en/stable/
     "ruamel.yaml.string >= 0.1.1, < 1",
     "tomlkit >= 0.11.8, < 0.14", # https://tomlkit.readthedocs.io/en/stable/,
@@ -30,4 +30,4 @@ dependencies = [
     "ExceptionMan >=0.1,<0.2",
     "ProtocolMan >=0.1,<0.2",
 ]
-requires-python = ">=3.10"
+requires-python = ">=3.12"

pyserials-0.1.3/setup.py

@@ -0,0 +1,141 @@
+"""PySerials Setup Script
+
+Usage
+-----
+- Build with mypyc (default when available):
+```
+python -m build
+```
+
+- Development install with compiled extensions:
+```
+pip install -e .
+```
+
+- Force pure-Python build even when compilers are available:
+```
+DISABLE_MYPYC=1 pip install -e .
+```
+
+Notes
+-----
+Compiled extensions are built when **both** conditions are met:
+
+1. **DISABLE_MYPYC** — The environment variable is not set to a truthy
+   value (``1``, ``true``, or ``yes``, case-insensitive).
+   Defaults to unset (enabled).
+
+2. **SHOULD_COMPILE** — The setup command includes a compilation-triggering
+   argument: ``bdist_wheel``, ``editable_wheel``, ``build_ext``, ``build``,
+   ``install``, or ``develop``.
+   Commands like ``egg_info`` or ``sdist`` skip compilation entirely.
+
+If build dependencies are missing or compilation fails,
+the build raises an error and stops.
+
+mypyc modules
+~~~~~~~~~~~~~
+Only modules with measured speedup and no subclassing risk are compiled:
+
+- ``pyserials.compare``  — Recursive dict/list comparison (2.2x speedup).
+- ``pyserials.flatten``  — Nested-to-flat dict conversion (2.4x speedup).
+- ``pyserials.format``   — TOML/YAML object conversion (1.3–2.6x speedup).
+- ``pyserials.update``   — Template filler & recursive update (1.4–2.5x speedup).
+
+Modules intentionally kept as pure Python:
+
+- ``pyserials.read`` / ``pyserials.write`` — I/O-bound; ~98% time in
+  ruamel.yaml / tomlkit / json. Compilation yields only 1.1x.
+- ``pyserials.validate`` — Actually *slower* compiled (0.5–0.9x) due to
+  mypyc boxing overhead at the untyped jsonschema boundary.
+- ``pyserials.property_dict`` / ``pyserials.nested_dict`` — Compiled classes
+  cannot be subclassed from interpreted Python, which would be a breaking
+  change for downstream users.
+"""
+
+import logging
+import os
+import sys
+
+from setuptools import setup, Extension
+
+
+SRC_DIR: str = "src/pyserials"
+
+log = logging.getLogger("pyserials.setup")
+logging.basicConfig(level=logging.INFO, format="%(name)s: %(message)s")
+
+COMPILE_COMMANDS = {
+    "bdist_wheel",
+    "editable_wheel",
+    "build_ext",
+    "build",
+    "install",
+    "develop",
+}
+IS_COMPILE_COMMAND = bool(set(sys.argv) & COMPILE_COMMANDS)
+DISABLE_MYPYC = os.environ.get("DISABLE_MYPYC", "").lower() in ("1", "true", "yes")
+
+# Number of parallel compilation jobs (C compiler invocations).
+# Defaults to os.cpu_count(); override with BUILD_PARALLEL=N.
+PARALLEL = int(os.environ.get("BUILD_PARALLEL", os.cpu_count() or 1))
+
+# mypyc modules to compile (hot-path only; keep error handling in pure Python).
+MYPYC_MODULES = [
+    f"{SRC_DIR}/compare.py",
+    f"{SRC_DIR}/flatten.py",
+    f"{SRC_DIR}/format.py",
+    f"{SRC_DIR}/update.py",
+]
+
+
+def create_mypyc_extensions() -> list[Extension]:
+    """Create mypyc-compiled extensions for performance-critical modules."""
+    try:
+        from mypyc.build import mypycify
+    except ImportError as exc:
+        log.critical("mypyc dependency not found: %s", exc)
+        raise RuntimeError("mypyc dependency not found") from exc
+
+    try:
+        log.info("mypyc modules: %s", MYPYC_MODULES)
+        ext_modules = mypycify(
+            ["--ignore-missing-imports", *MYPYC_MODULES],
+            opt_level="3",
+            debug_level="0",
+            strip_asserts=True,
+            multi_file=False,
+            verbose=True,
+        )
+        log.info("Compiling %d mypyc extensions", len(ext_modules))
+        return ext_modules
+
+    except (Exception, SystemExit) as exc:
+        log.critical("mypyc compilation failed (%s): %s", type(exc).__name__, exc)
+        raise RuntimeError("mypyc compilation failed") from exc
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+log.info(
+    "Setup script invoked by %s command: %s",
+    "build" if IS_COMPILE_COMMAND else "metadata-only",
+    " ".join(sys.argv),
+)
+log.info(
+    "Setup configuration: DISABLE_MYPYC=%s, BUILD_PARALLEL=%d",
+    DISABLE_MYPYC,
+    PARALLEL,
+)
+
+ext_modules: list[Extension] = []
+
+if IS_COMPILE_COMMAND and not DISABLE_MYPYC:
+    ext_modules.extend(create_mypyc_extensions())
+
+setup(
+    ext_modules=ext_modules,
+    options={"build_ext": {"parallel": PARALLEL}},
+)

{pyserials-0.1.2 → pyserials-0.1.3}/src/PySerials.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: PySerials
-Version: 0.1.2
-Requires-Python: >=3.10
+Version: 0.1.3
+Requires-Python: >=3.12
 Requires-Dist: jsonschema<5,>=4.21.0
 Requires-Dist: referencing>=0.35.1
-Requires-Dist: jsonpath-ng<2,>=1.6.1
+Requires-Dist: jsonpath-ng<1.8.0,>=1.6.1
 Requires-Dist: ruamel.yaml>=0.18
 Requires-Dist: ruamel.yaml.string<1,>=0.1.1
 Requires-Dist: tomlkit<0.14,>=0.11.8

{pyserials-0.1.2 → pyserials-0.1.3}/src/PySerials.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 pyproject.toml
+setup.py
 src/PySerials.egg-info/PKG-INFO
 src/PySerials.egg-info/SOURCES.txt
 src/PySerials.egg-info/dependency_links.txt

{pyserials-0.1.2 → pyserials-0.1.3}/src/PySerials.egg-info/requires.txt

@@ -1,6 +1,6 @@
 jsonschema<5,>=4.21.0
 referencing>=0.35.1
-jsonpath-ng<2,>=1.6.1
+jsonpath-ng<1.8.0,>=1.6.1
 ruamel.yaml>=0.18
 ruamel.yaml.string<1,>=0.1.1
 tomlkit<0.14,>=0.11.8

pyserials-0.1.3/src/pyserials/__init__.py

@@ -0,0 +1,38 @@
+"""PySerials: A Python package for reading, writing, validating, and transforming serialized data.
+
+PySerials provides utilities for working with JSON, YAML, and TOML data formats,
+including reading/writing files and strings, recursive dictionary updates,
+template filling, JSON Schema validation, data comparison, and flattening of
+nested structures.
+
+Modules
+-------
+read
+    Read serialized data from files and strings.
+write
+    Write data to serialized format strings and files.
+update
+    Recursively update data structures and fill templates.
+validate
+    Validate data against JSON schemas.
+compare
+    Compare two data structures and report differences.
+format
+    Convert data to specific TOML/YAML object types.
+flatten
+    Flatten nested dictionaries to single-level dictionaries.
+exception
+    Custom exception classes for error reporting.
+
+Classes
+-------
+NestedDict
+    A dictionary wrapper supporting dot-separated key access and template filling.
+PropertyDict
+    A dictionary wrapper supporting attribute-style access.
+"""
+
+from pyserials import exception, update, validate, read, write, format, compare
+from pyserials.nested_dict import NestedDict
+from pyserials.property_dict import PropertyDict
+from pyserials.flatten import flatten

pyserials-0.1.3/src/pyserials/compare.py

@@ -0,0 +1,88 @@
+"""Compare two data structures and report differences.
+
+This module provides functionality to recursively compare nested data structures
+(dicts, lists, tuples, and scalar values), producing categorized lists of
+JSONPath-like paths indicating which elements were added, removed, modified,
+or left unchanged.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+def items(
+    source: Any,
+    target: Any,
+    path: str = "$",
+) -> dict[str, list[str]]:
+    """Recursively compare two data structures and categorize differences.
+
+    Walks both ``source`` and ``target`` in parallel, emitting JSONPath-style
+    strings for every leaf.  Paths are grouped into four categories:
+
+    * **added** – present in *source* but not in *target*.
+    * **removed** – present in *target* but not in *source*.
+    * **modified** – present in both but with different values or types.
+    * **unchanged** – present in both with the same value.
+
+    .. note::
+        Type comparison uses ``type(x) is type(y)`` (exact equality), not
+        ``isinstance``.  Any type mismatch — including subclass vs base class
+        (e.g. ``True`` vs ``1``, ``OrderedDict`` vs ``dict``) — causes the
+        entire node to be marked **modified** with no further traversal into
+        its children.  Two nodes are traversed recursively only when their
+        exact types match.
+
+    Parameters
+    ----------
+    source : Any
+        The *new* data structure (additions relative to *target*).
+    target : Any
+        The *old* / reference data structure.
+    path : str, default ``"$"``
+        Root JSONPath prefix for all emitted paths.
+
+    Returns
+    -------
+    dict[str, list[str]]
+        A mapping with keys ``"added"``, ``"removed"``, ``"modified"``,
+        and ``"unchanged"``, each containing a sorted list of JSONPath strings.
+    """
+
+    def recursive_compare(src: Any, trg: Any, curr_path: str) -> None:
+        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: int = len(src)
+            len_trg: int = len(trg)
+            min_len: int = 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: dict[str, list[str]] = {
+        "added": [],
+        "removed": [],
+        "modified": [],
+        "unchanged": [],
+    }
+    recursive_compare(source, target, path)
+    return {key: sorted(comp[key]) for key in comp}

pyserials-0.1.3/src/pyserials/exception/__init__.py

@@ -0,0 +1,8 @@
+"""Exceptions raised by PySerials.
+
+All exceptions inherit from :class:`PySerialsException`, which itself
+extends ``exceptionman.ReporterException`` for rich error reporting.
+"""
+
+from pyserials.exception._base import PySerialsException
+from pyserials.exception import read, update, validate

{pyserials-0.1.2 → pyserials-0.1.3}/src/pyserials/exception/_base.py

@@ -5,22 +5,32 @@ from __future__ import annotations
 from typing import TYPE_CHECKING as _TYPE_CHECKING
 from functools import partial as _partial
 
-from exceptionman import ReporterException as _ReporterException
-import mdit as _mdit
+from exceptionman import ReporterException as _ReporterException  # type: ignore[import-untyped]
+import mdit as _mdit  # type: ignore[import-untyped]
 
 if _TYPE_CHECKING:
     from mdit import Document
 
 
-class PySerialsException(_ReporterException):
-    """Base class for all exceptions raised by PySerials."""
+class PySerialsException(_ReporterException):  # type: ignore[misc]
+    """Base class for all exceptions raised by PySerials.
 
-    def __init__(self, report: Document):
-        sphinx_config = {"html_title": "PySerials Error Report"}
+    Wraps an ``mdit.Document`` error report and configures Sphinx rendering.
+
+    Parameters
+    ----------
+    report : mdit.Document
+        The structured error report document.
+    """
+
+    __slots__ = ()
+
+    def __init__(self, report: Document) -> None:
+        sphinx_config: dict[str, str] = {"html_title": "PySerials Error Report"}
         sphinx_target_config = _mdit.target.sphinx(
             renderer=_partial(
                 _mdit.render.sphinx,
-                config=_mdit.render.get_sphinx_config(sphinx_config)
+                config=_mdit.render.get_sphinx_config(sphinx_config),
             )
         )
         report.target_configs["sphinx"] = sphinx_target_config

{pyserials-0.1.2 → pyserials-0.1.3}/src/pyserials/exception/read.py

@@ -5,8 +5,9 @@ from typing import Literal as _Literal
 from pathlib import Path as _Path
 
 import ruamel.yaml as _yaml
+from ruamel.yaml.error import MarkedYAMLError as _MarkedYAMLError
 import json as _json
-import mdit as _mdit
+import mdit as _mdit  # type: ignore[import-untyped]
 
 from tomlkit.exceptions import TOMLKitError as _TOMLKitError
 
@@ -26,19 +27,23 @@ class PySerialsReadException(_base.PySerialsException):
         Path to the input datafile, if data was read from a file.
     """
 
+    __slots__ = ("source_type", "data_type", "filepath")
+
     def __init__(
         self,
         source_type: _Literal["file", "string"],
-        problem,
-        section: dict | None = None,
+        problem: str | list[str] | object,
+        section: dict[str, object] | None = None,
         data_type: _Literal["json", "yaml", "toml"] | None = None,
         filepath: _Path | None = 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(
+            "string."
+            if source_type == "string"
+            else _mdit.inline_container(
                 "file at ", _mdit.element.code_span(filepath), "."
             ),
             separator=" ",
@@ -61,8 +66,10 @@ class PySerialsReadException(_base.PySerialsException):
 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."
+    __slots__ = ()
+
+    def __init__(self, data_type: _Literal["json", "yaml", "toml"]) -> None:
+        problem = "The string is empty."
         super().__init__(problem=problem, source_type="string", data_type=data_type)
         return
 
@@ -70,19 +77,21 @@ class PySerialsEmptyStringError(PySerialsReadException):
 class PySerialsInvalidFileExtensionError(PySerialsReadException):
     """Exception raised when a file to be read has an unrecognized extension."""
 
-    def __init__(self, filepath: _Path):
+    __slots__ = ()
+
+    def __init__(self, filepath: _Path) -> None:
         problem = _mdit.inline_container(
             "The file extension must be one of ",
-            _mdit.element.code_span('json'),
+            _mdit.element.code_span("json"),
             ", ",
-            _mdit.element.code_span('yaml'),
+            _mdit.element.code_span("yaml"),
             ", ",
-            _mdit.element.code_span('yml'),
+            _mdit.element.code_span("yml"),
             ", or ",
-            _mdit.element.code_span('.toml'),
+            _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."
+            _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
@@ -91,18 +100,30 @@ class PySerialsInvalidFileExtensionError(PySerialsReadException):
 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)
+    __slots__ = ()
+
+    def __init__(
+        self, data_type: _Literal["json", "yaml", "toml"], filepath: _Path
+    ) -> None:
+        problem: str = "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)
+    __slots__ = ()
+
+    def __init__(
+        self, data_type: _Literal["json", "yaml", "toml"], filepath: _Path
+    ) -> None:
+        problem: str = "The file is empty."
+        super().__init__(
+            problem=problem, source_type="file", data_type=data_type, filepath=filepath
+        )
         return
 
 
@@ -115,6 +136,19 @@ class PySerialsInvalidDataError(PySerialsReadException):
         The input data that was supposed to be read.
     """
 
+    __slots__ = (
+        "data",
+        "cause",
+        "problem",
+        "problem_line",
+        "problem_column",
+        "problem_data_type",
+        "context",
+        "context_line",
+        "context_column",
+        "context_data_type",
+    )
+
     def __init__(
         self,
         source_type: _Literal["file", "string"],
@@ -122,7 +156,7 @@ class PySerialsInvalidDataError(PySerialsReadException):
         data: str,
         cause: Exception,
         filepath: _Path | None = None,
-    ):
+    ) -> None:
         self.data = data
         self.cause = cause
         self.problem: str = str(cause)
@@ -135,25 +169,31 @@ class PySerialsInvalidDataError(PySerialsReadException):
         self.context_data_type: str | None = None
         self.data_type = data_type
 
-        if isinstance(cause, _yaml.YAMLError):
+        if isinstance(cause, _MarkedYAMLError):
             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_data_type = cause.problem_mark.name.removeprefix(
+                "<"
+            ).removesuffix(">")
             self.problem = cause.problem.strip()
             if cause.context:
                 self.context = cause.context.strip()
                 if cause.context_mark:
                     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(">")
+                    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_line = getattr(cause, "line", None)
+            self.problem_column = getattr(cause, "col", None)
+            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:
@@ -171,34 +211,51 @@ class PySerialsInvalidDataError(PySerialsReadException):
             source_type=source_type,
             section=self._report_content(),
             data_type=data_type,
-            filepath=filepath
+            filepath=filepath,
         )
         return
 
-    def _report_content(self) -> dict:
+    def _report_content(self) -> dict[str, _mdit.element.Admonition]:
 
-        def make_table(problem, line, column, data_type):
+        def make_table(
+            problem: str | None,
+            line: int | None,
+            column: int | None,
+            data_type: str | None,
+        ) -> _mdit.element.FieldList:
             items = [
-                _mdit.element.field_list_item(title=title, body=value) for title, value in [
-                    ["Description", problem],
-                    ["Line Number", line],
-                    ["Column Number", column],
-                    ["Data Type", data_type],
-                ] if value is not None
+                _mdit.element.field_list_item(title=title, body=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(
                 title="Problem",
-                body=make_table(self.problem, self.problem_line, self.problem_column, self.problem_data_type),
+                body=make_table(
+                    self.problem,
+                    self.problem_line,
+                    self.problem_column,
+                    self.problem_data_type,
+                ),
                 type="error",
             )
         }
         if self.context:
             content["context_details"] = _mdit.element.admonition(
                 title="Context",
-                body=make_table(self.context, self.context_line, self.context_column, self.context_data_type),
+                body=make_table(
+                    self.context,
+                    self.context_line,
+                    self.context_column,
+                    self.context_data_type,
+                ),
                 type="note",
             )
 
@@ -207,16 +264,22 @@ class PySerialsInvalidDataError(PySerialsReadException):
             language=self.data_type,
             caption="Data",
             line_num=True,
-            emphasize_lines=[line for line in (self.problem_line, self.context_line) if line],
+            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,
+                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)",
+                caption="Data"
+                if len(self.data) <= 1000
+                else "Data (truncated to first 1000 characters)",
                 line_num=True,
             )
         else:
@@ -224,10 +287,12 @@ class PySerialsInvalidDataError(PySerialsReadException):
                 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_start_val = self.problem_line or self.context_line
+                assert line_start_val is not None
+                line_start = line_start_val
                 line_end = line_start
             data_lines = self.data.splitlines()
-            selected_lines = data_lines[line_start - 1:line_end]
+            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,