fix: address remaining review feedback for Cython serializers

- Fix float range check: use cast-to-float + isinf check instead of
  FLT_MAX comparison, matching struct.pack('>f') rounding semantics
  (e.g. 3.4028235e38 now correctly accepted)
- Normalize vector input with tuple() so non-subscriptable iterables
  with __len__ + __iter__ work (matches Python VectorType.serialize)
- Change vector_size from int to Py_ssize_t to prevent overflow
- Fix int32 vector double-indexing: store values[i] in local variable
- Update docstrings to reflect actual behavior
- Add regression tests for float boundary rounding and iterable input

Author: mykaul

cassandra/serializers.pyx

@@ -44,14 +44,19 @@ from cassandra.util import is_little_endian
 # ---------------------------------------------------------------------------
 
 cdef inline void _check_float_range(double value) except *:
-    """Raise OverflowError for finite values outside float32 range.
+    """Raise OverflowError for finite values that overflow float32.
+
+    Uses the same semantics as ``struct.pack('>f', value)``: cast the
+    double to float and reject only if the result is ±inf while the
+    input was finite.  This correctly accepts values slightly above
+    ``FLT_MAX`` that round down (e.g. 3.4028235e38).
 
     Intentionally raises OverflowError (not struct.error) so callers
-    can catch a single exception type. The accepted range matches
-    struct.pack('>f', ...).  inf, -inf, and nan pass through unchanged.
+    can catch a single exception type.  inf, -inf, and nan pass
+    through unchanged.
     """
     if not isinf(value) and not isnan(value):
-        if value > <double>FLT_MAX or value < -<double>FLT_MAX:
+        if isinf(<float>value):
             raise OverflowError(
                 "Value %r too large for float32 (max %r)" % (value, FLT_MAX))
 
@@ -179,7 +184,7 @@ cdef class SerVectorType(Serializer):
     per-element Python serialization.
     """
 
-    cdef int vector_size
+    cdef Py_ssize_t vector_size
     cdef object subtype
     # 0 = generic, 1 = float, 2 = double, 3 = int32
     cdef int type_code
@@ -199,7 +204,11 @@ cdef class SerVectorType(Serializer):
             self.type_code = 0
 
     cpdef bytes serialize(self, object value, int protocol_version):
