fix(python): keep bound nullability when pickling range types

__reduce__ rebuilt both range types from their parameters only, so a
type with non-nullable bounds came back nullable after unpickling.
Rebuild them from the storage type through the C++ Deserialize
instead. This also keeps a type where only one bound is nullable, and
tests cover both cases.

Author: Hoeze

python/pyarrow/includes/libarrow.pxd

@@ -3160,6 +3160,10 @@ cdef extern from "arrow/extension/range.h" namespace "arrow::extension" nogil:
                                             CRangeClosed closed,
                                             c_bool allow_unbounded)
 
+        CResult[shared_ptr[CDataType]] Deserialize(
+            shared_ptr[CDataType] storage_type,
+            const c_string& serialized_data) const
+
         CRangeClosed closed()
         shared_ptr[CDataType] value_type()
 
@@ -3174,6 +3178,10 @@ cdef extern from "arrow/extension/range.h" namespace "arrow::extension" nogil:
         CResult[shared_ptr[CDataType]] Make(shared_ptr[CDataType] value_type,
                                             c_bool allow_unbounded)
 
+        CResult[shared_ptr[CDataType]] Deserialize(
+            shared_ptr[CDataType] storage_type,
+            const c_string& serialized_data) const
+
         shared_ptr[CDataType] value_type()
 
     cdef cppclass CVariableClosednessRangeArray \

python/pyarrow/tests/test_extension_type.py

@@ -2147,7 +2147,7 @@ def test_fixed_closedness_range_type_invalid_closed():
         pa.fixed_closedness_range(pa.int32(), "")
 
 
-def test_fixed_closedness_range_type_allow_unbounded():
+def test_fixed_closedness_range_type_allow_unbounded(pickle_module):
     # Default: bounds are nullable (can represent an unbounded / infinite side).
     nullable = pa.fixed_closedness_range(pa.int32(), "both")
     assert nullable.storage_type.field("lower").nullable
@@ -2163,12 +2163,28 @@ def test_fixed_closedness_range_type_allow_unbounded():
     # Distinct types: storage nullability differs.
     assert finite != nullable
 
+    # Pickling keeps the storage nullability.
+    assert pickle_module.loads(pickle_module.dumps(finite)) == finite
+
     # A non-nullable-bounds range round-trips through its storage.
     storage = pa.array([{"lower": 1, "upper": 5}], finite.storage_type)
     arr = pa.ExtensionArray.from_storage(finite, storage)
     assert arr.type == finite
 
 
