deepdiff-rust 0.1.0__tar.gz → 0.1.1__tar.gz

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/Cargo.lock

@@ -103,7 +103,7 @@ dependencies = [
 
 [[package]]
 name = "deepdiff-core"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "num-bigint",
  "num-traits",
@@ -116,7 +116,7 @@ dependencies = [
 
 [[package]]
 name = "deepdiff-python"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "deepdiff-core",
  "num-bigint",

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "3"
 members = ["crates/deepdiff-core", "crates/deepdiff-python"]
 
 [workspace.package]
-version = "0.1.0"
+version = "0.1.1"
 edition = "2024"
 rust-version = "1.88"
 license = "MIT"

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepdiff-rust
-Version: 0.1.0
+Version: 0.1.1
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -55,7 +55,7 @@ print(DeepDiff({"a": 1, "b": [1, 2]}, {"a": 2, "b": [1, 3]}))
 From a local wheel (Windows / manylinux x86_64 abi3):
 
 ```bash
-pip install --force-reinstall --no-deps path/to/deepdiff_rust-0.1.0-*.whl
+pip install --force-reinstall --no-deps path/to/deepdiff_rust-0.1.1-*.whl
 ```
 
 From source (Rust toolchain + Maturin):
@@ -157,7 +157,7 @@ value; maturin authenticates as user `__token__`.
 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
+pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ deepdiff-rust==0.1.1
 python -c "from deepdiff_rust import DeepDiff; print(DeepDiff({'a':1},{'a':2}))"
 ```
 
@@ -166,12 +166,12 @@ python -c "from deepdiff_rust import DeepDiff; print(DeepDiff({'a':1},{'a':2}))"
 ### 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`).
+   without the leading `v` (e.g. `0.1.1` ↔ `v0.1.1`).
 2. Push the tag (or run the workflow with target `pypi`):
 
 ```bash
-git tag v0.1.0
-git push origin v0.1.0
+git tag v0.1.1
+git push origin v0.1.1
 ```
 
 3. After the job finishes: `pip install deepdiff-rust`.

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/README.md

@@ -21,7 +21,7 @@ print(DeepDiff({"a": 1, "b": [1, 2]}, {"a": 2, "b": [1, 3]}))
 From a local wheel (Windows / manylinux x86_64 abi3):
 
 ```bash
-pip install --force-reinstall --no-deps path/to/deepdiff_rust-0.1.0-*.whl
+pip install --force-reinstall --no-deps path/to/deepdiff_rust-0.1.1-*.whl
 ```
 
 From source (Rust toolchain + Maturin):
@@ -123,7 +123,7 @@ value; maturin authenticates as user `__token__`.
 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
+pip install -i https://test.pypi.org/simple/ --extra-index-url https://pypi.org/simple/ deepdiff-rust==0.1.1
 python -c "from deepdiff_rust import DeepDiff; print(DeepDiff({'a':1},{'a':2}))"
 ```
 
@@ -132,12 +132,12 @@ python -c "from deepdiff_rust import DeepDiff; print(DeepDiff({'a':1},{'a':2}))"
 ### 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`).
+   without the leading `v` (e.g. `0.1.1` ↔ `v0.1.1`).
 2. Push the tag (or run the workflow with target `pypi`):
 
 ```bash
-git tag v0.1.0
-git push origin v0.1.0
+git tag v0.1.1
+git push origin v0.1.1
 ```
 
 3. After the job finishes: `pip install deepdiff-rust`.

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/crates/deepdiff-python/src/deepdiff.rs

@@ -115,8 +115,6 @@ impl DeepDiff {
             }
             opts.type_groups = Some(Arc::new(groups));
         }
