deepdiff-rust 0.1.0__cp39-abi3-win_amd64.whl

deepdiff_rust/_options.py

@@ -0,0 +1,93 @@
+"""deepdiff 9.1.0's value-normalization options, as the native diff takes them."""
+
+import datetime
+import decimal
+import fractions
+import uuid
+
+# deepdiff's `numbers` and `strings`, plus numpy scalars when numpy is importable.
+_NUMBERS = [
+    int, float, complex, decimal.Decimal, fractions.Fraction,
+    datetime.datetime, datetime.date, datetime.timedelta, datetime.time,
+]
+try:
+    import numpy as _np
+
+    _NUMBERS.extend(
+        t for t in (
+            getattr(_np, "integer", None),
+            getattr(_np, "floating", None),
+            getattr(_np, "complexfloating", None),
+        )
+        if t is not None
+    )
+except ImportError:
+    pass
+_NUMBERS = tuple(_NUMBERS)
+_STRINGS = (str, bytes, memoryview)
+_UUID_STR = (uuid.UUID, str)
+_ZEROED = ("hour", "minute", "second", "microsecond")
+_TRUNCATE_FROM = {"day": 0, "hour": 1, "minute": 2, "second": 3}
+
+
+def _type_groups(groups, ignore_string_type_changes, ignore_numeric_type_changes, ignore_uuid_types):
+    """`get_ignore_types_in_groups`: each group a tuple of types."""
+    if groups and isinstance(groups[0], type):
+        groups = [groups]
+    result = [
+        tuple(type(item) if item is None or not isinstance(item, type) else item for item in group)
+        for group in groups or []
+    ]
+    if ignore_string_type_changes and _STRINGS not in result:
+        result.append(_STRINGS)
+    if ignore_numeric_type_changes and _NUMBERS not in result:
+        result.append(_NUMBERS)
+    if ignore_uuid_types and _UUID_STR not in result:
+        result.append(_UUID_STR)
+    return result
+
+
+def native_options(
+    builtin_types, *, significant_digits, number_format_notation, math_epsilon, use_log_scale,
+    log_scale_similarity_threshold, ignore_nan_inequality, ignore_string_case,
+    ignore_numeric_type_changes, ignore_string_type_changes, ignore_type_in_groups,
+    ignore_type_subclasses, truncate_datetime, ignore_uuid_types=False,
+):
+    """The native `DeepDiff` keyword arguments for these options."""
+    if significant_digits is not None and significant_digits < 0:
+        raise ValueError("significant_digits must be None or a non-negative integer")
+    if significant_digits is None and ignore_numeric_type_changes:
+        significant_digits = 12
+    if significant_digits is not None and number_format_notation not in ("f", "e"):
+        raise ValueError(
+            f"number_format_notation got invalid value of {number_format_notation}. "
+            "The valid values are 'f' and 'e'"
+        )
+    if truncate_datetime not in {None, *_TRUNCATE_FROM}:
+        raise ValueError("truncate_datetime must be second, minute, hour or day")
+    options = {
+        "truncate_datetime": truncate_datetime
+        and dict.fromkeys(_ZEROED[_TRUNCATE_FROM[truncate_datetime]:], 0),
+        "significant_digits": significant_digits,
+        "exponent_notation": number_format_notation == "e",
+        "math_epsilon": math_epsilon,
+        "log_scale_threshold": log_scale_similarity_threshold if use_log_scale else None,
+        "ignore_nan_inequality": ignore_nan_inequality,
+        "ignore_string_case": ignore_string_case,
+        "ignore_numeric_type_changes": ignore_numeric_type_changes,
+    }
+    groups = _type_groups(
+        ignore_type_in_groups, ignore_string_type_changes, ignore_numeric_type_changes,
+        ignore_uuid_types,
+    )
+    if groups:
+        # ponytail: a u64 mask, so at most 64 groups.
+        def group_mask(cls):
+            return sum(
+                1 << i for i, group in enumerate(groups)
+                if (cls in group if ignore_type_subclasses else issubclass(cls, group))
+            )
+
+        options["type_groups"] = {name: group_mask(cls) for name, cls in builtin_types.items()}
+        options["group_mask"] = group_mask
+    return options

deepdiff_rust/_paths.py