+def test_fixed_closedness_range_type_from_storage(pickle_module):
+    # C++ accepts one nullable and one non-nullable bound; pickling keeps it.
+    storage = pa.struct([pa.field("lower", pa.int32(), nullable=True),
+                         pa.field("upper", pa.int32(), nullable=False)])
+    range_type = pa.lib._fixed_closedness_range_from_storage(storage, "right")
+    assert range_type.storage_type == storage
+    assert range_type.closed == "right"
+    assert pickle_module.loads(pickle_module.dumps(range_type)) == range_type
+
+    with pytest.raises(pa.ArrowInvalid, match="must be a Struct"):
+        pa.lib._fixed_closedness_range_from_storage(pa.int32(), "left")
+
+
 @pytest.mark.parametrize("value_type,rows", [
     (pa.int32(), [
         {"lower": 1, "upper": 5, "lower_inc": True, "upper_inc": False},
@@ -2235,7 +2251,7 @@ def test_variable_closedness_range_type(pickle_module, value_type, rows):
     assert inner == storage
 
 
-def test_variable_closedness_range_type_allow_unbounded():
+def test_variable_closedness_range_type_allow_unbounded(pickle_module):
     # Default: bounds are nullable (can represent an unbounded / infinite side).
     nullable = pa.variable_closedness_range(pa.int32())
     assert nullable.storage_type.field("lower").nullable
@@ -2256,6 +2272,9 @@ def test_variable_closedness_range_type_allow_unbounded():
     # Distinct types: storage nullability differs.
     assert finite != nullable
 
+    # Pickling keeps the storage nullability.
+    assert pickle_module.loads(pickle_module.dumps(finite)) == finite
+
     # A variable closedness range with non-nullable bounds round-trips through
     # its storage.
     storage = pa.array(
@@ -2266,6 +2285,20 @@ def test_variable_closedness_range_type_allow_unbounded():
     assert arr.type == finite
 
 
+def test_variable_closedness_range_type_from_storage(pickle_module):
+    # C++ accepts one nullable and one non-nullable bound; pickling keeps it.
+    storage = pa.struct([pa.field("lower", pa.float64(), nullable=False),
+                         pa.field("upper", pa.float64(), nullable=True),
+                         pa.field("lower_inc", pa.bool_(), nullable=False),
+                         pa.field("upper_inc", pa.bool_(), nullable=False)])
+    range_type = pa.lib._variable_closedness_range_from_storage(storage)
+    assert range_type.storage_type == storage
+    assert pickle_module.loads(pickle_module.dumps(range_type)) == range_type
+
+    with pytest.raises(pa.ArrowInvalid, match="must be a Struct"):
+        pa.lib._variable_closedness_range_from_storage(pa.int32())
+
+
 def test_bool8_type(pickle_module):
     bool8_type = pa.bool8()
     storage_type = pa.int8()

python/pyarrow/types.pxi

@@ -2138,7 +2138,10 @@ cdef class FixedClosednessRangeType(BaseExtensionType):
         return FixedClosednessRangeArray
 
     def __reduce__(self):
-        return fixed_closedness_range, (self.value_type, self.closed)
+        # Rebuild from the storage type, which keeps the nullability of each
+        # bound; the value type and closed alone cannot express that.
+        return _fixed_closedness_range_from_storage, (self.storage_type,
+                                                      self.closed)
 
     def __arrow_ext_scalar_class__(self):
         return FixedClosednessRangeScalar
@@ -2183,7 +2186,9 @@ cdef class VariableClosednessRangeType(BaseExtensionType):
         return VariableClosednessRangeArray
 
     def __reduce__(self):
-        return variable_closedness_range, (self.value_type,)
+        # Rebuild from the storage type, which keeps the nullability of each
+        # bound; the value type alone cannot express that.
+        return _variable_closedness_range_from_storage, (self.storage_type,)
 
     def __arrow_ext_scalar_class__(self):
         return VariableClosednessRangeScalar
@@ -5941,6 +5946,36 @@ def variable_closedness_range(DataType value_type not None, allow_unbounded=True
     return out
 
 
+def _fixed_closedness_range_from_storage(DataType storage_type not None,
+                                         str closed not None):
+    """
+    Rebuild a fixed closedness range type from its storage type.
+
+    Used for pickling. The storage type is validated like extension type
+    metadata read from IPC.
+    """
+    cdef:
+        FixedClosednessRangeType prototype = fixed_closedness_range(int32())
+        c_string c_metadata = tobytes(f'{{"closed": "{closed}"}}')
+        shared_ptr[CDataType] c_type = GetResultValue(
+            prototype.range_ext_type.Deserialize(storage_type.sp_type, c_metadata))
+    return pyarrow_wrap_data_type(c_type)
+
+
+def _variable_closedness_range_from_storage(DataType storage_type not None):
+    """
+    Rebuild a variable closedness range type from its storage type.
+
+    Used for pickling. The storage type is validated like extension type
+    metadata read from IPC.
+    """
+    cdef:
+        VariableClosednessRangeType prototype = variable_closedness_range(int32())
+        shared_ptr[CDataType] c_type = GetResultValue(
+            prototype.range_ext_type.Deserialize(storage_type.sp_type, b"{}"))
+    return pyarrow_wrap_data_type(c_type)
+
+
 def opaque(DataType storage_type, str type_name not None, str vendor_name not None):
     """
     Create instance of opaque extension type.