parse-errors 0.5.0__py3-none-any.whl

parse_errors/__init__.py

@@ -0,0 +1,13 @@
+"""re-raise parse errors with filename and line number."""
+
+from .context import ParseContext, ParseError
+
+try:
+    from ._version import __version__
+except ImportError:  # pragma: no cover
+    __version__ = "dev"
+
+__all__ = [
+    "ParseContext",
+    "ParseError",
+]

parse_errors/_jsonpath.py

@@ -0,0 +1,70 @@
+"""Convert JSONPath expressions to JSON Pointer (RFC 6901)."""
+
+from __future__ import annotations
+
+import re
+
+
+# Matches a single step in a JSONPath: .key or [index] or ['key'] or ["key"]
+_STEP = re.compile(
+    r"\.(?P<name>[^.\[]+)"  # .key
+    r"|\[(?P<idx>\d+)\]"  # [0]
+    r"|\[\'(?P<sq>[^\']*)\'\]"  # ['key']
+    r'|\["(?P<dq>[^"]*)"\]'  # ["key"]
+)
+
+# Pattern to extract JSONPath from msgspec-style error messages: "... - at `$.foo.bar`"
+_AT_PATH = re.compile(r" - at `(\$[^`]*)`")
+
+
+def jsonpath_to_pointer(jsonpath: str) -> str:
+    """Convert a JSONPath string like ``$.foo[0].bar`` to a JSON Pointer like ``/foo/0/bar``.
+
+    Only supports simple dot-notation and bracket-index forms as produced by
+    msgspec.  Does not support filter expressions or wildcards.
+
+    Args:
+        jsonpath: A JSONPath string starting with ``$``.
+
+    Returns:
+        A JSON Pointer string (RFC 6901), e.g. ``/foo/0/bar``.
+    """
+    if jsonpath == "$":
+        return ""
+    if not jsonpath.startswith("$"):
+        raise ValueError(f"JSONPath must start with '$', got: {jsonpath!r}")
+
+    tail = jsonpath[1:]  # strip leading $
+    parts: list[str] = []
+
+    pos = 0
+    while pos < len(tail):
+        m = _STEP.match(tail, pos)
+        if m is None:
+            raise ValueError(
+                f"Cannot parse JSONPath step at position {pos}: {tail[pos:]!r}"
+            )
+        name = m.group("name") or m.group("sq") or m.group("dq") or m.group("idx")
+        parts.append(_escape(name))
+        pos = m.end()
+
+    return "/" + "/".join(parts) if parts else ""
+
+
+def extract_jsonpath(message: str) -> str | None:
+    """Extract a JSONPath expression from an error message.
+
+    Looks for the pattern ``- at `$.path``` as used by msgspec.
+
+    Args:
+        message: The exception message string.
+
+    Returns:
+        The JSONPath string if found, otherwise ``None``.
+    """
+    m = _AT_PATH.search(message)
+    return m.group(1) if m else None
+
+
+def _escape(segment: str) -> str:
+    return segment.replace("~", "~0").replace("/", "~1")

parse_errors/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.5.0'
+__version_tuple__ = version_tuple = (0, 5, 0)
+
+__commit_id__ = commit_id = None

parse_errors/context.py