-        // ponytail: filters drop findings after the diff instead of pruning it, so an
-        // excluded part still pairs under ignore_order; prune in the core if that matters.
         let excluded = std::mem::take(&mut held.excluded);
         let skip_error = Mutex::new(None);
         let keep = |path: &[PathSegment]| {

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "deepdiff-rust"
-version = "0.1.0"
+version = "0.1.1"
 description = "Rust-backed DeepDiff-compatible comparison for Python"
 readme = "README.md"
 requires-python = ">=3.10"

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/__init__.pyi

@@ -10,8 +10,6 @@ class MaxDepthError(ValueError):
 MAX_DEPTH_CEILING: int
 
 class DeepDiff(dict[str, Any]):
-    """A drop-in ``deepdiff.DeepDiff``: the differences between ``t1`` and ``t2`` as a dict."""
-
     t1: Any
     t2: Any
     verbose_level: int
@@ -61,25 +59,19 @@ class DeepDiff(dict[str, Any]):
         include_obj_callback_strict: Any | None = ...,
         iterable_compare_func: Any | None = ...,
     ) -> None: ...
-    def to_dict(self, verbose_level: int | None = ...) -> dict[str, Any]:
-        """The differences as a plain dict, with ``type_changes`` types as type objects."""
-
+    def to_dict(self, verbose_level: int | None = ...) -> dict[str, Any]: ...
     def to_json(
         self,
         default_mapping: dict[type, Any] | None = ...,
         force_use_builtin_json: bool = ...,
         verbose_level: int | None = ...,
         **kwargs: Any,
-    ) -> str:
-        """The differences as JSON; extra keyword arguments go to ``json.dumps``."""
-
+    ) -> str: ...
     @property
-    def affected_paths(self) -> set[str]:
-        """The paths of every difference in this result."""
-
+    def affected_paths(self) -> set[str]: ...
     @property
