Two bugs combined to make ignore_order=True miss int-vs-float type changes:

  1. Hash cache collision (deephash.py): The shared self.hashes dict used raw objects as keys.
  Since Python treats 1 == 1.0 and hash(1) == hash(1.0), looking up 1.0 returned the cached hash
  for 1, silently hiding the type difference.
  2. Distance over-counting (distance.py): _get_item_length counted both old_type and old_value in
  type_changes entries, double-counting a single operation. This inflated distances, causing the
  pairing algorithm to reject items that should have been matched.

  Fixes:

  - deepdiff/deephash.py: Added _make_hash_key() / _make_hash_key_for_lookup() that wrap numeric
  objects as (type(obj), obj) tuples when ignore_numeric_type_changes=False. Applied at cache
  lookup, cache store, and all public accessor methods (__getitem__, __contains__, get, get_key).
  Added _unwrap_hash_key() for iteration methods so the public API still shows raw objects.
  - deepdiff/distance.py: Skip old_type and old_value keys in _get_item_length — they're metadata
  about prior state, not additional operations. Also added ignore_numeric_type_changes to
  DistanceProtocol and threaded it through get_key calls.
  - Test updates: Updated expected distance values in test_distance.py to reflect the corrected
  distance formula.

Author: seperman

deepdiff/deephash.py

@@ -9,7 +9,7 @@
 from pathlib import Path
 from enum import Enum
 import re
