structmatch 0.1.0__py3-none-any.whl

structmatch/__init__.py

@@ -0,0 +1,40 @@
+"""structmatch — Deep structural matching, diffing, and pattern matching for Python."""
+
+from .core import eq, diff, match
+from .comparators import (
+    Comparator,
+    ANY,
+    TYPE,
+    GT,
+    LT,
+    GE,
+    LE,
+    BETWEEN,
+    REGEX,
+    NOT,
+)
+from .diff import DiffResult
+from .schema import Schema, SchemaError
+from .options import MatchOptions
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "eq",
+    "diff",
+    "match",
+    "ANY",
+    "TYPE",
+    "GT",
+    "LT",
+    "GE",
+    "LE",
+    "BETWEEN",
+    "REGEX",
+    "NOT",
+    "Comparator",
+    "DiffResult",
+    "Schema",
+    "SchemaError",
+    "MatchOptions",
+]

structmatch/comparators.py

@@ -0,0 +1,106 @@
+"""Pattern-matching comparators."""
+
+from __future__ import annotations
+import re
+from abc import ABC, abstractmethod
+
+
+class Comparator(ABC):
+    """Base class for custom comparators."""
+
+    @abstractmethod
+    def matches(self, a, b) -> bool:
+        ...
+
+    def __call__(self, a, b) -> bool:
+        return self.matches(a, b)
+
+
+class ANY(Comparator):
+    """Matches anything."""
+
+    def matches(self, a, b) -> bool:
+        return True
+
+
+class TYPE(Comparator):
+    """Matches any value of a given type."""
+
+    def __init__(self, expected_type):
+        self.expected_type = expected_type
+
+    def matches(self, a, b) -> bool:
+        return isinstance(b, self.expected_type)
+
+
+class GT(Comparator):
+    """Matches if b > value."""
+
+    def __init__(self, value):
+        self.value = value
+
+    def matches(self, a, b) -> bool:
+        return b > self.value
+
+
+class LT(Comparator):
+    """Matches if b < value."""
+
+    def __init__(self, value):
+        self.value = value
+
+    def matches(self, a, b) -> bool:
+        return b < self.value
+
+
+class GE(Comparator):
+    """Matches if b >= value."""
+
+    def __init__(self, value):
+        self.value = value
+
+    def matches(self, a, b) -> bool:
+        return b >= self.value
+
+
+class LE(Comparator):
+    """Matches if b <= value."""
+
+    def __init__(self, value):
+        self.value = value
+
+    def matches(self, a, b) -> bool:
+        return b <= self.value
+
+
+class BETWEEN(Comparator):
+    """Matches if low <= b <= high."""
+
+    def __init__(self, low, high):
+        self.low = min(low, high)
+        self.high = max(low, high)
+
+    def matches(self, a, b) -> bool:
+        return self.low <= b <= self.high
+
+
+class REGEX(Comparator):
+    """Matches if b (string) matches the regex pattern."""
+
+    def __init__(self, pattern: str):
+        self.pattern = re.compile(pattern)
+
+    def matches(self, a, b) -> bool:
+        if not isinstance(b, str):
+            return False
+        return bool(self.pattern.search(b))
+
+
+class NOT(Comparator):
+    """Negates another comparator."""
+
+    def __init__(self, comparator: Comparator):
+        self.comparator = comparator
+
+    def matches(self, a, b) -> bool:
+        return not self.comparator.matches(a, b)

structmatch/core.py