@@ -0,0 +1,152 @@
+"""Path filters: deepdiff 9.1.0's `_skip_this` over rendered path strings."""
+
+import ast
+import re
+from functools import cache
+
+_WILDCARD_RE = re.compile(r"\[\*\*?\]|\.\*\*?(?=[.\[]|$)")
+_ONE, _ANY = object(), object()
+
+
+def _element(text, literal):
+    if text in ("*", "**"):
+        return _ONE if text == "*" else _ANY
+    if not literal:
+        return text
+    try:
+        return ast.literal_eval(text)
+    except (ValueError, SyntaxError):
+        return text
+
+
+@cache
+def _elements(path):
+    """`root['a'][0].b` -> ('a', 0, 'b'); `*`/`**` become wildcard markers."""
+    out, i, n = [], 4, len(path)
+    while i < n:
+        j = i + 1
+        if path[i] == ".":
+            while j < n and path[j] not in ".[":
+                j += 1
+            out.append(_element(path[i + 1 : j], literal=False))
+            i = j
+            continue
+        quote = None
+        while j < n and (quote or path[j] != "]"):
+            if quote and path[j] == "\\":
+                j += 1
+            elif path[j] == quote:
+                quote = None
+            elif not quote and path[j] in "'\"":
+                quote = path[j]
+            j += 1
+        out.append(_element(path[i + 1 : j], literal=True))
+        i = j + 1
+    return tuple(out)
+
+
+def _matches(pattern, target, prefix):
+    """`pattern` matches `target`, or (`prefix`) some prefix of it."""
+
+    @cache
+    def go(p, t):
+        if p == len(pattern):
+            return prefix or t == len(target)
+        if pattern[p] is _ANY:
+            return any(go(p + 1, k) for k in range(t, len(target) + 1))
+        if t == len(target):
+            return False
+        return (pattern[p] is _ONE or pattern[p] == target[t]) and go(p + 1, t + 1)
+
+    return go(0, 0)
+
+
+def _could_reach(pattern, target):
+    """`target` is an ancestor of some path `pattern` matches."""
+
+    @cache
+    def go(p, t):
+        if t == len(target):
+            return p < len(pattern)
+        if p == len(pattern):
+            return False
+        if pattern[p] is _ANY:
+            return go(p + 1, t) or go(p, t + 1)
+        return (pattern[p] is _ONE or pattern[p] == target[t]) and go(p + 1, t + 1)
+
+    return go(0, 0)
+
+
+def _root_paths(paths):
+    """deepdiff's `add_root_to_paths`: a bare key also means `root[key]`."""
+    result = set()
+    for path in paths:
+        if path.startswith("root"):
+            result.add(path)
+        elif path.isdigit():
+            result |= {f"root['{path}']", f"root[{path}]"}
+        elif path[0].isdigit():
+            result.add(f"root['{path}']")
+        else:
+            result |= {f"root.{path}", f"root['{path}']"}
+    return result
+
+
+def _split(paths):
+    """(exact paths, glob patterns as element tuples), as deepdiff separates them."""
+    if not paths:
+        return set(), []
+    paths = {paths} if isinstance(paths, str) else set(paths)
+    globs = []
+    for path in paths:
+        if _WILDCARD_RE.search(path):
+            if not path.startswith("root"):
+                raise ValueError(f"Wildcard paths must start with 'root'. Got: {path}")
+            globs.append(_elements(path))
+    exact = {path for path in paths if not _WILDCARD_RE.search(path)}
+    return _root_paths(exact), globs
+
+
+def _regexes(items):
+    if not items:
+        return []
+    items = [items] if isinstance(items, (str, re.Pattern)) else list(items)
+    return [item if isinstance(item, re.Pattern) else re.compile(item) for item in items]
+
+
+def skip_filter(exclude_paths, include_paths, exclude_regex_paths, exclude_types):
+    """`skip(prefixes, typed)` for a finding: `prefixes` are its path's rendered
+    prefixes from `root`, `typed[k]` whether `prefixes[k]` holds an
+    `exclude_types` instance. `None` when nothing filters."""
+    ex_exact, ex_globs = _split(exclude_paths)
+    in_exact, in_globs = _split(include_paths)
+    regexes = _regexes(exclude_regex_paths)
+    if not (ex_exact or ex_globs or in_exact or in_globs or regexes or exclude_types):
+        return None
+
+    def included(path):
+        return path in in_exact or any(p in path or path in p for p in in_exact)
+
+    @cache
+    def skip_level(path, typed):
+        if path in ex_exact or any(_matches(g, _elements(path), False) for g in ex_globs):
+            return True
+        if (in_exact or in_globs) and path != "root":
+            if included(path):
+                return False
+            target = _elements(path)
+            return not any(_matches(g, target, False) or _could_reach(g, target) for g in in_globs)
+        if any(regex.search(path) for regex in regexes):
+            return True
+        return typed
+
+    def skip_report(path):
+        # `_skip_report_for_include_glob`: a glob ancestor is walked, not reported.
+        if not in_globs or path in in_exact or any(p in path for p in in_exact):
+            return False
+        return not any(_matches(g, _elements(path), True) for g in in_globs)
+
+    def skip(prefixes, typed):
+        return any(map(skip_level, prefixes, typed)) or skip_report(prefixes[-1])
+
+    return skip

