Problem: _convert_oversized_ints treated NamedTuples as plain tuples, calling

  type(obj)(converted_list) to reconstruct them. This fails because NamedTuple constructors require
  positional arguments matching their field definitions, not a single list.

  Solution: Before reconstructing a tuple subclass, check for the _fields attribute (the NamedTuple
  marker). If present, reconstruct via type(obj)(**dict(zip(obj._fields, converted))) so each field
  is passed by keyword. Plain tuples and lists continue to use the original path.

Author: seperman

README.md

@@ -23,6 +23,9 @@ Tested on Python 3.9+ and PyPy3.
 
 Please check the [ChangeLog](CHANGELOG.md) file for the detailed information.
 
+DeepDiff 8-7-0
+- support for python 3.14
+
 DeepDiff 8-6-1
 - Patched security vulnerability in the Delta class which was vulnerable to class pollution via its constructor, and when combined with a gadget available in DeltaDiff itself, it could lead to Denial of Service and Remote Code Execution (via insecure Pickle deserialization).
 

deepdiff/serialization.py

@@ -751,6 +751,9 @@ def _convert_oversized_ints(obj):
         return {k: _convert_oversized_ints(v) for k, v in obj.items()}
     if isinstance(obj, (list, tuple)):
         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)(converted)
     return obj
 

tests/test_serialization.py

@@ -577,6 +577,49 @@ def test_json_dumps_large_negative_int(self):
         back = json_loads(serialized)
         assert back['value'] == str(large_neg_int)
 
+    def test_json_dumps_namedtuple_with_large_int(self):
+        """Test that a NamedTuple containing an oversized int is properly serialized.
+        _convert_oversized_ints must reconstruct the NamedTuple via _fields, not
+        pass a flat list to its constructor (which fails for NamedTuples with
+        required keyword arguments)."""
+        large_int = 59579472846392086780
+        stats = SomeStats(
+            counter=Counter(["a", "b"]),
+            context_aware_counter=Counter(),
+            min_int=0,
+            max_int=large_int,
+        )
+        data = {'stats': stats}
+        serialized = json_dumps(data)
+        back = json_loads(serialized)
+        assert back['stats']['max_int'] == str(large_int)
+        assert back['stats']['min_int'] == 0
+
+    def test_json_dumps_dict_of_namedtuples_with_large_int(self):
+        """Test a dict of NamedTuples where one contains an oversized int.
+        This mirrors the real-world pattern of field stats keyed by column name."""
+        large_int = 59579472846392086780
+        stats_map = {
+            'normal_field': SomeStats(counter=Counter(["x"]), max_int=10),
+            'big_field': SomeStats(counter=Counter(["y"]), max_int=large_int),
+        }
+        serialized = json_dumps(stats_map)
+        back = json_loads(serialized)
+        assert back['normal_field']['max_int'] == 10
+        assert back['big_field']['max_int'] == str(large_int)
+
+    def test_json_dumps_namedtuple_with_large_int_in_list(self):
+        """Test a list of NamedTuples where one has an oversized int."""
+        large_int = 59579472846392086780
+        data = [
+            SomeStats(counter=Counter(), max_int=5),
+            SomeStats(counter=Counter(), max_int=large_int),
+        ]
+        serialized = json_dumps(data)
+        back = json_loads(serialized)
+        assert back[0]['max_int'] == 5
+        assert back[1]['max_int'] == str(large_int)
+
     def test_bytes_in_deepdiff_serialization(self):
         """Test that bytes work correctly in DeepDiff JSON serialization"""
         t1 = {