@@ -0,0 +1,83 @@
+"""Context manager for better parse error messages."""
+
+from __future__ import annotations
+
+import os
+import contextlib
+from pathlib import Path
+from typing import Iterator
+
+from .source_map import detect_format, build_source_map, closest_entry
+from ._jsonpath import extract_jsonpath, jsonpath_to_pointer
+
+__all__ = ["ParseError", "ParseContext"]
+
+
+class ParseError(Exception):
+    """A parse or validation error augmented with filename and line number."""
+
+    def __init__(
+        self, message: str, filename: str | os.PathLike[str], line: int, column: int = 0
+    ):
+        self.filename = str(filename)
+        self.line = line
+        self.column = column
+        super().__init__(message)
+
+
+@contextlib.contextmanager
+def ParseContext(
+    filename: str | os.PathLike[str],
+    *,
+    data: str | bytes | None = None,
+    format: str | None = None,
+) -> Iterator[None]:
+    """Context manager that re-raises parse/validation errors with location info.
+
+    Catches exceptions whose message contains a JSONPath (e.g. as emitted by
+    msgspec) and re-raises a :class:`ParseError` with the filename and
+    1-based line number derived from the file's source map.
+
+    Args:
+        filename: Path to the file being parsed.
+        data: The file contents as a string or bytes (UTF-8).  If provided, the
+              file is not read from disk.  Regardless of type, reported
+              locations (line, column) are always in characters, not bytes.
+        format: One of ``"json"``, ``"yaml"``, or ``"toml"``.  If omitted the
+                format is inferred from the file extension.
+    """
+    try:
+        yield
+    except Exception as exc:
+        message = str(exc)
+        # This is focused on msgspec-style exceptions, which use JSONPath for
+        # some reason.  If there are other formats we know can be raised,
+        # adjust this.
+        jsonpath = extract_jsonpath(message)
+        if jsonpath is None:
+            raise
+
+        try:
+            pointer = jsonpath_to_pointer(jsonpath)
+        except ValueError:  # pragma: no cover
+            raise exc
+
+        path = Path(filename)
+        fmt = format or detect_format(path)
+        assert fmt is not None
+
+        source = data if data is not None else path.read_bytes()
+        source_map = build_source_map(source, fmt)
+
+        entry = closest_entry(source_map, pointer)
+        if entry is None:  # pragma: no cover
+            raise exc
+
+        loc = entry.value_start
+        # Lines are 0-based in source maps; convert to 1-based for humans.
+        raise ParseError(
+            f"{path}:{loc.line + 1}:{loc.column + 1}: {message}",
+            filename=path,
+            line=loc.line + 1,
+            column=loc.column + 1,
+        ) from exc

parse_errors/json_source_map/__init__.py

@@ -0,0 +1,25 @@
+"""Thin wrapper around the json-source-map package that returns our own types."""
+
+from __future__ import annotations
+
+import json_source_map as _ext
+
+from ..source_map import Entry, Location, TSourceMap
+
+
+def calculate(source: str) -> TSourceMap:
+    """Calculate the source map for a JSON document."""
+    return {
+        pointer: Entry(
+            value_start=_loc(e.value_start),
+            value_end=_loc(e.value_end),
+            key_start=_loc(e.key_start) if e.key_start is not None else None,
+            key_end=_loc(e.key_end) if e.key_end is not None else None,
+        )
+        for pointer, e in _ext.calculate(source).items()
+    }
+
+
+def _loc(ext: _ext.Location) -> Location:
+    """Translate to our internal structure."""
+    return Location(line=ext.line, column=ext.column, position=ext.position)

parse_errors/json_source_map/__main__.py

@@ -0,0 +1,7 @@
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+    from . import calculate
+
+    source = open(sys.argv[1]).read()
+    for pointer, entry in calculate(source).items():
+        print(f"{pointer!r:40s} {entry}")

parse_errors/source_map.py

