- deephash.py: corrected exclude_paths/include_paths type to SetOrdered

  - helper.py: relaxed add_to_frozen_set to Any (callers use both int and str ids); changed
  type_in_type_group/type_is_subclass_of_type_group to accept Iterable[Type]
  - delta.py: added elem is not None guard, narrowed tag type, type-ignored namedtuple
  _replace/summarize
  - diff.py: typed _compare_in_order index params as Optional[int] with early return; fixed real
  bug len(other.indexes > 1) → len(other.indexes) > 1; cast UUID arg to str
  - distance.py: handled iterable_compare_func None check; widened max_/replace_inf_with to float;
  switched memoryview-incompatible strings to str
  - path.py: fixed real bug obj.append(_guess_type(...), next_element) (misplaced paren); coerced
  setattr name to str
  - serialization.py: type-ignored namedtuple _fields access

Author: seperman

deepdiff/deephash.py

@@ -14,7 +14,8 @@
                              convert_item_or_items_into_compiled_regexes_else_none,
                              get_id, type_is_subclass_of_type_group, type_in_type_group,
                              number_to_string, datetime_normalize, KEY_TO_VAL_STR,
-                             get_truncate_datetime, dict_, add_root_to_paths, PydanticBaseModel)
+                             get_truncate_datetime, dict_, add_root_to_paths, PydanticBaseModel,
+                             SetOrdered)
 
 from deepdiff.base import Base
 
@@ -159,8 +160,8 @@ class DeepHash(Base):
     hashes: Dict[Any, Any]
     exclude_types_tuple: Tuple[type, ...]
     ignore_repetition: bool
-    exclude_paths: Optional[Set[str]]
-    include_paths: Optional[Set[str]]
+    exclude_paths: Optional[SetOrdered]
+    include_paths: Optional[SetOrdered]
     exclude_regex_paths: Optional[List[re.Pattern[str]]]
     hasher: Callable[[Union[str, bytes]], str]
     use_enum_value: bool

deepdiff/delta.py

@@ -167,7 +167,7 @@ def _deserializer(obj, safe_to_import=None):
         self.reset()
 
     def __repr__(self):
-        return "<Delta: {}>".format(summarize(self.diff, max_length=100))
+        return "<Delta: {}>".format(summarize(self.diff, max_length=100))  # type: ignore[arg-type]
 
     def reset(self):
         self.post_process_paths_to_convert = dict_()
