adding ignore_uuid_types flag

Author: seperman

CLAUDE.md

@@ -21,6 +21,9 @@ uv pip install -e ".[cli,coverage,dev,docs,static,test]"
 uv sync --all-extras
 ```
 
+**Virtual Environment**: Activate with `source ~/.venvs/atlas/bin/activate` before running tests or Python commands
+
+
 ### Testing
 ```bash
 # Run tests with coverage

deepdiff/base.py

@@ -1,3 +1,4 @@
+import uuid
 from deepdiff.helper import strings, numbers, SetOrdered
 
 
@@ -21,7 +22,8 @@ def get_significant_digits(self, significant_digits, ignore_numeric_type_changes
     def get_ignore_types_in_groups(self, ignore_type_in_groups,
                                    ignore_string_type_changes,
                                    ignore_numeric_type_changes,
-                                   ignore_type_subclasses):
+                                   ignore_type_subclasses,
+                                   ignore_uuid_types=False):
         if ignore_type_in_groups:
             if isinstance(ignore_type_in_groups[0], type):
                 ignore_type_in_groups = [ignore_type_in_groups]
@@ -43,6 +45,12 @@ def get_ignore_types_in_groups(self, ignore_type_in_groups,
         if ignore_numeric_type_changes and self.numbers not in ignore_type_in_groups:
             ignore_type_in_groups.append(SetOrdered(self.numbers))
 
+        if ignore_uuid_types:
+            # Create a group containing both UUID and str types
+            uuid_str_group = SetOrdered([uuid.UUID, str])
+            if uuid_str_group not in ignore_type_in_groups:
+                ignore_type_in_groups.append(uuid_str_group)
+
         if not ignore_type_subclasses:
             # is_instance method needs tuples. When we look for subclasses, we need them to be tuples
             ignore_type_in_groups = list(map(tuple, ignore_type_in_groups))

deepdiff/deephash.py

@@ -163,6 +163,7 @@ def __init__(self,
                  ignore_string_type_changes=False,
                  ignore_type_in_groups=None,
                  ignore_type_subclasses=False,
+                 ignore_uuid_types=False,
                  include_paths=None,
                  number_format_notation="f",
                  number_to_string_func=None,
@@ -177,7 +178,7 @@ def __init__(self,
                  "The valid parameters are obj, hashes, exclude_types, significant_digits, truncate_datetime,"
                  "exclude_paths, include_paths, exclude_regex_paths, hasher, ignore_repetition, "
                  "number_format_notation, apply_hash, ignore_type_in_groups, ignore_string_type_changes, "
-                 "ignore_numeric_type_changes, ignore_type_subclasses, ignore_string_case "
+                 "ignore_numeric_type_changes, ignore_type_subclasses, ignore_string_case, ignore_uuid_types, "
                  "number_to_string_func, ignore_private_variables, parent, use_enum_value, default_timezone "
                  "encodings, ignore_encoding_errors") % ', '.join(kwargs.keys()))
         if isinstance(hashes, MutableMapping):
@@ -203,7 +204,9 @@ def __init__(self,
             ignore_type_in_groups=ignore_type_in_groups,
             ignore_string_type_changes=ignore_string_type_changes,
             ignore_numeric_type_changes=ignore_numeric_type_changes,
-            ignore_type_subclasses=ignore_type_subclasses)
+            ignore_type_subclasses=ignore_type_subclasses,
+            ignore_uuid_types=ignore_uuid_types,
+        )
         self.ignore_string_type_changes = ignore_string_type_changes
         self.ignore_numeric_type_changes = ignore_numeric_type_changes
         self.ignore_string_case = ignore_string_case

deepdiff/diff.py

@@ -9,6 +9,7 @@
 import logging
 import types
 import datetime
+import uuid
 from enum import Enum
 from copy import deepcopy
 from math import isclose as is_close
@@ -108,6 +109,7 @@ def _report_progress(_stats, progress_logger, duration):
     'number_format_notation',
     'ignore_string_type_changes',
     'ignore_numeric_type_changes',
+    'ignore_uuid_types',
     'use_enum_value',
     'ignore_type_in_groups',
     'ignore_type_subclasses',
