fix: address review feedback for Cython serializers

- Guard find_serializer() against un-parameterized VectorType base class
  that would crash _is_float_type(None) with TypeError
- Fix assertAlmostEqual(inf, inf) test bug (inf - inf = nan fails)
- Wrap test serializer import in try/except for graceful skip when .so
  is missing under VERIFY_CYTHON
- Change make_serializers() to return obj_array (Cython typed memoryview)
  matching make_deserializers() convention
- Eliminate double values[i] indexing in _serialize_float vector loop
- Remove unused ctypes import in test_flt_max

Author: mykaul

cassandra/serializers.pyx

@@ -31,6 +31,7 @@ from libc.string cimport memcpy
 from libc.math cimport isinf, isnan
 from libc.float cimport FLT_MAX
 from cpython.bytes cimport PyBytes_FromStringAndSize, PyBytes_AS_STRING
+from cython.view cimport array as cython_array
 
 from cassandra import cqltypes
 
@@ -229,13 +230,15 @@ cdef class SerVectorType(Serializer):
 
         cdef object result = PyBytes_FromStringAndSize(NULL, buf_size)
         cdef char *buf = PyBytes_AS_STRING(result)
+        cdef double dval
         cdef float val
         cdef char *src
         cdef char *dst
 
         for i in range(self.vector_size):
-            _check_float_range(<double>values[i])
-            val = <float>values[i]
+            dval = <double>values[i]
+            _check_float_range(dval)
+            val = <float>dval
             src = <char *>&val
             dst = buf + i * 4
 
@@ -361,9 +364,12 @@ cdef dict _ser_classes = {}
 cpdef Serializer find_serializer(cqltype):
     """Find a serializer for a cqltype."""
 
-    # For VectorType, always use SerVectorType (it handles generic subtypes internally)
+    # For VectorType, use SerVectorType only if parameterized (has a valid subtype).
+    # Un-parameterized VectorType (base class) would crash _is_float_type() etc.
     if issubclass(cqltype, cqltypes.VectorType):
-        return SerVectorType(cqltype)
+        if getattr(cqltype, 'subtype', None) is not None:
+            return SerVectorType(cqltype)
+        return GenericSerializer(cqltype)
 
     # For scalar types with dedicated serializers, look up by name
     name = 'Ser' + cqltype.__name__
@@ -376,8 +382,29 @@ cpdef Serializer find_serializer(cqltype):
 
 
 def make_serializers(cqltypes_list):
-    """Create a list of Serializer objects for each given cqltype."""
-    return [find_serializer(ct) for ct in cqltypes_list]
+    """Create a Cython typed array of Serializer objects for each given cqltype.
+
+    Returns an ``obj_array`` (Cython typed memoryview) matching the
+    ``make_deserializers()`` convention for O(1) C-level indexed access.
+    """
+    return obj_array([find_serializer(ct) for ct in cqltypes_list])
+
+
+def obj_array(list objs):
+    """Create a (Cython) array of objects given a list of objects.
+
+    Mirrors ``deserializers.obj_array()`` so both sides share the same
+    typed-memoryview convention.  Returns the plain list for empty input
+    since ``cython_array`` does not support zero-length shapes.
+    """
+    if not objs:
+        return objs
+    cdef object[:] arr
+    cdef Py_ssize_t i
+    arr = cython_array(shape=(len(objs),), itemsize=sizeof(void *), format="O")
+    for i, obj in enumerate(objs):
+        arr[i] = obj
+    return arr
 
 
 # Build the lookup dict for scalar serializers at module load time

tests/unit/test_serializers.py

@@ -19,6 +19,7 @@
 implementations, plus correct error behavior for edge cases.
 """
 
+import math
 import struct
 import unittest
 
@@ -39,18 +40,23 @@
     BooleanType,
 )
 
-# Import serializers only if Cython is available
+# Import serializers only if Cython is available (compiled .so present)
 if HAVE_CYTHON or VERIFY_CYTHON:
-    from cassandra.serializers import (
-        Serializer,
-        SerFloatType,
-        SerDoubleType,
-        SerInt32Type,
-        SerVectorType,
-        GenericSerializer,
-        find_serializer,
-        make_serializers,
-    )
+    try:
+        from cassandra.serializers import (
+            Serializer,
+            SerFloatType,
+            SerDoubleType,
+            SerInt32Type,
+            SerVectorType,
+            GenericSerializer,
+            find_serializer,
+            make_serializers,
+        )
+    except ImportError:
+        # .so not built — fall back so @cythontest skips gracefully
+        HAVE_CYTHON = False
+        VERIFY_CYTHON = False
 
 cythontest = unittest.skipUnless(
     HAVE_CYTHON or VERIFY_CYTHON, "Cython is not available"
@@ -97,8 +103,6 @@ def test_negative_values(self):
             self._assert_equiv(val)
 
     def test_flt_max(self):
-        import ctypes
-
         flt_max = 3.4028234663852886e38
         self._assert_equiv(flt_max)
         self._assert_equiv(-flt_max)
@@ -410,7 +414,10 @@ def test_float_round_trip(self):
         for val in [0.0, 1.0, -1.0, 3.14, float("inf"), float("-inf")]:
             serialized = ser.serialize(val, PROTO)
             deserialized = FloatType.deserialize(serialized, PROTO)
-            self.assertAlmostEqual(val, deserialized, places=5)
+            if math.isinf(val):
+                self.assertEqual(val, deserialized)
+            else:
+                self.assertAlmostEqual(val, deserialized, places=5)
 
     def test_double_round_trip(self):
         ser = SerDoubleType(DoubleType)
@@ -481,6 +488,11 @@ def test_generic_delegates_to_python(self):
         expected = LongType.serialize(42, PROTO)
         self.assertEqual(result, expected)
 
+    def test_unparameterized_vector_type_gets_generic(self):
+        """Un-parameterized VectorType (base class) should not crash."""
+        ser = find_serializer(VectorType)
+        self.assertIsInstance(ser, GenericSerializer)
+
 
 @cythontest
 class TestMakeSerializers(unittest.TestCase):
@@ -497,7 +509,7 @@ def test_basic(self):
 
     def test_empty(self):
         serializers = make_serializers([])
-        self.assertEqual(serializers, [])
+        self.assertEqual(len(serializers), 0)
 
     def test_with_vector_type(self):
         vec_type = _make_vector_type(FloatType, 3)