@@ -0,0 +1,177 @@
+"""Core functions: eq(), diff(), match()."""
+
+from __future__ import annotations
+from .options import MatchOptions
+from .diff import DiffResult, diff as _diff
+from .utils import (
+    _is_numeric,
+    _within_tolerance,
+    _compare_strings,
+    _filter_keys,
+    _is_dataclass_like,
+    _get_fields,
+    _is_comparator,
+    _as_multiset,
+    _hashable,
+)
+from .comparators import Comparator
+
+
+def _deep_eq(va, vb, opts: MatchOptions) -> bool:
+    """Recursive deep equality."""
+    # Check custom comparators first
+    for comp in opts.comparators:
+        if comp.matches(va, vb):
+            return True
+
+    # Handle type coercion: int/float interop
+    if opts.type_coerce and _is_numeric(va, vb) and _within_tolerance(va, vb, opts.tolerance):
+        return True
+
+    # Type mismatch (but handle dataclass/NamedTuple equality)
+    type_a = type(va)
+    type_b = type(vb)
+    if type_a != type_b:
+        if opts.type_coerce and _is_numeric(va, vb) and _within_tolerance(va, vb, opts.tolerance):
+            return True
+        return False
+
+    # None
+    if va is None:
+        return vb is None
+
+    # Booleans
+    if isinstance(va, bool):
+        return va == vb
+
+    # Strings
+    if isinstance(va, str):
+        return _compare_strings(va, vb, opts.case_sensitive)
+
+    # Numbers
+    if _is_numeric(va, vb):
+        return _within_tolerance(va, vb, opts.tolerance)
+
+    # Dicts
+    if isinstance(va, dict):
+        if len(va) != len(vb):
+            return False
+        va_f = _filter_keys(va, opts.ignore_keys)
+        vb_f = _filter_keys(vb, opts.ignore_keys)
+        if len(va_f) != len(vb_f):
+            return False
+        if set(va_f) != set(vb_f):
+            return False
+        for k in va_f:
+            if not _deep_eq(va_f[k], vb_f[k], opts):
+                return False
+        return True
+
+    # Lists / tuples
+    if isinstance(va, (list, tuple)):
+        if type(va) != type(vb):
+            return False
+        if len(va) != len(vb):
+            return False
+        if opts.ignore_order and isinstance(va, list):
+            return _as_multiset(va) == _as_multiset(vb)
+        return all(_deep_eq(a, b, opts) for a, b in zip(va, vb))
+
+    # Sets
+    if isinstance(va, set):
+        return va == vb
+
+    # Dataclasses / NamedTuples / objects with __dict__
+    if _is_dataclass_like(va):
+        fa = _get_fields(va)
+        fb = _get_fields(vb)
+        if fa is not None and fb is not None:
+            return _deep_eq(fa, fb, opts)
+
+    # Objects with __dict__ (but not dataclasses)
+    if not isinstance(va, (type, bool, int, float, str, list, tuple, set, dict)):
+        fa = _get_fields(va)
+        fb = _get_fields(vb)
+        if fa is not None and fb is not None and type(va) == type(vb):
+            return _deep_eq(fa, fb, opts)
+
+    # Fallback to ==
+    return va == vb
+
+
+def eq(a, b, *, tolerance: float = 0.0, ignore_order: bool = False,
+       ignore_keys: list[str] | None = None, case_sensitive: bool = True,
+       type_coerce: bool = False, comparators: list[Comparator] | None = None) -> bool:
+    """Deep structural equality comparison."""
+    opts = MatchOptions(
+        tolerance=tolerance,
+        ignore_order=ignore_order,
+        ignore_keys=ignore_keys,
+        case_sensitive=case_sensitive,
+        type_coerce=type_coerce,
+        comparators=comparators,
+    )
+    return _deep_eq(a, b, opts)
+
+
+def diff(a, b, **opts) -> DiffResult:
+    """Compute a deep diff between two structures."""
+    return _diff(a, b, **opts)
+
+
+def _deep_match(value, pattern, opts: MatchOptions) -> bool:
+    """Check if value matches a pattern (which may contain comparators)."""
+    # Pattern is a comparator (check FIRST, before any type checks)
+    if _is_comparator(pattern):
+        if isinstance(pattern, type):
+            pattern = pattern()
+        return pattern.matches(value, value)
+
+    # None value
+    if value is None:
+        if pattern is None or pattern is type(None):
+            return True
+        if isinstance(pattern, type):
+            return False
+        return False
+
+    # Pattern is a type
+    if isinstance(pattern, type):
+        if pattern is type(None):
+            return value is None
+        if pattern in (int, float):
+            return _is_numeric(value, value) and isinstance(value, pattern)
+        return isinstance(value, pattern)
+
+    # Both dicts
+    if isinstance(pattern, dict) and isinstance(value, dict):
+        value_f = _filter_keys(value, opts.ignore_keys)
+        for key, sub_pattern in pattern.items():
+            if key not in value_f:
+                return False
+            if not _deep_match(value_f[key], sub_pattern, opts):
+                return False
+        return True
+
+    # Both lists/tuples
+    if isinstance(pattern, (list, tuple)) and isinstance(value, (list, tuple)):
+        if len(pattern) != len(value):
+            return False
+        return all(_deep_match(v, p, opts) for v, p in zip(value, pattern))
+
+    # String pattern with case sensitivity
+    if isinstance(pattern, str) and isinstance(value, str):
+        return _compare_strings(pattern, value, opts.case_sensitive)
+
+    # Numeric with tolerance
+    if _is_numeric(pattern, value) or _is_numeric(value, pattern):
+        return _within_tolerance(pattern, value, opts.tolerance)
+
+    # Literal match
+    return pattern == value
+
+
+def match(obj, pattern, **opts) -> bool:
+    """Pattern matching: check if obj matches the given pattern."""
+    options = MatchOptions(**opts)
+    return _deep_match(obj, pattern, options)