-from deepdiff.helper import (strings, numbers, times, unprocessed, not_hashed, add_to_frozen_set,
+from deepdiff.helper import (strings, numbers, only_numbers, times, unprocessed, not_hashed, add_to_frozen_set,
                              convert_item_or_items_into_set_else_none, get_doc, ipranges,
                              convert_item_or_items_into_compiled_regexes_else_none,
                              get_id, type_is_subclass_of_type_group, type_in_type_group,
@@ -276,10 +276,13 @@ def __init__(self,
     sha1hex: Callable[[Union[str, bytes]], str] = sha1hex
 
     def __getitem__(self, obj: Any, extract_index: Optional[int] = 0) -> Any:
-        return self._getitem(self.hashes, obj, extract_index=extract_index, use_enum_value=self.use_enum_value)
+        return self._getitem(self.hashes, obj, extract_index=extract_index,
+                             use_enum_value=self.use_enum_value,
+                             ignore_numeric_type_changes=self.ignore_numeric_type_changes)
 
     @staticmethod
-    def _getitem(hashes: Dict[Any, Any], obj: Any, extract_index: Optional[int] = 0, use_enum_value: bool = False) -> Any:
+    def _getitem(hashes: Dict[Any, Any], obj: Any, extract_index: Optional[int] = 0,
+                 use_enum_value: bool = False, ignore_numeric_type_changes: bool = False) -> Any:
         """
         extract_index is zero for hash and 1 for count and None to get them both.
         To keep it backward compatible, we only get the hash by default so it is set to zero by default.
@@ -292,6 +295,7 @@ def _getitem(hashes: Dict[Any, Any], obj: Any, extract_index: Optional[int] = 0,
             key = BoolObj.FALSE
         elif use_enum_value and isinstance(obj, Enum):
             key = obj.value
+        key = DeepHash._make_hash_key_for_lookup(key, ignore_numeric_type_changes=ignore_numeric_type_changes)
 
         result_n_count: Tuple[Any, int] = (None, 0)  # type: ignore
 
@@ -310,9 +314,10 @@ def _getitem(hashes: Dict[Any, Any], obj: Any, extract_index: Optional[int] = 0,
         return result_n_count if extract_index is None else result_n_count[extract_index]
 
     def __contains__(self, obj: Any) -> bool:
+        key = self._make_hash_key(obj)
         result = False
         try:
-            result = obj in self.hashes
+            result = key in self.hashes
         except (TypeError, KeyError):
             result = False
         if not result:
@@ -325,21 +330,32 @@ def get(self, key: Any, default: Any = None, extract_index: Optional[int] = 0) -
         It can extract the hash for a given key that is already calculated when extract_index=0
         or the count of items that went to building the object whenextract_index=1.
         """
-        return self.get_key(self.hashes, key, default=default, extract_index=extract_index)
+        return self.get_key(self.hashes, key, default=default, extract_index=extract_index,
+                            ignore_numeric_type_changes=self.ignore_numeric_type_changes)
 
     @staticmethod
-    def get_key(hashes: Dict[Any, Any], key: Any, default: Any = None, extract_index: Optional[int] = 0, use_enum_value: bool = False) -> Any:
+    def get_key(hashes: Dict[Any, Any], key: Any, default: Any = None, extract_index: Optional[int] = 0,
+                use_enum_value: bool = False, ignore_numeric_type_changes: bool = False) -> Any:
         """
         get_key method for the hashes dictionary.
         It can extract the hash for a given key that is already calculated when extract_index=0
         or the count of items that went to building the object whenextract_index=1.
         """
         try:
-            result = DeepHash._getitem(hashes, key, extract_index=extract_index, use_enum_value=use_enum_value)
+            result = DeepHash._getitem(hashes, key, extract_index=extract_index,
+                                       use_enum_value=use_enum_value,
+                                       ignore_numeric_type_changes=ignore_numeric_type_changes)
         except KeyError:
             result = default
         return result
 
+    @staticmethod
+    def _unwrap_hash_key(key: Any) -> Any:
+        """Unwrap a (type, value) hash key back to the original value for public API."""
+        if isinstance(key, tuple) and len(key) == 2 and isinstance(key[0], type) and isinstance(key[1], only_numbers):
+            return key[1]
+        return key
+
     def _get_objects_to_hashes_dict(self, extract_index: Optional[int] = 0) -> Dict[Any, Any]:
         """
         A dictionary containing only the objects to hashes,
@@ -348,6 +364,7 @@ def _get_objects_to_hashes_dict(self, extract_index: Optional[int] = 0) -> Dict[
         """
         result = dict_()
         for key, value in self.hashes.items():
+            key = self._unwrap_hash_key(key)
             if key is UNPROCESSED_KEY:
                 result[key] = value
             else:
@@ -377,13 +394,13 @@ def __bool__(self) -> bool:
         return bool(self.hashes)
 
     def keys(self) -> Any:
-        return self.hashes.keys()
+        return [self._unwrap_hash_key(k) for k in self.hashes.keys()]
 
     def values(self) -> Generator[Any, None, None]:
         return (i[0] for i in self.hashes.values())  # Just grab the item and not its count
 
     def items(self) -> Generator[Tuple[Any, Any], None, None]:
-        return ((i, v[0]) for i, v in self.hashes.items())
+        return ((self._unwrap_hash_key(i), v[0]) for i, v in self.hashes.items())
 
     def _prep_obj(self, obj: Any, parent: str, parents_ids: frozenset = EMPTY_FROZENSET, is_namedtuple: bool = False, is_pydantic_object: bool = False) -> HashTuple:
         """prepping objects"""
@@ -555,6 +572,26 @@ def _prep_tuple(self, obj: tuple, parent: str, parents_ids: frozenset) -> HashTu
             result, counts = self._prep_obj(obj, parent, parents_ids=parents_ids, is_namedtuple=True)
         return result, counts
 
+    def _make_hash_key(self, obj: Any) -> Any:
+        """
+        Create a key for the hashes dict that distinguishes numeric types.
+
+        In Python, 1 == 1.0 and hash(1) == hash(1.0), so int and float values
+        collide as dict keys. When ignore_numeric_type_changes is False, we wrap
+        numeric objects as (type, value) tuples so that each type gets its own
+        cache entry and its own hash.
+        """
+        if not self.ignore_numeric_type_changes and isinstance(obj, only_numbers):
+            return (type(obj), obj)
+        return obj
+
+    @staticmethod
+    def _make_hash_key_for_lookup(obj: Any, ignore_numeric_type_changes: bool = False) -> Any:
+        """Static version of _make_hash_key for use in static accessor methods."""
+        if not ignore_numeric_type_changes and isinstance(obj, only_numbers):
+            return (type(obj), obj)
+        return obj
+
     def _hash(self, obj: Any, parent: str, parents_ids: frozenset = EMPTY_FROZENSET) -> HashTuple:
         """The main hash method"""
         counts = 1
@@ -573,8 +610,9 @@ def _hash(self, obj: Any, parent: str, parents_ids: frozenset = EMPTY_FROZENSET)
             obj = obj.value
         else:
             result = not_hashed
+        hash_key = self._make_hash_key(obj)
         try:
-            result, counts = self.hashes[obj]
+            result, counts = self.hashes[hash_key]
         except (TypeError, KeyError):
             pass
         else:
@@ -662,7 +700,7 @@ def gen():
         # The hashes will be later used for comparing the objects.
         # Object to hash when possible otherwise ObjectID to hash
         try:
-            self.hashes[obj] = (result, counts)
+            self.hashes[hash_key] = (result, counts)
         except TypeError:
             obj_id = get_id(obj)
             self.hashes[obj_id] = (result, counts)

deepdiff/distance.py

@@ -14,6 +14,7 @@
     class DistanceProtocol(DeepDiffProtocol, Protocol):
         hashes: dict
         deephash_parameters: dict
+        ignore_numeric_type_changes: bool
         iterable_compare_func: Optional[Callable]
         math_epsilon: Optional[float]
         cutoff_distance_for_pairs: float
@@ -86,10 +87,12 @@ def __get_item_rough_length(self: "DistanceProtocol", item, parent='root'):
         """
         if not hasattr(self, 'hashes'):
             raise RuntimeError(DISTANCE_CALCS_NEEDS_CACHE)
-        length = DeepHash.get_key(self.hashes, key=item, default=None, extract_index=1)
+        length = DeepHash.get_key(self.hashes, key=item, default=None, extract_index=1,
+                                   ignore_numeric_type_changes=self.ignore_numeric_type_changes)
         if length is None:
             self.__calculate_item_deephash(item)
-            length = DeepHash.get_key(self.hashes, key=item, default=None, extract_index=1)
+            length = DeepHash.get_key(self.hashes, key=item, default=None, extract_index=1,
+                                       ignore_numeric_type_changes=self.ignore_numeric_type_changes)
         return length
 
     def __calculate_item_deephash(self: "DistanceProtocol", item: Any) -> None:
@@ -184,8 +187,10 @@ def _get_item_length(item, parents_ids=frozenset([])):
                     new_subitem[path_] = new_indexes_to_items
                 subitem = new_subitem
 
-            # internal keys such as _numpy_paths should not count towards the distance
-            if isinstance(key, strings) and (key.startswith('_') or key == 'deep_distance' or key == 'new_path'):
+            # internal keys such as _numpy_paths should not count towards the distance.
+            # old_type and old_value are metadata about the previous state, not additional operations.
+            if isinstance(key, strings) and (key.startswith('_') or key == 'deep_distance' or key == 'new_path'
+                                             or key == 'old_type' or key == 'old_value'):
                 continue
 
             item_id = id(subitem)

tests/test_distance.py

@@ -48,7 +48,7 @@ class TestDeepDistance:
                     }
                 }
             },
-            3
+            2
         ),
     ])
     def test_item_length(self, diff, expected_length):
@@ -165,7 +165,7 @@ def test_get_distance_works_event_when_ignore_order_and_different_hasher(self):
         diff = DeepDiff(t1, t2, ignore_order=True, get_deep_distance=True,
                         cache_size=100, hasher=sha256hex)
         dist = diff['deep_distance']
-        assert str(dist)[:4] == '0.44'
+        assert str(dist)[:4] == '0.33'
 
     def test_get_distance_does_not_care_about_the_size_of_string(self):
         t1 = ["a", "b"]

tests/test_hash.py

@@ -250,14 +250,39 @@ def test_prep_bool_vs_num2(self):
         }
         assert DeepHashPrep(item1)[item1] == DeepHashPrep(item2)[item2]
 
-    def test_prep_str(self):
+    def test_prep_str1(self):
         obj = "a"
+        obj2 = b"a"
         expected_result = {obj: prep_str(obj)}
         result = DeepHashPrep(obj, ignore_string_type_changes=True)
         assert expected_result == result
-        expected_result = {obj: prep_str(obj, ignore_string_type_changes=False)}
+        assert result[obj] == 'a'
+        expected_result2 = {obj: prep_str(obj, ignore_string_type_changes=False)}
         result = DeepHashPrep(obj, ignore_string_type_changes=False)
-        assert expected_result == result
+        assert expected_result2 == result
+        assert result[obj] == 'str:a'
+
+        expected_result3 = {obj2: prep_str(obj2, ignore_string_type_changes=True)}
+        result = DeepHashPrep(obj2, ignore_string_type_changes=True)
+        assert expected_result3 != result
+        assert result[obj2] == 'a'
+        result = DeepHashPrep(obj2, ignore_string_type_changes=False)
+        assert {b'a': 'bytes:a'} == result
+        assert result[obj2] == 'bytes:a'
+
+    def test_prep_number1(self):
+        obj_int = 1
+        obj_float = 1.0
+        # By default, type is included in the prep
+        result_int = DeepHashPrep(obj_int)
+        result_float = DeepHashPrep(obj_float)
+        assert result_int[obj_int] == 'int:1'
+        assert result_float[obj_float] == 'float:1.0'
+        # When ignoring numeric type changes, both get the same "number:" prefix
+        result_int2 = DeepHashPrep(obj_int, ignore_numeric_type_changes=True)
+        result_float2 = DeepHashPrep(obj_float, ignore_numeric_type_changes=True)
+        assert result_int2[obj_int] == result_float2[obj_float]
+        assert result_int2[obj_int] == 'number:1.000000000000'
 
     def test_dictionary_key_type_change(self):
         obj1 = {"b": 10}

tests/test_ignore_order.py

@@ -1396,3 +1396,61 @@ def test_error_messages_when_ignore_order(self, mock_logger):
         assert {} == result
 
         assert not mock_logger.error.called
+
+
+
+class TestIgnoreOrderNumericTypeChange:
+    """Regression tests for GitHub issue #485.
+
+    When ignore_order=True, numerically-equal values of different numeric types
+    (e.g. int 1 vs float 1.0) must still be reported as type_changes.
+
+    Root cause: Python's hash equality (hash(1) == hash(1.0)) and value equality
+    (1 == 1.0) caused both items to land in the same DeepHash bucket, so they
+    were treated as identical and silently dropped from the diff result.
+    """
+
+    def test_int_vs_float_in_list_of_dicts(self):
+        """Core regression: type change inside a dict nested in a list."""
+        result = DeepDiff([{"a": 1}], [{"a": 1.0}], ignore_order=True)
+        assert "type_changes" in result, (
+            "Expected type_changes between int 1 and float 1.0, got: %s" % result
+        )
+        assert result["type_changes"]["root[0]['a']"]["old_type"] is int
+        assert result["type_changes"]["root[0]['a']"]["new_type"] is float
+
+    def test_ignore_numeric_type_changes_suppresses_report(self):
+        """When ignore_numeric_type_changes=True the type change must be hidden."""
+        result = DeepDiff(
+            [{"a": 1}], [{"a": 1.0}],
+            ignore_order=True,
+            ignore_numeric_type_changes=True,
+        )
+        assert result == {}, (
+            "With ignore_numeric_type_changes=True there should be no diff, got: %s" % result
+        )
+
+    def test_value_change_still_detected(self):
+        """Ordinary value differences must still be detected."""
+        result = DeepDiff([1], [2], ignore_order=True)
+        assert result != {}, "Expected a diff between [1] and [2]"
+
+    def test_reorder_no_false_positive(self):
+        """A simple reorder of identical values must not trigger type_changes."""
+        result = DeepDiff([1, 2, 3], [3, 2, 1], ignore_order=True)
+        assert result == {}, "Reordering identical ints must not produce a diff"
+
+    def test_mixed_list_one_type_change(self):
+        """Only the item with a type change should appear in the diff."""
+        result = DeepDiff(
+            [{"a": 1}, {"b": 2}],
+            [{"b": 2}, {"a": 1.0}],
+            ignore_order=True,
+        )
+        assert "type_changes" in result
+        assert "root[0]['a']" in result["type_changes"]
+
+    def test_ignore_order_false_unchanged(self):
+        """The ignore_order=False path must continue to work as before."""
+        result = DeepDiff([{"a": 1}], [{"a": 1.0}], ignore_order=False)
+        assert "type_changes" in result