@@ -168,6 +170,7 @@ def __init__(self,
                  ignore_string_type_changes: bool=False,
                  ignore_type_in_groups: Optional[List[Tuple]]=None,
                  ignore_type_subclasses: bool=False,
+                 ignore_uuid_types: bool=False,
                  include_obj_callback: Optional[Callable]=None,
                  include_obj_callback_strict: Optional[Callable]=None,
                  include_paths: Union[str, List[str], None]=None,
@@ -199,7 +202,7 @@ def __init__(self,
                 "The following parameter(s) are not valid: %s\n"
                 "The valid parameters are ignore_order, report_repetition, significant_digits, "
                 "number_format_notation, exclude_paths, include_paths, exclude_types, exclude_regex_paths, ignore_type_in_groups, "
-                "ignore_string_type_changes, ignore_numeric_type_changes, ignore_type_subclasses, truncate_datetime, "
+                "ignore_string_type_changes, ignore_numeric_type_changes, ignore_type_subclasses, ignore_uuid_types, truncate_datetime, "
                 "ignore_private_variables, ignore_nan_inequality, number_to_string_func, verbose_level, "
                 "view, hasher, hashes, max_passes, max_diffs, zip_ordered_iterables, "
                 "cutoff_distance_for_pairs, cutoff_intersection_for_pairs, log_frequency_in_sec, cache_size, "
@@ -222,6 +225,11 @@ def __init__(self,
             self.ignore_numeric_type_changes = ignore_numeric_type_changes
             if strings == ignore_type_in_groups or strings in ignore_type_in_groups:
                 ignore_string_type_changes = True
+            # Handle ignore_uuid_types - check if uuid+str group is already in ignore_type_in_groups
+            uuid_str_group = (uuids[0], str)
+            if uuid_str_group == ignore_type_in_groups or uuid_str_group in ignore_type_in_groups:
+                ignore_uuid_types = True
+            self.ignore_uuid_types = ignore_uuid_types
             self.use_enum_value = use_enum_value
             self.log_scale_similarity_threshold = log_scale_similarity_threshold
             self.use_log_scale = use_log_scale
@@ -233,7 +241,8 @@ def __init__(self,
                 ignore_type_in_groups=ignore_type_in_groups,
                 ignore_string_type_changes=ignore_string_type_changes,
                 ignore_numeric_type_changes=ignore_numeric_type_changes,
-                ignore_type_subclasses=ignore_type_subclasses)
+                ignore_type_subclasses=ignore_type_subclasses,
+                ignore_uuid_types=ignore_uuid_types)
             self.report_repetition = report_repetition
             self.exclude_paths = add_root_to_paths(convert_item_or_items_into_set_else_none(exclude_paths))
             self.include_paths = add_root_to_paths(convert_item_or_items_into_set_else_none(include_paths))
@@ -1710,7 +1719,18 @@ def _diff(self, level, parents_ids=frozenset(), _original_type=None, local_tree=
             self._diff_booleans(level, local_tree=local_tree)
 
         elif isinstance(level.t1, strings):
-            self._diff_str(level, local_tree=local_tree)
+            # Special handling when comparing string with UUID and ignore_uuid_types is True
+            if self.ignore_uuid_types and isinstance(level.t2, uuids):
+                try:
+                    # Convert string to UUID for comparison
+                    t1_uuid = uuid.UUID(level.t1)
+                    if t1_uuid.int != level.t2.int:
+                        self._report_result('values_changed', level, local_tree=local_tree)
+                except (ValueError, AttributeError):
+                    # If string is not a valid UUID, report as changed
+                    self._report_result('values_changed', level, local_tree=local_tree)
+            else:
+                self._diff_str(level, local_tree=local_tree)
 
         elif isinstance(level.t1, datetime.datetime):
             self._diff_datetime(level, local_tree=local_tree)
@@ -1722,7 +1742,18 @@ def _diff(self, level, parents_ids=frozenset(), _original_type=None, local_tree=
             self._diff_time(level, local_tree=local_tree)
 
         elif isinstance(level.t1, uuids):
-            self._diff_uuids(level, local_tree=local_tree)
+            # Special handling when comparing UUID with string and ignore_uuid_types is True
+            if self.ignore_uuid_types and isinstance(level.t2, str):
+                try:
+                    # Convert string to UUID for comparison
+                    t2_uuid = uuid.UUID(level.t2)
+                    if level.t1.int != t2_uuid.int:
+                        self._report_result('values_changed', level, local_tree=local_tree)
+                except (ValueError, AttributeError):
+                    # If string is not a valid UUID, report as changed
+                    self._report_result('values_changed', level, local_tree=local_tree)
+            else:
+                self._diff_uuids(level, local_tree=local_tree)
 
         elif isinstance(level.t1, numbers):
             self._diff_numbers(level, local_tree=local_tree, report_type_change=report_type_change)

tests/test_delta.py

@@ -1508,6 +1508,7 @@ def test_delta_view_and_to_delta_dict_are_equal_when_parameteres_passed(self):
             'include_obj_callback_strict': None,
             'exclude_obj_callback': None,
             'exclude_obj_callback_strict': None,
+            'ignore_uuid_types': False,
             'ignore_private_variables': True,
             'ignore_nan_inequality': False,
             'hasher': None,

tests/test_ignore_uuid_types.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python
+import uuid
+import unittest
+from deepdiff import DeepDiff
+
+
+class TestIgnoreUuidTypes(unittest.TestCase):
+    """Test ignore_uuid_types functionality"""
+
+    def test_uuid_vs_string_without_ignore(self):
+        """Test that UUID vs string reports type change by default"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid_str = '12345678-1234-5678-1234-567812345678'
+        
+        result = DeepDiff(test_uuid, uuid_str)
+        
+        assert 'type_changes' in result
+        assert result['type_changes']['root']['old_type'] == uuid.UUID
+        assert result['type_changes']['root']['new_type'] == str
+        assert result['type_changes']['root']['old_value'] == test_uuid
+        assert result['type_changes']['root']['new_value'] == uuid_str
+
+    def test_uuid_vs_string_with_ignore(self):
+        """Test that UUID vs string is ignored when ignore_uuid_types=True"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid_str = '12345678-1234-5678-1234-567812345678'
+        
+        result = DeepDiff(test_uuid, uuid_str, ignore_uuid_types=True)
+        
+        assert result == {}
+
+    def test_string_vs_uuid_with_ignore(self):
+        """Test that string vs UUID is ignored when ignore_uuid_types=True (reverse order)"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid_str = '12345678-1234-5678-1234-567812345678'
+        
+        result = DeepDiff(uuid_str, test_uuid, ignore_uuid_types=True)
+        
+        assert result == {}
+
+    def test_different_uuid_values_with_ignore(self):
+        """Test that different UUID values are still reported"""
+        uuid1 = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid2 = uuid.UUID('87654321-4321-8765-4321-876543218765')
+        
+        result = DeepDiff(uuid1, uuid2, ignore_uuid_types=True)
+        
+        assert 'values_changed' in result
+        assert result['values_changed']['root']['old_value'] == uuid1
+        assert result['values_changed']['root']['new_value'] == uuid2
+
+    def test_uuid_vs_different_string_with_ignore(self):
+        """Test that UUID vs different UUID string reports value change"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        different_str = '87654321-4321-8765-4321-876543218765'
+        
+        result = DeepDiff(test_uuid, different_str, ignore_uuid_types=True)
+        
+        assert 'values_changed' in result
+        assert result['values_changed']['root']['old_value'] == test_uuid
+        assert result['values_changed']['root']['new_value'] == different_str
+
+    def test_uuid_vs_invalid_string_with_ignore(self):
+        """Test that UUID vs invalid UUID string reports value change"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        invalid_str = 'not-a-uuid'
+        
+        result = DeepDiff(test_uuid, invalid_str, ignore_uuid_types=True)
+        
+        assert 'values_changed' in result
+        assert result['values_changed']['root']['old_value'] == test_uuid
+        assert result['values_changed']['root']['new_value'] == invalid_str
+
+    def test_uuid_in_dict_with_ignore(self):
+        """Test that UUID vs string in dictionaries works correctly"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid_str = '12345678-1234-5678-1234-567812345678'
+        
+        dict1 = {'id': test_uuid, 'name': 'test', 'count': 42}
+        dict2 = {'id': uuid_str, 'name': 'test', 'count': 42}
+        
+        result = DeepDiff(dict1, dict2, ignore_uuid_types=True)
+        
+        assert result == {}
+
+    def test_uuid_in_list_with_ignore(self):
+        """Test that UUID vs string in lists works correctly"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid_str = '12345678-1234-5678-1234-567812345678'
+        
+        list1 = [test_uuid, 'test', 42]
+        list2 = [uuid_str, 'test', 42]
+        
+        result = DeepDiff(list1, list2, ignore_uuid_types=True)
+        
+        assert result == {}
+
+    def test_mixed_uuid_comparisons_with_ignore(self):
+        """Test mixed UUID/string comparisons in nested structures"""
+        uuid1 = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        uuid2 = uuid.UUID('87654321-4321-8765-4321-876543218765')
+        
+        data1 = {
+            'uuid_obj': uuid1,
+            'uuid_str': '12345678-1234-5678-1234-567812345678',
+            'nested': {
+                'id': uuid2,
+                'items': [uuid1, 'test']
+            }
+        }
+        
+        data2 = {
+            'uuid_obj': '12345678-1234-5678-1234-567812345678',  # string version
+            'uuid_str': uuid1,  # UUID object version
+            'nested': {
+                'id': '87654321-4321-8765-4321-876543218765',  # string version
+                'items': ['12345678-1234-5678-1234-567812345678', 'test']  # string version
+            }
+        }
+        
+        result = DeepDiff(data1, data2, ignore_uuid_types=True)
+        
+        assert result == {}
+
+    def test_uuid_with_other_ignore_flags(self):
+        """Test that ignore_uuid_types works with other ignore flags"""
+        test_uuid = uuid.UUID('12345678-1234-5678-1234-567812345678')
+        
+        data1 = {
+            'id': test_uuid,
+            'name': 'TEST',
+            'count': 42
+        }
+        
+        data2 = {
+            'id': '12345678-1234-5678-1234-567812345678',
+            'name': 'test',  # different case
+            'count': 42.0  # different numeric type
+        }
+        
+        result = DeepDiff(data1, data2, 
+                         ignore_uuid_types=True,
+                         ignore_string_case=True,
+                         ignore_numeric_type_changes=True)
+        
+        assert result == {}
+
+
+if __name__ == '__main__':
+    unittest.main()