structmatch/diff.py

@@ -0,0 +1,203 @@
+"""Deep diff engine."""
+
+from __future__ import annotations
+from .options import MatchOptions
+from .utils import (
+    _is_numeric,
+    _within_tolerance,
+    _compare_strings,
+    _filter_keys,
+    _is_dataclass_like,
+    _get_fields,
+)
+
+
+class DiffResult:
+    """Result of a deep diff between two structures."""
+
+    __slots__ = ("added", "removed", "changed", "type_changes", "path_changes")
+
+    def __init__(
+        self,
+        added: dict | None = None,
+        removed: dict | None = None,
+        changed: dict | None = None,
+        type_changes: dict | None = None,
+        path_changes: list | None = None,
+    ):
+        self.added = added if added is not None else {}
+        self.removed = removed if removed is not None else {}
+        self.changed = changed if changed is not None else {}
+        self.type_changes = type_changes if type_changes is not None else {}
+        self.path_changes = path_changes if path_changes is not None else []
+
+    def has_changes(self) -> bool:
+        return bool(self.added or self.removed or self.changed or self.type_changes or self.path_changes)
+
+    def __bool__(self) -> bool:
+        return self.has_changes()
+
+    def __repr__(self) -> str:
+        parts = []
+        if self.added:
+            parts.append(f"added={self.added}")
+        if self.removed:
+            parts.append(f"removed={self.removed}")
+        if self.changed:
+            parts.append(f"changed={self.changed}")
+        if self.type_changes:
+            parts.append(f"type_changes={self.type_changes}")
+        if self.path_changes:
+            parts.append(f"path_changes={self.path_changes}")
+        return f"DiffResult({', '.join(parts)})"
+
+    def __eq__(self, other):
+        if not isinstance(other, DiffResult):
+            return NotImplemented
+        return (
+            self.added == other.added
+            and self.removed == other.removed
+            and self.changed == other.changed
+            and self.type_changes == other.type_changes
+        )
+
+
+def _diff_dicts(a: dict, b: dict, opts: MatchOptions, path: str = "") -> DiffResult:
+    added = {}
+    removed = {}
+    changed = {}
+    type_changes = {}
+    path_changes = []
+
+    a_filtered = _filter_keys(a, opts.ignore_keys)
+    b_filtered = _filter_keys(b, opts.ignore_keys)
+
+    all_keys = set(a_filtered) | set(b_filtered)
+    for key in all_keys:
+        key_path = f"{path}.{key}" if path else key
+        if key not in a_filtered:
+            added[key] = b_filtered[key]
+        elif key not in b_filtered:
+            removed[key] = a_filtered[key]
+        else:
+            va = a_filtered[key]
+            vb = b_filtered[key]
+            child = _diff_values(va, vb, opts, key_path)
+            if child is None:
+                continue
+            if isinstance(child, dict):
+                if "sub_diff" in child:
+                    sub = child["sub_diff"]
+                    # Merge sub_diff into current
+                    added.update({f"{key}.{k}" if k in added else k: v for k, v in sub.added.items()})
+                    removed.update({f"{key}.{k}" if k in removed else k: v for k, v in sub.removed.items()})
+                    changed.update({f"{key}.{k}" if k in changed else k: v for k, v in sub.changed.items()})
+                    type_changes.update({f"{key}.{k}" if k in type_changes else k: v for k, v in sub.type_changes.items()})
+                    path_changes.extend(sub.path_changes)
+                elif "type_change" in child:
+                    type_changes[key] = child["type_change"]
+                elif "set_diff" in child:
+                    changed[key] = (va, vb)
+            elif isinstance(child, tuple):
+                changed[key] = child
+
+    return DiffResult(added=added, removed=removed, changed=changed, type_changes=type_changes, path_changes=path_changes)
+
+
+def _diff_sequences(a, b, opts: MatchOptions, path: str = "") -> DiffResult:
+    if opts.ignore_order:
+        # If same elements (multiset), no changes
+        from .utils import _as_multiset
+        if _as_multiset(a) == _as_multiset(b):
+            return DiffResult()
+
+    path_changes = []
+    max_len = max(len(a), len(b))
+    for i in range(max_len):
+        idx_path = f"{path}[{i}]"
+        if i >= len(a):
+            path_changes.append({"path": idx_path, "change": "added", "value": b[i]})
+        elif i >= len(b):
+            path_changes.append({"path": idx_path, "change": "removed", "value": a[i]})
+        else:
+            child = _diff_values(a[i], b[i], opts, idx_path)
+            if child is not None:
+                if isinstance(child, dict) and "type_change" in child:
+                    path_changes.append({"path": idx_path, "change": "type_change", "from": child["type_change"][0], "to": child["type_change"][1]})
+                elif isinstance(child, tuple):
+                    path_changes.append({"path": idx_path, "change": "changed", "from": child[0], "to": child[1]})
+                elif isinstance(child, dict) and "sub_diff" in child:
+                    path_changes.append({"path": idx_path, "change": "sub_diff", "details": child["sub_diff"]})
+                else:
+                    path_changes.append({"path": idx_path, "change": "changed", "from": a[i], "to": b[i]})
+
+    return DiffResult(path_changes=path_changes)
+
+
+def _diff_values(va, vb, opts: MatchOptions, path: str = ""):
+    """Returns None if equal, a tuple (old, new) if changed, or dict with type_change."""
+    type_a = type(va)
+    type_b = type(vb)
+
+    if type_a != type_b:
+        if opts.type_coerce and _is_numeric(va, vb) and _within_tolerance(va, vb, opts.tolerance):
+            return None
+        return {"type_change": (type_a, type_b)}
+
+    if isinstance(va, dict):
+        sub = _diff_dicts(va, vb, opts, path)
+        if sub.has_changes():
+            return {"sub_diff": sub}
+        return None
+
+    if isinstance(va, str):
+        if not _compare_strings(va, vb, opts.case_sensitive):
+            return (va, vb)
+        return None
+
+    if _is_numeric(va, vb):
+        if _within_tolerance(va, vb, opts.tolerance):
+            return None
+        return (va, vb)
+
+    if isinstance(va, (list, tuple)):
+        sub = _diff_sequences(va, vb, opts, path)
+        if sub.has_changes():
+            return {"sub_diff": sub}
+        return None
+
+    if isinstance(va, set):
+        extra_a = va - vb
+        extra_b = vb - va
+        if extra_a or extra_b:
+            return {"set_diff": {"removed": extra_a, "added": extra_b}}
+        return None
+
+    if _is_dataclass_like(va):
+        fa = _get_fields(va)
+        fb = _get_fields(vb)
+        return _diff_dicts(fa, fb, opts, path)
+
+    if va == vb:
+        return None
+    return (va, vb)
+
+
+def diff(a, b, **opts) -> DiffResult:
+    """Compute a deep diff between two structures."""
+    options = MatchOptions(**opts)
+    result = _diff_values(a, b, options)
+    if result is None:
+        return DiffResult()
+    if isinstance(result, dict):
+        if "sub_diff" in result:
+            return result["sub_diff"]
+        if "type_change" in result:
+            return DiffResult(type_changes={"root": result["type_change"]})
+        if "set_diff" in result:
+            return DiffResult(
+                added={"root_set_added": result["set_diff"]["added"]},
+                removed={"root_set_removed": result["set_diff"]["removed"]},
+            )
+        return DiffResult(changed={"root": (a, b)})
+    return DiffResult(changed={"root": result})