@@ -0,0 +1,77 @@
+"""Source map types and utilities for parse_errors."""
+
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+from typing import Dict, Optional
+
+
+# These are identical to the ones in json-source-map, but I feel icky exporting
+# some other project's types because they may change.
+
+
+@dataclasses.dataclass
+class Location:
+    line: int  # 0-based line number
+    column: int  # 0-based character offset within the line (not bytes)
+    position: int  # 0-based character offset from start of document (not bytes)
+
+
+@dataclasses.dataclass
+class Entry:
+    value_start: Location
+    value_end: Location
+    key_start: Optional[Location] = None
+    key_end: Optional[Location] = None
+
+
+TSourceMap = Dict[str, Entry]
+
+
+def detect_format(path: Path) -> str | None:
+    """Detect the format of a file based on its extension."""
+    suffix = path.suffix.lower()
+    return {
+        ".json": "json",
+        ".toml": "toml",
+        ".yaml": "yaml",
+        ".yml": "yaml",
+    }.get(suffix)
+
+
+def build_source_map(source: str | bytes, fmt: str) -> TSourceMap:
+    """Build a source map for the given source in the given format."""
+    if fmt == "toml":
+        from . import toml_source_map
+
+        return toml_source_map.calculate(source)
+    elif fmt in ("yaml", "yml"):
+        from . import yaml_source_map
+
+        return yaml_source_map.calculate(
+            source.decode("utf-8") if isinstance(source, bytes) else source
+        )
+    elif fmt == "json":
+        from . import json_source_map
+
+        return json_source_map.calculate(
+            source.decode("utf-8") if isinstance(source, bytes) else source
+        )
+    else:
+        raise ValueError(f"Unknown format: {fmt!r}")
+
+
+def closest_entry(source_map: TSourceMap, pointer: str) -> Entry | None:
+    """Return the source map entry for ``pointer``, falling back to the longest prefix."""
+    if pointer in source_map:
+        return source_map[pointer]
+
+    # Walk up the pointer path until we find a match.
+    parts = pointer.split("/")  # e.g. ['', 'foo', 'bar']
+    for length in range(len(parts) - 1, 0, -1):
+        candidate = "/".join(parts[:length])
+        if candidate in source_map:
+            return source_map[candidate]
+
+    return None

parse_errors/toml_source_map/__init__.py