-        cdef int v_length = len(value)
+        # Normalize to tuple so indexing works for any iterable with __len__.
+        # The Python VectorType.serialize() only requires len() + iteration,
+        # so we must accept the same inputs.
+        value = tuple(value)
+        cdef Py_ssize_t v_length = len(value)
         if v_length != self.vector_size:
             raise ValueError(
                 "Expected sequence of size %d for vector of type %s and "
@@ -219,9 +228,8 @@ cdef class SerVectorType(Serializer):
     cdef inline bytes _serialize_float(self, object values):
         """Serialize a list of floats into a contiguous big-endian buffer.
 
-        Uses ``values[i]`` (``__getitem__``) intentionally rather than
-        iteration so Cython can emit a tight indexed loop with minimal
-        Python overhead.  Callers must pass a sequence (list, tuple, etc.).
+        ``values`` is already a tuple (normalized in ``serialize()``), so
+        indexing is always safe and fast.
         """
         cdef Py_ssize_t i
         cdef Py_ssize_t buf_size = self.vector_size * 4
@@ -255,9 +263,8 @@ cdef class SerVectorType(Serializer):
     cdef inline bytes _serialize_double(self, object values):
         """Serialize a list of doubles into a contiguous big-endian buffer.
 
-        Uses ``values[i]`` (``__getitem__``) intentionally rather than
-        iteration so Cython can emit a tight indexed loop with minimal
-        Python overhead.  Callers must pass a sequence (list, tuple, etc.).
+        ``values`` is already a tuple (normalized in ``serialize()``), so
+        indexing is always safe and fast.
         """
         cdef Py_ssize_t i
         cdef Py_ssize_t buf_size = self.vector_size * 8
@@ -292,9 +299,8 @@ cdef class SerVectorType(Serializer):
     cdef inline bytes _serialize_int32(self, object values):
         """Serialize a list of int32 values into a contiguous big-endian buffer.
 
-        Uses ``values[i]`` (``__getitem__``) intentionally rather than
-        iteration so Cython can emit a tight indexed loop with minimal
-        Python overhead.  Callers must pass a sequence (list, tuple, etc.).
+        ``values`` is already a tuple (normalized in ``serialize()``), so
+        indexing is always safe and fast.
         """
         cdef Py_ssize_t i
         cdef Py_ssize_t buf_size = self.vector_size * 4
@@ -304,12 +310,14 @@ cdef class SerVectorType(Serializer):
         cdef object result = PyBytes_FromStringAndSize(NULL, buf_size)
         cdef char *buf = PyBytes_AS_STRING(result)
         cdef int32_t val
+        cdef object item
         cdef char *src
         cdef char *dst
 
         for i in range(self.vector_size):
-            _check_int32_range(values[i])
-            val = <int32_t>values[i]
+            item = values[i]
+            _check_int32_range(item)
+            val = <int32_t>item
             src = <char *>&val
             dst = buf + i * 4
 

tests/unit/test_serializers.py

@@ -107,6 +107,16 @@ def test_flt_max(self):
         self._assert_equiv(flt_max)
         self._assert_equiv(-flt_max)
 
+    def test_flt_max_rounding_boundary(self):
+        """Values slightly above FLT_MAX that round down should be accepted.
+
+        3.4028235e38 is above FLT_MAX (3.4028234663852886e38) but
+        struct.pack('>f', 3.4028235e38) rounds it down to FLT_MAX.
+        The Cython serializer must accept the same inputs.
+        """
+        self._assert_equiv(3.4028235e38)
+        self._assert_equiv(-3.4028235e38)
+
     def test_subnormal_values(self):
         """Subnormal (denormalized) floats should serialize correctly."""
         self._assert_equiv(1e-45)
@@ -451,6 +461,63 @@ def test_int32_vector_round_trip(self):
         self.assertEqual(list(deserialized), values)
 
 
+@cythontest
+class TestSerVectorTypeIterableInput(unittest.TestCase):
+    """Verify vector serializer accepts non-subscriptable iterables.
+
+    The Python VectorType.serialize() only requires len() + iteration,
+    so the Cython path must accept the same inputs after normalization.
+    """
+
+    def test_iterable_with_len_no_getitem(self):
+        """A custom iterable with __len__ + __iter__ but no __getitem__."""
+
+        class IterableOnly:
+            def __init__(self, data):
+                self._data = list(data)
+
+            def __len__(self):
+                return len(self._data)
+
+            def __iter__(self):
+                return iter(self._data)
+
+        vec_type = _make_vector_type(FloatType, 3)
+        ser = SerVectorType(vec_type)
+        values = IterableOnly([1.0, 2.0, 3.0])
+        cython_bytes = ser.serialize(values, PROTO)
+        python_bytes = vec_type.serialize([1.0, 2.0, 3.0], PROTO)
+        self.assertEqual(cython_bytes, python_bytes)
+
+    def test_iterable_int32_vector(self):
+        """Non-subscriptable iterable with int32 fast-path."""
+
+        class IterableOnly:
+            def __init__(self, data):
+                self._data = list(data)
+
+            def __len__(self):
+                return len(self._data)
+
+            def __iter__(self):
+                return iter(self._data)
+
+        vec_type = _make_vector_type(Int32Type, 3)
+        ser = SerVectorType(vec_type)
+        values = IterableOnly([1, 2, 3])
+        cython_bytes = ser.serialize(values, PROTO)
+        python_bytes = vec_type.serialize([1, 2, 3], PROTO)
+        self.assertEqual(cython_bytes, python_bytes)
+
+    def test_tuple_input(self):
+        """Tuple input should work (already subscriptable, but verify)."""
+        vec_type = _make_vector_type(Int32Type, 3)
+        ser = SerVectorType(vec_type)
+        cython_bytes = ser.serialize((1, 2, 3), PROTO)
+        python_bytes = vec_type.serialize([1, 2, 3], PROTO)
+        self.assertEqual(cython_bytes, python_bytes)
+
+
 # ---------------------------------------------------------------------------
 # Factory function tests
 # ---------------------------------------------------------------------------