structmatch/options.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+
+class MatchOptions:
+    """Options controlling comparison behavior."""
+
+    __slots__ = (
+        "tolerance",
+        "ignore_order",
+        "ignore_keys",
+        "case_sensitive",
+        "type_coerce",
+        "comparators",
+    )
+
+    def __init__(
+        self,
+        tolerance: float = 0.0,
+        ignore_order: bool = False,
+        ignore_keys: set[str] | None = None,
+        case_sensitive: bool = True,
+        type_coerce: bool = False,
+        comparators: list | None = None,
+    ):
+        self.tolerance = tolerance
+        self.ignore_order = ignore_order
+        self.ignore_keys = frozenset(ignore_keys) if ignore_keys else frozenset()
+        self.case_sensitive = case_sensitive
+        self.type_coerce = type_coerce
+        self.comparators = comparators or []
+
+    def update(self, **kwargs) -> MatchOptions:
+        """Return a new MatchOptions with updated fields."""
+        d = {
+            "tolerance": self.tolerance,
+            "ignore_order": self.ignore_order,
+            "ignore_keys": set(self.ignore_keys) if self.ignore_keys else None,
+            "case_sensitive": self.case_sensitive,
+            "type_coerce": self.type_coerce,
+            "comparators": list(self.comparators),
+        }
+        d.update(kwargs)
+        return MatchOptions(**d)