@@ -0,0 +1,194 @@
+"""Calculate the source map for a TOML document using tree-sitter."""
+
+from __future__ import annotations
+
+import tree_sitter_toml
+import tree_sitter as ts
+from ..source_map import Entry, Location, TSourceMap
+from .._jsonpath import _escape
+
+
+def calculate(source: str | bytes) -> TSourceMap:
+    """Calculate the source map for a TOML document.
+
+    Args:
+        source: The TOML document as a string or bytes.
+
+    Returns:
+        A dict mapping JSON Pointer paths to Entry objects with location info.
+    """
+    src_bytes = source if isinstance(source, bytes) else source.encode("utf-8")
+    parser = ts.Parser(ts.Language(tree_sitter_toml.language()))
+    root = parser.parse(src_bytes).root_node
+
+    result: TSourceMap = {}
+    aot_counts: dict[str, int] = {}
+
+    result[""] = Entry(
+        value_start=_loc(root.start_point, src_bytes),
+        value_end=_loc(root.end_point, src_bytes),
+    )
+
+    for child in root.children:
+        if child.type == "pair":
+            _process_pair(child, [], result, src_bytes)
+        elif child.type == "table":
+            _process_table(child, result, aot_counts, src_bytes)
+        elif child.type == "table_array_element":
+            _process_aot(child, result, aot_counts, src_bytes)
+
+    return result
+
+
+def _process_pair(
+    node: ts.Node,
+    prefix: list[str],
+    result: TSourceMap,
+    src: bytes,
+) -> None:
+    key_node, value_node = _pair_key_value(node)
+    segments = prefix + _key_segments(key_node)
+    pointer = _to_pointer(segments)
+
+    if value_node.type == "inline_table":
+        result[pointer] = Entry(
+            value_start=_loc(value_node.start_point, src),
+            value_end=_loc(value_node.end_point, src),
+            key_start=_loc(key_node.start_point, src),
+            key_end=_loc(key_node.end_point, src),
+        )
+        for child in value_node.children:
+            if child.type == "pair":
+                _process_pair(child, segments, result, src)
+    else:
+        result[pointer] = Entry(
+            value_start=_loc(value_node.start_point, src),
+            value_end=_loc(value_node.end_point, src),
+            key_start=_loc(key_node.start_point, src),
+            key_end=_loc(key_node.end_point, src),
+        )
+
+
+def _process_table(
+    node: ts.Node,
+    result: TSourceMap,
+    aot_counts: dict[str, int],
+    src: bytes,
+) -> None:
+    key_node = _table_key(node)
+    segments = _expand_aot_segments(_key_segments(key_node), aot_counts)
+    pointer = _to_pointer(segments)
+
+    result[pointer] = Entry(
+        value_start=_loc(node.start_point, src),
+        value_end=_loc(node.end_point, src),
+    )
+
+    for child in node.children:
+        if child.type == "pair":
+            _process_pair(child, segments, result, src)
+
+
+def _process_aot(
+    node: ts.Node,
+    result: TSourceMap,
+    aot_counts: dict[str, int],
+    src: bytes,
+) -> None:
+    key_node = _table_key(node)
+    segments = _key_segments(key_node)
+    array_pointer = _to_pointer(segments)
+
+    idx = aot_counts.get(array_pointer, 0)
+    aot_counts[array_pointer] = idx + 1
+
+    item_segments = segments + [str(idx)]
+    item_pointer = _to_pointer(item_segments)
+
+    entry_loc = _loc(node.start_point, src)
+    result.setdefault(array_pointer, Entry(value_start=entry_loc, value_end=entry_loc))
+    result[item_pointer] = Entry(
+        value_start=entry_loc,
+        value_end=_loc(node.end_point, src),
+    )
+
+    for child in node.children:
+        if child.type == "pair":
+            _process_pair(child, item_segments, result, src)
+
+
+def _pair_key_value(node: ts.Node) -> tuple[ts.Node, ts.Node]:
+    """Return (key_node, value_node) from a pair node."""
+    key_node = value_node = None
+    for child in node.children:
+        if child.type in ("bare_key", "quoted_key", "dotted_key"):
+            key_node = child
+        elif child.type not in ("=", "comment"):
+            value_node = child
+
+    assert key_node is not None
+    assert value_node is not None
+    return key_node, value_node
+
+
+def _table_key(node: ts.Node) -> ts.Node:
+    """Return the key node from a table or table_array_element node."""
+    for child in node.children:
+        if child.type in ("bare_key", "quoted_key", "dotted_key"):
+            return child
+    raise ValueError(f"No key found in {node.type}")  # pragma: no cover
+
+
+def _key_segments(node: ts.Node) -> list[str]:
+    """Extract key path segments from a key node."""
+    if node.type == "bare_key":
+        assert node.text is not None
+        return [node.text.decode()]
+    elif node.type == "quoted_key":
+        assert node.text is not None
+        return [_unquote(node.text.decode())]
+    elif node.type == "dotted_key":
+        return sum((_key_segments(child) for child in node.children), [])
+    return []
+
+
+def _unquote(s: str) -> str:
+    """Strip surrounding quotes from a TOML quoted key."""
+    if s.startswith('"') and s.endswith('"'):
+        # Basic string: full TOML escape sequences via unicode_escape codec.
+        # Encode to latin-1 first to preserve non-ASCII literals, then decode escapes.
+        return s[1:-1].encode("raw_unicode_escape").decode("unicode_escape")
+    elif s.startswith("'") and s.endswith("'"):
+        # Literal string: no escaping
+        return s[1:-1]
+    return s  # pragma: no cover
+
+
+def _expand_aot_segments(segments: list[str], aot_counts: dict[str, int]) -> list[str]:
+    """If a prefix of segments matches a known AoT, splice in its current index.
+
+    e.g. segments=[fruits, details] with aot_counts={/fruits: 1}
+    → [fruits, 0, details]
+    """
+    for i in range(1, len(segments)):
+        prefix_pointer = _to_pointer(segments[:i])
+        if prefix_pointer in aot_counts:
+            idx = aot_counts[prefix_pointer] - 1
+            return segments[:i] + [str(idx)] + segments[i:]
+    return segments
+
+
+def _to_pointer(segments: list[str]) -> str:
+    return "/" + "/".join(_escape(s) for s in segments) if segments else ""
+
+
+def _loc(point: ts.Point, src: bytes) -> Location:
+    # tree-sitter gives byte-based row/column; convert to char-based for consistency
+    # with json-source-map and yaml-source-map.
+    # Append b"" so end_point row (one past final newline) is always a valid index.
+    lines = src.splitlines(True) + [b""]
+    char_column = len(lines[point.row][: point.column].decode("utf-8"))
+    position = (
+        sum(len(line.decode("utf-8")) for line in lines[: point.row]) + char_column
+    )
+    return Location(line=point.row, column=char_column, position=position)

parse_errors/toml_source_map/__main__.py