-    def affected_root_keys(self) -> set[Any]:
-        """The root keys, indices or attribute names the differences sit under."""
+    def affected_root_keys(self) -> set[Any]: ...
+    def pretty(self, prefix: Any = ...) -> str: ...
 
 def diff_json(
     a: str,
@@ -88,4 +80,3 @@ def diff_json(
     max_depth: int | None = ...,
 ) -> str:
     """Diffs two JSON documents and returns a ``DeepDiff``-compatible JSON report string (``verbose_level=2`` shape)."""
-

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_callbacks.py

@@ -1,4 +1,4 @@
-"""DeepDiff callback helpers: Level, activity, object-callback skip."""
+"""Callback helpers: Level and object-callback skip."""
 
 from collections.abc import Mapping
 
@@ -6,8 +6,6 @@ from ._paths import _elements
 
 
 class Level:
-    """Minimal DeepDiff-compatible level for operators and iterable_compare_func."""
-
     __slots__ = ("t1", "t2", "_path")
 
     def __init__(self, t1, t2, path="root"):
@@ -67,7 +65,6 @@ def compose_skip(
     include_obj_callback=None,
     include_obj_callback_strict=None,
 ):
-    """Retain-filter skip plus DeepDiff object-callback branch of `_skip_this`."""
     if not any(
         (
             exclude_obj_callback,

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_diff.py

@@ -1,4 +1,4 @@
-"""The `DeepDiff` result: a `dict` of findings, like `deepdiff.DeepDiff`."""
+"""DeepDiff result dict, drop-in for deepdiff.DeepDiff."""
 
 import ast
 import datetime
@@ -34,13 +34,10 @@ _NOT_PRESENT = object()
 
 
 def _root_key(path):
-    """The key, index or attribute name right after `root` in a rendered path."""
     rest = path[len("root"):]
     if rest.startswith("."):
         ends = [i for i in (rest.find(".", 1), rest.find("[")) if i > 0]
         return rest[1 : min(ends, default=len(rest))]
-    # ponytail: tries each "]" until the key parses as a literal; a key whose
-    # repr is not a Python literal is skipped.
     end = rest.find("]")
     while end != -1:
         try:
@@ -51,7 +48,6 @@ def _root_key(path):
 
 
 class DeepDiff(dict):
-    """A drop-in `deepdiff.DeepDiff`: the differences between `t1` and `t2` as a dict."""
 
     def __init__(
         self, t1, t2, *, ignore_order=False, max_depth=None, verbose_level=1, view="text",
@@ -80,7 +76,6 @@ class DeepDiff(dict):
             self.t1 = t1
             self.t2 = t2
             self._native = None
-            self._bridge = None
             self.tree = {}
             super().__init__()
             return
@@ -134,7 +129,6 @@ class DeepDiff(dict):
                     ).to_dict(verbose_level)
                 )
             self._native = None
-            self._bridge = None
             self._finish_init(run_dual(self, t1, t2, native_factory))
             return
         skip = skip_filter(exclude_paths, include_paths, exclude_regex_paths, exclude_types)
@@ -145,7 +139,6 @@ class DeepDiff(dict):
             include_obj_callback=include_obj_callback,
             include_obj_callback_strict=include_obj_callback_strict,
         )
-        self._bridge = None
         self._native = _native.DeepDiff(
             t1, t2, ignore_order=ignore_order, max_depth=max_depth, exclude_types=exclude_types,
             ignore_private_variables=ignore_private_variables, skip=skip, use_enum_value=use_enum_value,
@@ -170,21 +163,16 @@ class DeepDiff(dict):
         self._finish_init(self.to_dict())
 
     def _finish_init(self, report):
-        """Store text report, build `.tree`, and optionally switch to view='tree'."""
         text = dict(report)
-        self.tree = build_tree(text, self.verbose_level)
+        self.tree = build_tree(text)
         if self.view == "tree":
             super().__init__(tree_as_result(self.tree))
         else:
             super().__init__(text)
 
     def to_dict(self, verbose_level=None):
-        """The differences as a plain dict, with `type_changes` types as type objects."""
         if self._native is None:
-            if self._bridge is not None:
-                return self._bridge.to_dict(verbose_level=self._level(verbose_level))
             if getattr(self, "view", "text") == "tree":
-                # Rebuild a text-shaped dict from levels when asked.
                 out = {}
                 for key, levels in self.tree.items():
                     if key.endswith(("_added", "_removed")) and self._level(verbose_level) < 2:
@@ -220,13 +208,11 @@ class DeepDiff(dict):
         return report
 
     def to_json(self, default_mapping=None, force_use_builtin_json=False, verbose_level=None, **kwargs):
-        """The differences as JSON; extra keyword arguments go to `json.dumps`."""
         if default_mapping is not None:
             raise NotImplementedError("default_mapping is not supported yet.")
         if self._native is None:
-            if self._bridge is not None:
-                return self._bridge.to_json(verbose_level=self._level(verbose_level), **kwargs)
-            return json.dumps(self.to_dict(verbose_level), **kwargs) if kwargs else json.dumps(self.to_dict(verbose_level))
+            data = self.to_dict(verbose_level)
+            return json.dumps(data, **kwargs) if kwargs else json.dumps(data)
         text = self._native.to_json(self._level(verbose_level))
         if self._native.deep_distance is not None:
             report = json.loads(text)
@@ -236,7 +222,6 @@ class DeepDiff(dict):
 
     @property
     def affected_paths(self):
-        """The paths of every difference in this result."""
         paths = set()
         for key, findings in self.items():
             if key == "deep_distance":
@@ -251,7 +236,6 @@ class DeepDiff(dict):
 
     @property
     def affected_root_keys(self):
-        """The root keys, indices or attribute names the differences sit under."""
         report = self.to_dict(2)
         keys = set()
         for findings in report.values():
@@ -263,8 +247,7 @@ class DeepDiff(dict):
         return keys
 
     def pretty(self, prefix=None):
-        """Human-readable multi-line summary of the differences."""
-        tree = getattr(self, "tree", None) or build_tree(self.to_dict(), self.verbose_level)
+        tree = getattr(self, "tree", None) or build_tree(self.to_dict())
         return pretty_from_tree(tree, self.verbose_level, prefix)
 
     def custom_report_result(self, report_type, level, extra_info=None):
@@ -275,7 +258,7 @@ class DeepDiff(dict):
             payload.setdefault("new_value", level.t2)
         bucket = getattr(self, "_walk_report", self).setdefault(report_type, {})
         bucket[path] = payload
-        if self._native is None and getattr(self, "_bridge", None) is None:
+        if self._native is None:
             self.setdefault(report_type, {})[path] = payload
 
     def _report_result(self, report_type, change_level, local_tree=None):

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_dual.py

@@ -1,4 +1,4 @@
-"""Native dual walk for custom_operators and iterable_compare_func."""
+"""Dual walk for custom_operators and iterable_compare_func."""
 
 from collections.abc import Mapping, Sequence
 

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_group_by.py

@@ -1,4 +1,4 @@
-"""`group_by`: a list of dicts regrouped into a dict before the diff, as DeepDiff does."""
+"""group_by: regroup a list of dicts before the diff."""
 
 from collections.abc import Iterable, Mapping
 from copy import deepcopy
@@ -16,7 +16,6 @@ def _add(result, key, row, sort_key):
 
 
 def _group(item, group_by, sort_key):
-    """DeepDiff's `_group_iterable_to_dict`; raises `KeyError` or `ValueError` when it cannot."""
     level1, level2 = group_by, None
     if isinstance(group_by, (list, tuple)):
         level1, level2 = group_by[0], group_by[1] if len(group_by) > 1 else None
@@ -39,7 +38,6 @@ def _group(item, group_by, sort_key):
 
 
 def group_pair(t1, t2, group_by, group_by_sort_key):
-    """`(t1, t2)` grouped, or both unchanged when either side cannot be grouped."""
     if not group_by:
         return t1, t2
     sort_key = group_by_sort_key

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_options.py

@@ -1,11 +1,10 @@
-"""deepdiff 9.1.0's value-normalization options, as the native diff takes them."""
+"""Normalization options passed through to the native DeepDiff."""
 
 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,
@@ -31,7 +30,6 @@ _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 = [
@@ -53,7 +51,6 @@ def native_options(
     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:
@@ -81,7 +78,6 @@ def native_options(
         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)

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_paths.py

@@ -1,4 +1,4 @@
-"""Path filters: deepdiff 9.1.0's `_skip_this` over rendered path strings."""
+"""Path filters over rendered DeepDiff path strings."""
 
 import ast
 import re
@@ -21,7 +21,6 @@ def _element(text, literal):
 
 @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
@@ -46,8 +45,6 @@ def _elements(path):
 
 
 def _matches(pattern, target, prefix):
-    """`pattern` matches `target`, or (`prefix`) some prefix of it."""
-
     @cache
     def go(p, t):
         if p == len(pattern):
@@ -62,8 +59,6 @@ def _matches(pattern, target, prefix):
 
 
 def _could_reach(pattern, target):
-    """`target` is an ancestor of some path `pattern` matches."""
-
     @cache
     def go(p, t):
         if t == len(target):
@@ -78,7 +73,6 @@ def _could_reach(pattern, target):
 
 
 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"):
@@ -93,7 +87,6 @@ def _root_paths(paths):
 
 
 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)
@@ -115,9 +108,6 @@ def _regexes(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)
@@ -141,7 +131,6 @@ def skip_filter(exclude_paths, include_paths, exclude_regex_paths, exclude_types
         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)

{deepdiff_rust-0.1.0 → deepdiff_rust-0.1.1}/python/deepdiff_rust/_view.py

@@ -1,11 +1,7 @@
-"""pretty() formatting and a minimal view='tree' DiffLevel."""
-
-from __future__ import annotations
+"""pretty() and view='tree' DiffLevel."""
 
 
 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):
@@ -85,8 +81,7 @@ def _level_from_finding(report_type, path, payload):
     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."""
+def build_tree(report):
     tree = {}
     for report_type, findings in report.items():
         if report_type == "deep_distance":
@@ -100,12 +95,11 @@ def build_tree(report: dict, verbose_level: int = 1) -> dict:
     return tree
 
 
-def tree_as_result(tree: dict) -> dict:
-    """DeepDiff view='tree' shape: category → list of DiffLevel."""
+def tree_as_result(tree):
     return {key: list(levels) for key, levels in tree.items()}
 
 
-def pretty_from_tree(tree: dict, verbose_level: int = 1, prefix=None) -> str:
+def pretty_from_tree(tree, verbose_level=1, prefix=None):
     forms = _PRETTY_V2 if verbose_level == 2 else _PRETTY
     if prefix is None:
         prefix = ""
@@ -115,12 +109,10 @@ def pretty_from_tree(tree: dict, verbose_level: int = 1, prefix=None) -> str:
             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,
+                type_t1=type(level.t1).__name__,
+                type_t2=type(level.t2).__name__,
                 val_t1=_fmt_val(level.t1),
                 val_t2=_fmt_val(level.t2),
             )