deepdiff_rust/_view.py

@@ -0,0 +1,131 @@
+"""pretty() formatting and a minimal view='tree' DiffLevel."""
+
+from __future__ import annotations
+
+
+class DiffLevel:
+    """Minimal DeepDiff tree node: path, t1/t2, report_type."""
+
+    __slots__ = ("t1", "t2", "report_type", "_path", "additional")
+
+    def __init__(self, path, t1, t2, report_type):
+        self._path = path
+        self.t1 = t1
+        self.t2 = t2
+        self.report_type = report_type
+        self.additional = {}
+
+    def path(self, root="root", **_kwargs):
+        if root == "root":
+            return self._path
+        if self._path == "root":
+            return root
+        return root + self._path[4:]
+
+    def __repr__(self):
+        return f"<{self._path} t1:{self.t1!r}, t2:{self.t2!r}>"
+
+
+_PRETTY = {
+    "type_changes": (
+        "Type of {diff_path} changed from {type_t1} to {type_t2} "
+        "and value changed from {val_t1} to {val_t2}."
+    ),
+    "values_changed": "Value of {diff_path} changed from {val_t1} to {val_t2}.",
+    "dictionary_item_added": "Item {diff_path} added to dictionary.",
+    "dictionary_item_removed": "Item {diff_path} removed from dictionary.",
+    "iterable_item_added": "Item {diff_path} added to iterable.",
+    "iterable_item_removed": "Item {diff_path} removed from iterable.",
+    "attribute_added": "Attribute {diff_path} added.",
+    "attribute_removed": "Attribute {diff_path} removed.",
+    "set_item_added": "Item root[{val_t2}] added to set.",
+    "set_item_removed": "Item root[{val_t1}] removed from set.",
+    "repetition_change": "Repetition change for item {diff_path}.",
+    "iterable_item_moved": "Item {diff_path} moved to {val_t2}.",
+}
+
+_PRETTY_V2 = {
+    **_PRETTY,
+    "dictionary_item_added": "Item {diff_path} ({val_t2}) added to dictionary.",
+    "dictionary_item_removed": "Item {diff_path} ({val_t1}) removed from dictionary.",
+    "iterable_item_added": "Item {diff_path} ({val_t2}) added to iterable.",
+    "iterable_item_removed": "Item {diff_path} ({val_t1}) removed from iterable.",
+    "attribute_added": "Attribute {diff_path} ({val_t2}) added.",
+    "attribute_removed": "Attribute {diff_path} ({val_t1}) removed.",
+}
+
+
+def _fmt_val(value):
+    if isinstance(value, str):
+        return f'"{value}"'
+    return str(value)
+
+
+def _iter_findings(findings):
+    if isinstance(findings, dict):
+        yield from findings.items()
+    else:
+        for path in findings:
+            yield path, None
+
+
+def _level_from_finding(report_type, path, payload):
+    if report_type == "values_changed" and isinstance(payload, dict):
+        return DiffLevel(path, payload.get("old_value"), payload.get("new_value"), report_type)
+    if report_type == "type_changes" and isinstance(payload, dict):
+        return DiffLevel(path, payload.get("old_value"), payload.get("new_value"), report_type)
+    if report_type == "iterable_item_moved" and isinstance(payload, dict):
+        return DiffLevel(path, payload.get("value"), payload.get("new_path"), report_type)
+    if report_type == "repetition_change" and isinstance(payload, dict):
+        return DiffLevel(path, payload.get("value"), payload.get("value"), report_type)
+    if report_type.endswith("_added"):
+        return DiffLevel(path, None, payload, report_type)
+    if report_type.endswith("_removed"):
+        return DiffLevel(path, payload, None, report_type)
+    return DiffLevel(path, payload, payload, report_type)
+
+
+def build_tree(report: dict, verbose_level: int = 1) -> dict:
+    """text-report dict → {category: [DiffLevel, ...]} like DeepDiff.tree."""
+    tree = {}
+    for report_type, findings in report.items():
+        if report_type == "deep_distance":
+            continue
+        levels = [
+            _level_from_finding(report_type, path, payload)
+            for path, payload in _iter_findings(findings)
+        ]
+        if levels:
+            tree[report_type] = levels
+    return tree
+
+
+def tree_as_result(tree: dict) -> dict:
+    """DeepDiff view='tree' shape: category → list of DiffLevel."""
+    return {key: list(levels) for key, levels in tree.items()}
+
+
+def pretty_from_tree(tree: dict, verbose_level: int = 1, prefix=None) -> str:
+    forms = _PRETTY_V2 if verbose_level == 2 else _PRETTY
+    if prefix is None:
+        prefix = ""
+    lines = []
+    for report_type in sorted(tree):
+        for level in tree[report_type]:
+            template = forms.get(level.report_type, "")
+            if not template:
+                continue
+            type_t1 = type(level.t1).__name__
+            type_t2 = type(level.t2).__name__
+            line = template.format(
+                diff_path=level.path(),
+                type_t1=type_t1,
+                type_t2=type_t2,
+                val_t1=_fmt_val(level.t1),
+                val_t2=_fmt_val(level.t2),
+            )
+            if callable(prefix):
+                lines.append(f"{prefix(diff=level)}{line}")
+            else:
+                lines.append(f"{prefix}{line}")
+    return "\n".join(lines)