@@ -0,0 +1,7 @@
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+    from . import calculate
+
+    source = open(sys.argv[1]).read()
+    for pointer, entry in calculate(source).items():
+        print(f"{pointer!r:40s} {entry}")

parse_errors/yaml_source_map/__init__.py

@@ -0,0 +1,62 @@
+"""Calculate the source map for a YAML document."""
+
+from __future__ import annotations
+
+import yaml
+from ..source_map import Entry, Location, TSourceMap
+
+
+def calculate(source: str) -> TSourceMap:
+    """Calculate the source map for a YAML document.
+
+    Args:
+        source: The YAML document as a string.
+
+    Returns:
+        A dict mapping JSON Pointer paths to Entry objects with location info.
+    """
+    loader = yaml.SafeLoader(source)
+    node = loader.get_single_node()
+    if node is None:
+        return {}
+    result: TSourceMap = {}
+    _walk(node, "", result, loader)
+    return result
+
+
+def _location(mark: yaml.Mark) -> Location:
+    return Location(line=mark.line, column=mark.column, position=mark.index)
+
+
+def _walk(
+    node: yaml.Node, path: str, result: TSourceMap, loader: yaml.SafeLoader
+) -> None:
+    value_start = _location(node.start_mark)
+    value_end = _location(node.end_mark)
+
+    if isinstance(node, yaml.MappingNode):
+        result[path] = Entry(value_start=value_start, value_end=value_end)
+        for key_node, value_node in node.value:
+            key = loader.construct_scalar(key_node)
+            child_path = f"{path}/{_escape(str(key))}"
+            key_start = _location(key_node.start_mark)
+            key_end = _location(key_node.end_mark)
+            _walk(value_node, child_path, result, loader)
+            existing = result[child_path]
+            result[child_path] = Entry(
+                value_start=existing.value_start,
+                value_end=existing.value_end,
+                key_start=key_start,
+                key_end=key_end,
+            )
+    elif isinstance(node, yaml.SequenceNode):
+        result[path] = Entry(value_start=value_start, value_end=value_end)
+        for i, item_node in enumerate(node.value):
+            _walk(item_node, f"{path}/{i}", result, loader)
+    else:
+        result[path] = Entry(value_start=value_start, value_end=value_end)
+
+
+def _escape(key: str) -> str:
+    """Escape a key for use in a JSON Pointer (RFC 6901)."""
+    return key.replace("~", "~0").replace("/", "~1")

parse_errors/yaml_source_map/__main__.py

@@ -0,0 +1,7 @@
+if __name__ == "__main__":  # pragma: no cover
+    import sys
+    from . import calculate
+
+    source = open(sys.argv[1]).read()
+    for pointer, entry in calculate(source).items():
+        print(f"{pointer!r:40s} {entry}")