structmatch/schema.py

@@ -0,0 +1,110 @@
+"""Schema validation."""
+
+from __future__ import annotations
+from .utils import _is_comparator
+
+
+class SchemaError(Exception):
+    """Raised when schema validation fails."""
+
+    def __init__(self, errors: list[dict]):
+        self.errors = errors
+        parts = []
+        for e in errors:
+            path = e.get("path", "root")
+            msg = e.get("message", "validation error")
+            parts.append(f"  {path}: {msg}")
+        super().__init__("Schema validation failed:\n" + "\n".join(parts))
+
+
+def _validate_type(value, expected, path: str, errors: list):
+    """Validate a value against an expected type/schema."""
+    if expected is None or expected is type(None):
+        if value is not None:
+            errors.append({"path": path, "message": f"expected None, got {type(value).__name__}: {value!r}"})
+        return
+
+    if isinstance(expected, type):
+        if isinstance(value, bool) and expected in (int, float):
+            errors.append({"path": path, "message": f"expected {expected.__name__}, got bool"})
+            return
+        if not isinstance(value, expected):
+            # Allow int/float coercion
+            if expected in (int, float) and isinstance(value, (int, float)) and not isinstance(value, bool):
+                return
+            if expected is float and isinstance(value, int) and not isinstance(value, bool):
+                return
+            errors.append({"path": path, "message": f"expected {expected.__name__}, got {type(value).__name__}: {value!r}"})
+        return
+
+    if isinstance(expected, dict):
+        if not isinstance(value, dict):
+            errors.append({"path": path, "message": f"expected dict, got {type(value).__name__}"})
+            return
+        for key, sub_schema in expected.items():
+            if key not in value:
+                errors.append({"path": f"{path}.{key}", "message": "missing required key"})
+            else:
+                _validate_type(value[key], sub_schema, f"{path}.{key}", errors)
+        return
+
+    if isinstance(expected, list):
+        schema = expected[0] if expected else None
+        if not isinstance(value, (list, tuple)):
+            errors.append({"path": path, "message": f"expected list, got {type(value).__name__}"})
+            return
+        for i, item in enumerate(value):
+            if schema is not None:
+                _validate_type(item, schema, f"{path}[{i}]", errors)
+        return
+
+    if isinstance(expected, tuple):
+        if not isinstance(value, (list, tuple)):
+            errors.append({"path": path, "message": f"expected tuple/list, got {type(value).__name__}"})
+            return
+        if len(value) != len(expected):
+            errors.append({"path": path, "message": f"expected {len(expected)} elements, got {len(value)}"})
+            return
+        for i, (item, sub_schema) in enumerate(zip(value, expected)):
+            _validate_type(item, sub_schema, f"{path}[{i}]", errors)
+        return
+
+    if isinstance(expected, set):
+        if not isinstance(expected, frozenset):
+            expected = frozenset(expected)
+        if not isinstance(value, (list, tuple, set, frozenset)):
+            errors.append({"path": path, "message": f"expected set/list, got {type(value).__name__}"})
+            return
+        if set(value) != set(expected):
+            errors.append({"path": path, "message": f"expected one of {expected}, got {set(value)}"})
+        return
+
+    if _is_comparator(expected):
+        if not expected.matches(None, value):
+            errors.append({"path": path, "message": f"failed comparator {type(expected).__name__}"})
+        return
+
+    # Literal value
+    if value != expected:
+        errors.append({"path": path, "message": f"expected {expected!r}, got {value!r}"})
+
+
+class Schema:
+    """Schema validator for Python structures."""
+
+    def __init__(self, definition):
+        self.definition = definition
+
+    def validate(self, data) -> bool:
+        errors = []
+        _validate_type(data, self.definition, "root", errors)
+        if errors:
+            raise SchemaError(errors)
+        return True
+
+    def is_valid(self, data) -> bool:
+        try:
+            self.validate(data)
+            return True
+        except SchemaError:
+            return False