deepdiff_rust-0.1.0.dist-info/METADATA

@@ -0,0 +1,191 @@
+Metadata-Version: 2.4
+Name: deepdiff-rust
+Version: 0.1.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: pytest>=8 ; extra == 'test'
+Requires-Dist: deepdiff==9.1.0 ; extra == 'test'
+Provides-Extra: test
+License-File: LICENSE
+License-File: LICENSE-ONIX
+Summary: Rust-backed DeepDiff-compatible comparison for Python
+Keywords: deepdiff,diff,rust,performance,comparison
+Author-email: viktormokhov <110980778+viktormokhov@users.noreply.github.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/viktormokhov/deepdiff-rust
+Project-URL: Issues, https://github.com/viktormokhov/deepdiff-rust/issues
+Project-URL: Repository, https://github.com/viktormokhov/deepdiff-rust
+
+# deepdiff-rust
+
+Rust-backed [DeepDiff](https://github.com/seperman/deepdiff) for Python.
+Forked from [Onix](https://github.com/ksco92/onix) (`deepdiff-rs`) and extended
+toward full `deepdiff==9.1.0` parity for the comparison API.
+
+- **Distribution:** `deepdiff-rust`
+- **Import:** `deepdiff_rust` (does not shadow PyPI `deepdiff` or `deepdiff-rs`)
+- **Runtime deps:** none (CPython 3.10+)
+- **Branch:** `fork-onix` is the active development line
+
+```python
+from deepdiff_rust import DeepDiff
+
+print(DeepDiff({"a": 1, "b": [1, 2]}, {"a": 2, "b": [1, 3]}))
+# {'values_changed': {"root['a']": {...}, "root['b'][1]": {...}}}
+```
+
+## Install
+
+From a local wheel (Windows / manylinux x86_64 abi3):
+
+```bash
+pip install --force-reinstall --no-deps path/to/deepdiff_rust-0.1.0-*.whl
+```
+
+From source (Rust toolchain + Maturin):
+
+```bash
+git clone https://github.com/viktormokhov/deepdiff-rust.git
+cd deepdiff-rust
+git checkout fork-onix
+python -m venv .venv
+source .venv/bin/activate   # Windows: .venv\Scripts\activate
+pip install maturin
+maturin develop --release
+```
+
+## Status
+
+**Core `DeepDiff(...)` comparison is largely done** and differentially tested
+against live `deepdiff==9.1.0`. Not a complete drop-in for the whole DeepDiff
+*package* yet (no DeepHash / DeepSearch / Delta).
+
+### Supported (tested vs DeepDiff 9.1.0)
+
+| Area | Options / behavior |
+|---|---|
+| Result API | `dict`-like result, `to_dict` / `to_json`, `affected_paths`, `affected_root_keys`, `t1` / `t2`, `verbose_level` 0/1/2 |
+| Order | `ignore_order`, `zip_ordered_iterables`, pairing cutoffs, `threshold_to_diff_deeper`, `report_repetition`, `group_by` |
+| Limits | `max_diffs`, `max_passes`, `max_depth` (extension beyond DeepDiff) |
+| Numbers / strings | `significant_digits`, `math_epsilon`, `use_log_scale`, `ignore_nan_inequality`, `ignore_string_case`, type-ignore groups |
+| Filters | `exclude_paths` / `include_paths` (incl. `*`/`**`), `exclude_regex_paths`, `exclude_types`, `ignore_private_variables` |
+| Callbacks | `exclude_obj_callback`(+`_strict`), `include_obj_callback`(+`_strict`), `iterable_compare_func`, `custom_operators` |
+| Types | `None`, bool, int, float, str, bytes, list/tuple/set/frozenset, dict, Decimal, UUID, complex, datetime/date/time/timedelta, Enum / IntEnum (`use_enum_value`), numpy int/float scalars + `ndarray`, many custom objects by attributes |
+| Other | `get_deep_distance`, `view='tree'`, `pretty()`, `diff_json` (JSON fast path in Rust) |
+
+Details and known divergences: [docs/compatibility.md](docs/compatibility.md).
+
+### Not yet
+
+- `DeepHash` / `hasher`, `DeepSearch`, `Delta` / patch
+- numpy `bool_` / `datetime64` / complex scalars
+- Onix extras we did not port: `diff_tables` (Arrow), `onix` CLI
+- Some exotic report shapes for failed/opaque objects may still differ from DeepDiff
+
+## vs `deepdiff-rs` (Onix) and `deepdiff`
+
+| | `deepdiff` | `deepdiff-rs` (Onix) | **this package** |
+|---|---|---|---|
+| Engine | pure Python | Rust | Rust (Onix fork) |
+| Import | `deepdiff` | `deepdiff_rs` | `deepdiff_rust` |
+| Pip runtime deps | several | none (+ optional pyarrow) | none |
+| Full DeepDiff option set | yes | core only | most comparison options |
+| DeepHash / Delta / Search | yes | no | no (planned) |
+| Arrow `diff_tables` | no | yes | no |
+
+Keep stock `deepdiff` installed only if you want differential tests or a reference oracle.
+
+## Architecture
+
+- `crates/deepdiff-core` — comparison engine, paths, reports
+- `crates/deepdiff-python` — PyO3 extension (`deepdiff_rust._native`)
+- `python/deepdiff_rust` — public Python API
+- `tests` — API + differential tests against `deepdiff==9.1.0`
+- `docs/` — compatibility matrix and design notes
+
+Live Python objects are converted into a native value model, diffed in Rust,
+then rendered as DeepDiff-compatible reports. JSON strings can skip the
+Python object round-trip via `diff_json`.
+
+## Development
+
+```bash
+pip install -e ".[test]"   # pytest + deepdiff==9.1.0
+cargo test --workspace
+cargo fmt --all --check
+cargo clippy --workspace --all-targets --all-features -- -D warnings
+maturin develop --release
+pytest -q
+```
+
+## Publishing to PyPI
+
+Workflow [`.github/workflows/publish.yml`](.github/workflows/publish.yml) builds
+abi3 wheels (Linux x86_64/aarch64, Windows x64, macOS Intel/ARM) plus an sdist.
+
+### Secrets (GitHub → Settings → Secrets and variables → Actions)
+
+| Secret | Purpose |
+|---|---|
+| `TEST_PYPI_API_TOKEN` | Upload to https://test.pypi.org |
+| `PYPI_API_TOKEN` | Upload to https://pypi.org |
+
+Create tokens on TestPyPI / PyPI (Account → API tokens). Store the raw token
+value; maturin authenticates as user `__token__`.
+
+### Dry run on TestPyPI
+
+1. Register on https://test.pypi.org and create a token → secret
+   `TEST_PYPI_API_TOKEN`.
+2. **Actions → Publish → Run workflow** → target `testpypi`.
+3. Install and smoke-test:
+
+```bash
+pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ deepdiff-rust==0.1.0
+python -c "from deepdiff_rust import DeepDiff; print(DeepDiff({'a':1},{'a':2}))"
+```
+
+(`--extra-index-url` is only needed if a future release gains PyPI dependencies.)
+
+### Production release
+
+1. Version in `pyproject.toml` and `[workspace.package]` must match the tag
+   without the leading `v` (e.g. `0.1.0` ↔ `v0.1.0`).
+2. Push the tag (or run the workflow with target `pypi`):
+
+```bash
+git tag v0.1.0
+git push origin v0.1.0
+```
+
+3. After the job finishes: `pip install deepdiff-rust`.
+
+A version string can be uploaded to PyPI only once — fix mistakes with a new
+version number.
+
+## Third-party code
+
+Comparison engine and Python conversion modules are forked from Onix,
+Copyright (c) 2026 Rodrigo Carvajal, MIT. See
+[THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md) and [LICENSE-ONIX](LICENSE-ONIX).
+
+## License
+
+MIT. Upstream licenses in third-party notices still apply.
+

deepdiff_rust-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+deepdiff_rust/__init__.py,sha256=q3PDPu7ZJBqo9_T-birDkHjvY-p91ULOd3punAxKvi8,260
+deepdiff_rust/__init__.pyi,sha256=NaPyHP4kLZINdwsa-gAKVYeLAFGP1wEqdZ1hQmdRHDo,3326
+deepdiff_rust/_callbacks.py,sha256=61TpMIQdYQmMoJRw49pHCHIbAbdWtp_fc6e_wNfyTKA,3008
+deepdiff_rust/_diff.py,sha256=p872e2pnYoFyA8kL6RnRTRnBGxQ14tuAGNaP4uTNUZs,14170
+deepdiff_rust/_dual.py,sha256=56m4Vfx0BE1MCkOCbg5fGTBpjNmR7x_tElVbg7-0QRY,4697
+deepdiff_rust/_group_by.py,sha256=tjSQah_qNcCtkUzlnUTe49WVbeCpCparw55g1mWIGp8,1993
+deepdiff_rust/_native.pyd,sha256=E_gn4hQiNANnYK4CgW2dHylKXtUWwXZDMzMOyq9EJfU,1552384
+deepdiff_rust/_options.py,sha256=VReNz-JZjHfBh8kxHYYAeXE-V2Ixfz1rQgb3TwAFaqY,3868
+deepdiff_rust/_paths.py,sha256=aXa90axI6yVv0mhI3dbc32LGP6gWvOBD-l_7XJsqLtA,5162
+deepdiff_rust/_view.py,sha256=icf6kZoThV9Tya55JUulxqce6ThRoJ-3CzPg045dg1s,5070
+deepdiff_rust/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+deepdiff_rust-0.1.0.dist-info/METADATA,sha256=tEe1Q2FOc6xXP-8E9YVTfhIrzOyTNScqeatzG9hWOgU,7558
+deepdiff_rust-0.1.0.dist-info/WHEEL,sha256=xw8F9xBWUOgm5ym2S9tihj_bLJOb723bjhA0kdANo2I,95
+deepdiff_rust-0.1.0.dist-info/licenses/LICENSE,sha256=bBESMrPM6AtsqS38rSgpBMXoBLhBRMDcE_bHw_Ivie0,1091
+deepdiff_rust-0.1.0.dist-info/licenses/LICENSE-ONIX,sha256=-9RD2QdrTE077HE1bP2OPj29mVd9n63ywdnqxzsN5yg,1094
+deepdiff_rust-0.1.0.dist-info/sboms/deepdiff-python.cyclonedx.json,sha256=nI7vnQda7asAVzuRkwxQfgCmbQm8AE87Jdcacr2NFWU,32576
+deepdiff_rust-0.1.0.dist-info/RECORD,,

deepdiff_rust-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.16.0)
+Root-Is-Purelib: false
+Tag: cp39-abi3-win_amd64

deepdiff_rust-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Viktor Mokhov
+
+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.

deepdiff_rust-0.1.0.dist-info/licenses/LICENSE-ONIX

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rodrigo Carvajal
+
+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.