parse_errors-0.5.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: parse-errors
+Version: 0.5.0
+Summary: re-raise parse errors with filename and line number
+Home-page: https://github.com/advice-animal/parse-errors/
+Author: Tim Hatch
+Author-email: tim@timhatch.com
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: json-source-map
+Requires-Dist: pyyaml
+Requires-Dist: tree-sitter
+Requires-Dist: tree-sitter-toml
+Provides-Extra: dev
+Requires-Dist: checkdeps==0.9.0; extra == "dev"
+Requires-Dist: mypy==1.19.1; extra == "dev"
+Requires-Dist: ruff==0.15.6; extra == "dev"
+Requires-Dist: tox==4.50.0; extra == "dev"
+Requires-Dist: tox-uv==1.33.4; extra == "dev"
+Requires-Dist: types-pyyaml; extra == "dev"
+Provides-Extra: test
+Requires-Dist: coverage>=6; extra == "test"
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: msgspec; extra == "test"
+Dynamic: license-file
+
+# parse-errors
+
+
+# Version Compat
+
+This library is compatile with Python 3.10+, but should be linted under the
+newest stable version.
+
+# Versioning
+
+This library follows [meanver](https://meanver.org/) which basically means
+[semver](https://semver.org/) along with a promise to rename when the major
+version changes.
+
+# License
+
+parse-errors is copyright [Tim Hatch](https://timhatch.com/), and licensed under
+the MIT license.  See the `LICENSE` file for details.

parse_errors-0.5.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+parse_errors/__init__.py,sha256=CvFERGkB_kPTZaNm2OOhN_oWk8GoyuPG9QCbOlWk8FE,267
+parse_errors/_jsonpath.py,sha256=rZtKCyd6Pq5w32CHtTXwfA8uiX9-s4MxA1-iB0BJTyc,2047
+parse_errors/_version.py,sha256=fvHpBU3KZKRinkriKdtAt3crenOyysELF-M9y3ozg3U,704
+parse_errors/context.py,sha256=u4uw6tL_Y4KZiRXBmZqC3c6bWqRsZVLvmBLyL66tT6c,2741
+parse_errors/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+parse_errors/source_map.py,sha256=rql45F9NY2NkVwVd3AigVdvT9gokB4194b0DB9V_wjI,2244
+parse_errors/json_source_map/__init__.py,sha256=ikxzrIV5Slr6vk5lAEi_hypNxZF5osLNHEpBM8WKsfA,818
+parse_errors/json_source_map/__main__.py,sha256=TDNK26EbxF0WMS-AODOCNtI1mOaB1LR7LJleSAH4b_8,224
+parse_errors/toml_source_map/__init__.py,sha256=fsYKzIFF9htEwrnAiEAddT9RM_HEVB7ClXu-OUfssrs,6493
+parse_errors/toml_source_map/__main__.py,sha256=TDNK26EbxF0WMS-AODOCNtI1mOaB1LR7LJleSAH4b_8,224
+parse_errors/yaml_source_map/__init__.py,sha256=roVnYYF9d9ySFywGE-Gmtc_mD3U5vsv_nd6lQWd9JMc,2076
+parse_errors/yaml_source_map/__main__.py,sha256=TDNK26EbxF0WMS-AODOCNtI1mOaB1LR7LJleSAH4b_8,224
+parse_errors-0.5.0.dist-info/licenses/LICENSE,sha256=VmipWWASETlYtNqZa5usLdDsB3mgyEZfkXaTqq5N06Y,1066
+tests/__init__.py,sha256=RIdYaeATLR1IDVfU2zKSFmQIDNAwcrVfu3_sbiVgi0w,68
+tests/_types.py,sha256=QPnMThM4g-waEXDPGrbUYeYIuNpmKgX-JqgX2GKut4E,126
+tests/conftest.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_parse_context_json.py,sha256=ZH16fSvufoC8vvRM9axweqDICi5B4TuF6oHnlKXjB8w,2211
+tests/test_parse_context_toml.py,sha256=Ea5a0_uRtMG-eWoNFT6MRlehVNBEAVQESgnTc6Hheq0,2230
+tests/test_parse_context_yaml.py,sha256=2HiYdw7S-hYsxEF1yjHTBpbRP5WMpjJLlvdFyVGXvpA,1317
+tests/test_source_map.py,sha256=JAqp0TnvjwIh9IbVMOBIYIhp_jXB0O01s2QN4CcxUPM,1574
+parse_errors-0.5.0.dist-info/METADATA,sha256=HSZgwUQuJUhwru-4DdGPndfo2lipguo_jXE3dEbH4rM,1358
+parse_errors-0.5.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+parse_errors-0.5.0.dist-info/top_level.txt,sha256=JcC-dKRhzVdseLnfdPfRa9lIdyNmKn0WiRFNHgI1lCU,19
+parse_errors-0.5.0.dist-info/RECORD,,

parse_errors-0.5.0.dist-info/WHEEL

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

parse_errors-0.5.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim Hatch
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

parse_errors-0.5.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+parse_errors
+tests

tests/__init__.py

@@ -0,0 +1 @@
+# Needed so pytest considers this a package -- PEP 420 isn't enough

tests/_types.py

@@ -0,0 +1,10 @@
+import msgspec
+
+
+class Config(msgspec.Struct):
+    host: str
+    port: int
+
+
+class Nested(msgspec.Struct):
+    server: Config

tests/test_parse_context_json.py

@@ -0,0 +1,79 @@
+import pytest
+import msgspec
+
+from parse_errors import ParseContext, ParseError
+
+from ._types import Config, Nested
+
+
+JSON_GOOD = b'{"host": "localhost", "port": 8080}'
+JSON_BAD = b'{"host": "localhost", "port": "not-an-int"}'
+JSON_NESTED_BAD = b'{"server": {"host": "localhost", "port": "not-an-int"}}'
+
+JSON_SOURCE = """\
+{
+  "host": "localhost",
+  "port": "not-an-int"
+}
+"""
+
+JSON_NESTED_SOURCE = """\
+{
+  "server": {
+    "host": "localhost",
+    "port": "not-an-int"
+  }
+}
+"""
+
+
+def test_json_no_error():
+    with ParseContext("config.json", data=JSON_GOOD.decode()):
+        msgspec.json.decode(JSON_GOOD, type=Config)
+
+
+def test_json_non_jsonpath_exception_passes_through():
+    with pytest.raises(ZeroDivisionError):
+        with ParseContext("config.json", data=JSON_SOURCE):
+            raise ZeroDivisionError("oops")
+
+
+def test_json_raises_parse_error():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.json", data=JSON_SOURCE):
+            msgspec.json.decode(JSON_SOURCE.encode(), type=Config)
+
+    err = exc_info.value
+    assert err.filename == "config.json"
+    assert err.line == 3
+    assert str(err) == "config.json:3:11: Expected `int`, got `str` - at `$.port`"
+
+
+def test_json_nested_raises_parse_error():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.json", data=JSON_NESTED_SOURCE):
+            msgspec.json.decode(JSON_NESTED_SOURCE.encode(), type=Nested)
+
+    err = exc_info.value
+    assert (
+        str(err) == "config.json:4:13: Expected `int`, got `str` - at `$.server.port`"
+    )
+
+
+def test_json_bytes_data():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.json", data=JSON_SOURCE.encode()):
+            msgspec.json.decode(JSON_SOURCE.encode(), type=Config)
+
+    assert (
+        str(exc_info.value)
+        == "config.json:3:11: Expected `int`, got `str` - at `$.port`"
+    )
+
+
+def test_json_original_exception_is_cause():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.json", data=JSON_SOURCE):
+            msgspec.json.decode(JSON_SOURCE.encode(), type=Config)
+
+    assert isinstance(exc_info.value.__cause__, msgspec.ValidationError)

tests/test_parse_context_toml.py

@@ -0,0 +1,82 @@
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore[no-redef]
+
+import pytest
+import msgspec
+
+from parse_errors import ParseContext, ParseError
+
+from ._types import Config, Nested
+
+
+TOML_SOURCE = """\
+host = "localhost"
+port = "not-an-int"
+"""
+
+TOML_NESTED_SOURCE = """\
+[server]
+host = "localhost"
+port = "not-an-int"
+"""
+
+
+def test_passthrough_non_jsonspec():
+    with pytest.raises(ValueError, match="^foo$"):
+        with ParseContext("config.toml", data=TOML_SOURCE):
+            raise ValueError("foo")
+
+
+def test_toml_raises_parse_error():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.toml", data=TOML_SOURCE):
+            data = tomllib.loads(TOML_SOURCE)
+            msgspec.convert(data, Config)
+
+    err = exc_info.value
+    assert err.filename == "config.toml"
+    assert err.line == 2
+    assert str(err) == "config.toml:2:8: Expected `int`, got `str` - at `$.port`"
+
+
+def test_toml_bytes_data():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.toml", data=TOML_SOURCE.encode()):
+            data = tomllib.loads(TOML_SOURCE)
+            msgspec.convert(data, Config)
+
+    assert (
+        str(exc_info.value)
+        == "config.toml:2:8: Expected `int`, got `str` - at `$.port`"
+    )
+
+
+def test_toml_nested_raises_parse_error():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.toml", data=TOML_NESTED_SOURCE):
+            data = tomllib.loads(TOML_NESTED_SOURCE)
+            msgspec.convert(data, Nested)
+
+    err = exc_info.value
+    assert str(err) == "config.toml:3:8: Expected `int`, got `str` - at `$.server.port`"
+
+
+# --- fallback to nearest parent pointer ---
+
+FALLBACK_SOURCE = """\
+[server]
+port = 8080
+"""
+
+
+def test_toml_fallback_to_parent():
+    # Inject a fake error at a path deeper than the source map tracks.
+    # /server/tls/cert doesn't exist; should fall back to /server (line 1).
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.toml", data=FALLBACK_SOURCE):
+            raise msgspec.ValidationError(
+                "Expected `str`, got `int` - at `$.server.tls.cert`"
+            )
+    assert exc_info.value.line == 1

tests/test_parse_context_yaml.py

@@ -0,0 +1,48 @@
+import pytest
+import msgspec
+
+from parse_errors import ParseContext, ParseError
+
+from ._types import Config, Nested
+
+YAML_SOURCE = """\
+host: localhost
+port: not-an-int
+"""
+
+YAML_NESTED_SOURCE = """\
+server:
+  host: localhost
+  port: not-an-int
+"""
+
+
+def test_yaml_raises_parse_error():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.yaml", data=YAML_SOURCE):
+            msgspec.yaml.decode(YAML_SOURCE.encode(), type=Config)
+
+    err = exc_info.value
+    assert err.filename == "config.yaml"
+    assert err.line == 2
+    assert str(err) == "config.yaml:2:7: Expected `int`, got `str` - at `$.port`"
+
+
+def test_yaml_bytes_data():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.yaml", data=YAML_SOURCE.encode()):
+            msgspec.yaml.decode(YAML_SOURCE.encode(), type=Config)
+
+    assert (
+        str(exc_info.value)
+        == "config.yaml:2:7: Expected `int`, got `str` - at `$.port`"
+    )
+
+
+def test_yaml_nested_raises_parse_error():
+    with pytest.raises(ParseError) as exc_info:
+        with ParseContext("config.yaml", data=YAML_NESTED_SOURCE):
+            msgspec.yaml.decode(YAML_NESTED_SOURCE.encode(), type=Nested)
+
+    err = exc_info.value
+    assert str(err) == "config.yaml:3:9: Expected `int`, got `str` - at `$.server.port`"

tests/test_source_map.py

@@ -0,0 +1,41 @@
+from parse_errors.source_map import build_source_map, Location, Entry, closest_entry
+
+
+def test_build_toml():
+    # This isn't an exhaustive test of the toml source mapper, just as something
+    # a minimal example that lets us exercise str/bytes
+    sm1 = build_source_map("x=1\nb='foo'\n", fmt="toml")
+    assert sm1 == {
+        "": Entry(
+            value_start=Location(line=0, column=0, position=0),
+            value_end=Location(line=2, column=0, position=12),
+        ),
+        "/x": Entry(
+            value_start=Location(line=0, column=2, position=2),
+            value_end=Location(line=0, column=3, position=3),
+            key_start=Location(line=0, column=0, position=0),
+            key_end=Location(line=0, column=1, position=1),
+        ),
+        "/b": Entry(
+            value_start=Location(line=1, column=2, position=6),
+            value_end=Location(line=1, column=7, position=11),
+            key_start=Location(line=1, column=0, position=4),
+            key_end=Location(line=1, column=1, position=5),
+        ),
+    }
+    sm2 = build_source_map(b"x=1\nb='foo'\n", fmt="toml")
+    # Only ASCII, so str vs bytes should be the same
+    assert sm1 == sm2
+
+
+def test_closest_entry():
+    sm = {"": "root", "/foo": "foo", "/foo/1": "idx 1", "/foo/1/bar": "bar"}
+    assert closest_entry(sm, "/baz") == "root"
+    assert closest_entry(sm, "/foo") == "foo"
+    assert closest_entry(sm, "/foo/0") == "foo"
+    assert closest_entry(sm, "/foo/1") == "idx 1"
+
+
+def test_closest_entry_fallthrough():
+    sm = {}
+    assert closest_entry(sm, "/baz") is None