structmatch/utils.py

@@ -0,0 +1,67 @@
+"""Helper utilities."""
+
+from __future__ import annotations
+from collections import Counter
+from dataclasses import is_dataclass, fields
+from typing import Any
+
+
+def _is_dataclass_like(obj: Any) -> bool:
+    return is_dataclass(obj) and not isinstance(obj, type)
+
+
+def _get_fields(obj: Any) -> dict:
+    """Get comparable fields from an object."""
+    if _is_dataclass_like(obj):
+        return {f.name: getattr(obj, f.name) for f in fields(obj)}
+    try:
+        return dict(vars(obj))
+    except TypeError:
+        return None
+
+
+def _as_multiset(lst):
+    """Convert a list to a Counter for order-independent comparison."""
+    return Counter(_hashable(x) for x in lst)
+
+
+def _hashable(x):
+    """Make a value hashable for multiset comparison."""
+    if isinstance(x, dict):
+        return tuple(sorted((k, _hashable(v)) for k, v in x.items()))
+    if isinstance(x, (list, tuple)):
+        return tuple(_hashable(i) for i in x)
+    if isinstance(x, set):
+        return frozenset(_hashable(i) for i in x)
+    return x
+
+
+def _is_numeric(a, b) -> bool:
+    return isinstance(a, (int, float)) and isinstance(b, (int, float)) and not isinstance(a, bool) and not isinstance(b, bool)
+
+
+def _within_tolerance(a, b, tolerance: float) -> bool:
+    if not _is_numeric(a, b):
+        return a == b
+    if tolerance <= 0.0:
+        return a == b
+    if tolerance > 1:
+        return abs(a - b) <= tolerance
+    return abs(a - b) <= tolerance * max(abs(a), abs(b), 1)
+
+
+def _compare_strings(a: str, b: str, case_sensitive: bool) -> bool:
+    if case_sensitive:
+        return a == b
+    return a.lower() == b.lower()
+
+
+def _is_comparator(val) -> bool:
+    from .comparators import Comparator
+    return isinstance(val, Comparator) or (isinstance(val, type) and issubclass(val, Comparator) and val is not Comparator)
+
+
+def _filter_keys(d: dict, ignore_keys) -> dict:
+    if not ignore_keys:
+        return d
+    return {k: v for k, v in d.items() if k not in ignore_keys}

structmatch-0.1.0.dist-info/METADATA

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: structmatch
+Version: 0.1.0
+Summary: Deep structural matching, diffing, and pattern matching for Python
+Author: Teja
+License: MIT
+Requires-Python: >=3.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"

structmatch-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+structmatch/__init__.py,sha256=-sm6hkVh9ygag6cRmiSycqFDED960gqEkS_6n08L9DQ,621
+structmatch/comparators.py,sha256=yPtXdm494iL0wqOfFcPVDnbbl_yiItUAIwplcS0tRuY,2218
+structmatch/core.py,sha256=LuzZv2BeAfYEYlQhuT5sw_grnlroDL2BvqHV0axLtZA,5501
+structmatch/diff.py,sha256=i8xER0qLdaMp1cQpqTwpOC4eTvRszp5uk-Gan_cD87I,7469
+structmatch/options.py,sha256=tINGmGDuF3Q-SKf7azcJRildu88kPvPyJagR0h3VrJI,1333
+structmatch/schema.py,sha256=cuvexzNQKaDneu-NO0Ct-ObTZIYVOjP3VOMMH_d5zJ8,4254
+structmatch/utils.py,sha256=W1azfIBHVlT4HhY8EP0uj3OtZ0C6Ko38Jqs7nUNM-Lg,1960
+structmatch-0.1.0.dist-info/METADATA,sha256=v2VDfenfY0RtAf0WklAjB55Z1mcnepsq_s4uryn9gKk,328
+structmatch-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+structmatch-0.1.0.dist-info/top_level.txt,sha256=-m-cg6sthw8Eo6WwUYlf_eH-5wWgGX3JyVlrndT9WZw,12
+structmatch-0.1.0.dist-info/RECORD,,

structmatch-0.1.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
+

structmatch-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+structmatch