@@ -289,7 +289,7 @@ def _simple_set_elem_value(self, obj, path_for_err_reporting, elem=None, value=N
                 except IndexError:
                     if elem == len(obj):
                         obj.append(value)
-                    elif self.fill is not not_found and elem > len(obj):
+                    elif self.fill is not not_found and elem is not None and elem > len(obj):
                         while len(obj) < elem:
                             if callable(self.fill):
                                 obj.append(self.fill(obj, value, path_for_err_reporting))
@@ -334,7 +334,7 @@ def _set_new_value(self, parent, parent_to_obj_elem, parent_to_obj_action,
             # Check if it's a NamedTuple and use _replace() to generate a new copy with the change
             if hasattr(obj, '_fields') and hasattr(obj, '_replace'):
                 if action == GETATTR:
-                    obj = obj._replace(**{elem: new_value})
+                    obj = obj._replace(**{elem: new_value})  # type: ignore[attr-defined]
                     if parent:
                         self._simple_set_elem_value(obj=parent, path_for_err_reporting=path,
                                                     elem=parent_to_obj_elem, value=obj,
@@ -887,7 +887,7 @@ def _get_reverse_diff(self):
                 for path, op_codes in info.items():
                     r_diff[action][path] = []
                     for op_code in op_codes:
-                        tag = op_code.tag
+                        tag: str = op_code.tag
                         tag = {'delete': 'insert', 'insert': 'delete'}.get(tag, tag)
                         new_op_code = Opcode(
                             tag=tag,

deepdiff/diff.py

@@ -638,8 +638,8 @@ def _diff_dict(
         parents_ids: FrozenSet[int]=frozenset([]),
         print_as_attribute: bool=False,
         override: bool=False,
-        override_t1: Optional[Any]=None,
-        override_t2: Optional[Any]=None,
+        override_t1: Any=None,
+        override_t2: Any=None,
         local_tree: Optional[Any]=None,
     ) -> None:
         """Difference of 2 dictionaries"""
@@ -788,14 +788,14 @@ def _diff_iterable(self, level: Any, parents_ids: FrozenSet[int]=frozenset(), _o
 
     def _compare_in_order(
         self, level,
-        t1_from_index=None, t1_to_index=None,
-        t2_from_index=None, t2_to_index=None
+        t1_from_index: Optional[int]=None, t1_to_index: Optional[int]=None,
+        t2_from_index: Optional[int]=None, t2_to_index: Optional[int]=None
     ) -> List[Tuple[Tuple[int, int], Tuple[Any, Any]]]:
         """
         Default compare if `iterable_compare_func` is not provided.
         This will compare in sequence order.
         """
-        if t1_from_index is None:
+        if t1_from_index is None or t2_from_index is None:
             return [((i, i), (x, y)) for i, (x, y) in enumerate(
                 zip_longest(
                     level.t1, level.t2, fillvalue=ListItemRemovedOrAdded))]
@@ -1432,7 +1432,7 @@ def get_other_pair(hash_value, in_t1=True):
                 # When we report repetitions, we want the child_relationship_param2 only if there is no repetition.
                 # Because when there is a repetition, we report it in a different way (iterable_items_added_at_indexes for example).
                 # When there is no repetition, we want child_relationship_param2 so that we report the "new_path" correctly.
-                if other.item is notpresent or len(other.indexes > 1):
+                if other.item is notpresent or len(other.indexes) > 1:
                     index2 = None
                 else:
                     index2 = other.indexes[0]
@@ -1759,7 +1759,7 @@ def _diff(self, level, parents_ids=frozenset(), _original_type=None, local_tree=
             if self.ignore_uuid_types and isinstance(level.t2, uuids):
                 try:
                     # Convert string to UUID for comparison
-                    t1_uuid = uuid.UUID(level.t1)
+                    t1_uuid = uuid.UUID(str(level.t1))
                     if t1_uuid.int != level.t2.int:
                         self._report_result('values_changed', level, local_tree=local_tree)
                 except (ValueError, AttributeError):

deepdiff/distance.py

@@ -107,10 +107,13 @@ def __calculate_item_deephash(self: "DistanceProtocol", item: Any) -> None:
     def _precalculate_distance_by_custom_compare_func(
             self: "DistanceProtocol", hashes_added, hashes_removed, t1_hashtable, t2_hashtable, _original_type):
         pre_calced_distances = dict_()
+        if self.iterable_compare_func is None:
+            return pre_calced_distances
+        compare_func = self.iterable_compare_func
         for added_hash in hashes_added:
             for removed_hash in hashes_removed:
                 try:
-                    is_close_distance = self.iterable_compare_func(t2_hashtable[added_hash].item, t1_hashtable[removed_hash].item)
+                    is_close_distance = compare_func(t2_hashtable[added_hash].item, t1_hashtable[removed_hash].item)
                 except CannotCompare:
                     pass
                 else:
@@ -189,8 +192,8 @@ def _get_item_length(item, parents_ids=frozenset([])):
 
             # 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'):
+            if isinstance(key, str) and (key.startswith('_') or key == 'deep_distance' or key == 'new_path'
+                                         or key == 'old_type' or key == 'old_value'):
                 continue
 
             item_id = id(subitem)
@@ -250,7 +253,7 @@ def _get_numbers_distance(num1, num2, max_=1, use_log_scale=False, log_scale_sim
         return max_  # pragma: no cover
 
 
-def _numpy_div(a, b, replace_inf_with=1):
+def _numpy_div(a, b, replace_inf_with: float=1):
     max_array = np.full(shape=a.shape, fill_value=replace_inf_with, dtype=np_float64)
     result = np.divide(a, b, out=max_array, where=b != 0, dtype=np_float64)
     # wherever 2 numbers are the same, make sure the distance is zero. This is mainly for 0 divided by zero.
@@ -284,15 +287,15 @@ def logarithmic_similarity(a: NumberType, b: NumberType, threshold: float=0.1) -
 
 def logarithmic_distance(a: NumberType, b: NumberType) -> float:
     # Apply logarithm to the absolute values and consider the sign
-    a = float(a)
-    b = float(b)
+    a = float(a)  # type: ignore[arg-type]
+    b = float(b)  # type: ignore[arg-type]
     log_a = math.copysign(math.log(abs(a) + MATH_LOG_OFFSET), a)
     log_b = math.copysign(math.log(abs(b) + MATH_LOG_OFFSET), b)
 
     return abs(log_a - log_b)
 
 
-def _get_numpy_array_distance(num1, num2, max_=1, use_log_scale=False, log_scale_similarity_threshold=0.1):
+def _get_numpy_array_distance(num1, num2, max_: float=1, use_log_scale=False, log_scale_similarity_threshold=0.1):
     """
     Get the distance of 2 numbers. The output is a number between 0 to the max.
     The reason is the

deepdiff/helper.py

@@ -313,7 +313,7 @@ class indexed_set(set):
     """
 
 
-def add_to_frozen_set(parents_ids: FrozenSet[int], item_id: int) -> FrozenSet[int]:
+def add_to_frozen_set(parents_ids: FrozenSet[Any], item_id: Any) -> FrozenSet[Any]:
     return parents_ids | {item_id}
 
 
@@ -386,14 +386,15 @@ def numpy_dtype_string_to_type(dtype_str: str) -> Type[Any]:
     return numpy_dtype_str_to_type[dtype_str]
 
 
-def type_in_type_group(item: Any, type_group: Tuple[Type[Any], ...]) -> bool:
+def type_in_type_group(item: Any, type_group: Iterable[Type[Any]]) -> bool:
     return get_type(item) in type_group
 
 
-def type_is_subclass_of_type_group(item: Any, type_group: Tuple[Type[Any], ...]) -> bool:
-    return isinstance(item, type_group) \
-        or (isinstance(item, type) and issubclass(item, type_group)) \
-        or type_in_type_group(item, type_group)
+def type_is_subclass_of_type_group(item: Any, type_group: Iterable[Type[Any]]) -> bool:
+    type_group_tuple = tuple(type_group)
+    return isinstance(item, type_group_tuple) \
+        or (isinstance(item, type) and issubclass(item, type_group_tuple)) \
+        or type_in_type_group(item, type_group_tuple)
 
 
 def get_doc(doc_filename: str) -> str:

deepdiff/path.py

@@ -158,7 +158,7 @@ def _get_nested_obj_and_force(obj, elements, next_element=None):
             except IndexError:
                 if isinstance(obj, list) and isinstance(elem, int) and elem >= len(obj):
                     obj.extend([None] * (elem - len(obj)))
-                    obj.append(_guess_type(elements, elem, index), next_element)
+                    obj.append(_guess_type(elements, elem, index, next_element))
                     obj = obj[-1]
                     prev_obj = _prev_obj
                 elif isinstance(obj, list) and len(obj) == 0 and prev_elem:
@@ -168,7 +168,7 @@ def _get_nested_obj_and_force(obj, elements, next_element=None):
                     if prev_action == GET:
                         prev_obj[prev_elem] = obj
                     else:
-                        setattr(prev_obj, prev_elem, obj)
+                        setattr(prev_obj, str(prev_elem), obj)
                     obj = obj[elem]
         elif action == GETATTR:
             obj = getattr(obj, elem)

deepdiff/serialization.py

@@ -807,7 +807,7 @@ def _convert_oversized_ints(obj):
         converted = [_convert_oversized_ints(v) for v in obj]
         if hasattr(obj, '_fields'):
             # NamedTuple: reconstruct using keyword arguments
-            return type(obj)(**dict(zip(obj._fields, converted)))
+            return type(obj)(**dict(zip(obj._fields, converted)))  # type: ignore[attr-defined]
         return type(obj)(converted)
     return obj