Address review feedback: fix bugs, imports, and documentation

- Fix NotImplemented -> NotImplementedError in test_types.py (was raising
  the singleton constant instead of the exception class)
- Remove unused DoubleType import in unit/test_types.py
- Replace fragile sys.path.insert(0, '.') with __file__-relative path
  resolution in vector_deserialize.py
- Fix ShortType test data truncation: use modulo instead of clamping
  vector length to avoid producing fewer elements than vector_size
- Add forward-looking note to DesVectorType variable-size subtype test
- Expand Cython benchmark docstring to explain skip behavior

Author: mykaul

benchmarks/vector_deserialize.py

@@ -25,15 +25,22 @@
 Run with: python benchmarks/vector_deserialize.py
 """
 
+import os
 import sys
 import time
 import struct
 
-# Add parent directory to path
-sys.path.insert(0, '.')
+# Add project root to path so the benchmark can be run from any directory
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
 
 from cassandra.cqltypes import FloatType, DoubleType, Int32Type, LongType, ShortType
-from cassandra.marshal import float_pack, double_pack, int32_pack, int64_pack, int16_pack
+from cassandra.marshal import (
+    float_pack,
+    double_pack,
+    int32_pack,
+    int64_pack,
+    int16_pack,
+)
 
 
 def create_test_data(vector_size, element_type):
@@ -51,13 +58,13 @@ def create_test_data(vector_size, element_type):
         values = list(range(vector_size))
         pack_fn = int64_pack
     elif element_type == ShortType:
-        values = list(range(min(vector_size, 32767)))
+        values = [i % 32767 for i in range(vector_size)]
         pack_fn = int16_pack
     else:
         raise ValueError(f"Unsupported element type: {element_type}")
 
     # Serialize the vector
-    serialized = b''.join(pack_fn(v) for v in values)
+    serialized = b"".join(pack_fn(v) for v in values)
 
     return serialized, values
 
@@ -83,16 +90,26 @@ def benchmark_struct_optimization(vector_type, serialized_data, iterations=10000
     subtype = vector_type.subtype
 
     # Determine format string - subtype is a class, use identity or issubclass
-    if subtype is FloatType or (isinstance(subtype, type) and issubclass(subtype, FloatType)):
-        format_str = f'>{vector_size}f'
-    elif subtype is DoubleType or (isinstance(subtype, type) and issubclass(subtype, DoubleType)):
-        format_str = f'>{vector_size}d'
-    elif subtype is Int32Type or (isinstance(subtype, type) and issubclass(subtype, Int32Type)):
-        format_str = f'>{vector_size}i'
-    elif subtype is LongType or (isinstance(subtype, type) and issubclass(subtype, LongType)):
-        format_str = f'>{vector_size}q'
-    elif subtype is ShortType or (isinstance(subtype, type) and issubclass(subtype, ShortType)):
-        format_str = f'>{vector_size}h'
+    if subtype is FloatType or (
+        isinstance(subtype, type) and issubclass(subtype, FloatType)
+    ):
+        format_str = f">{vector_size}f"
+    elif subtype is DoubleType or (
+        isinstance(subtype, type) and issubclass(subtype, DoubleType)
+    ):
+        format_str = f">{vector_size}d"
+    elif subtype is Int32Type or (
+        isinstance(subtype, type) and issubclass(subtype, Int32Type)
+    ):
+        format_str = f">{vector_size}i"
+    elif subtype is LongType or (
+        isinstance(subtype, type) and issubclass(subtype, LongType)
+    ):
+        format_str = f">{vector_size}q"
+    elif subtype is ShortType or (
+        isinstance(subtype, type) and issubclass(subtype, ShortType)
+    ):
+        format_str = f">{vector_size}h"
     else:
         return None, None, None
 
@@ -118,16 +135,26 @@ def benchmark_numpy_optimization(vector_type, serialized_data, iterations=10000)
     subtype = vector_type.subtype
 
     # Determine dtype
-    if subtype is FloatType or (isinstance(subtype, type) and issubclass(subtype, FloatType)):
-        dtype = '>f4'
-    elif subtype is DoubleType or (isinstance(subtype, type) and issubclass(subtype, DoubleType)):
-        dtype = '>f8'
-    elif subtype is Int32Type or (isinstance(subtype, type) and issubclass(subtype, Int32Type)):
-        dtype = '>i4'
-    elif subtype is LongType or (isinstance(subtype, type) and issubclass(subtype, LongType)):
-        dtype = '>i8'
-    elif subtype is ShortType or (isinstance(subtype, type) and issubclass(subtype, ShortType)):
-        dtype = '>i2'
+    if subtype is FloatType or (
+        isinstance(subtype, type) and issubclass(subtype, FloatType)
+    ):
+        dtype = ">f4"
+    elif subtype is DoubleType or (
+        isinstance(subtype, type) and issubclass(subtype, DoubleType)
+    ):
+        dtype = ">f8"
+    elif subtype is Int32Type or (
+        isinstance(subtype, type) and issubclass(subtype, Int32Type)
+    ):
+        dtype = ">i4"
+    elif subtype is LongType or (
+        isinstance(subtype, type) and issubclass(subtype, LongType)
+    ):
+        dtype = ">i8"
+    elif subtype is ShortType or (
+        isinstance(subtype, type) and issubclass(subtype, ShortType)
+    ):
+        dtype = ">i2"
     else:
         return None, None, None
 
@@ -144,7 +171,12 @@ def benchmark_numpy_optimization(vector_type, serialized_data, iterations=10000)
 
 
 def benchmark_cython_deserializer(vector_type, serialized_data, iterations=10000):
-    """Benchmark Cython DesVectorType deserializer."""
+    """Benchmark Cython DesVectorType deserializer.
+
+    This benchmark requires the Cython deserializers extension to be compiled.
+    When the extension is not available, or the type does not have a dedicated
+    DesVectorType deserializer, the benchmark is silently skipped (returns None).
+    """
     try:
         from cassandra.deserializers import find_deserializer
     except ImportError:
@@ -156,7 +188,7 @@ def benchmark_cython_deserializer(vector_type, serialized_data, iterations=10000
     deserializer = find_deserializer(vector_type)
 
     # Check if we got the Cython deserializer
-    if deserializer.__class__.__name__ != 'DesVectorType':
+    if deserializer.__class__.__name__ != "DesVectorType":
         return None, None, None
 
     start = time.perf_counter()
@@ -193,15 +225,18 @@ def verify_results(expected, *results):
 
 def run_benchmark_suite(vector_size, element_type, type_name, iterations=10000):
     """Run complete benchmark suite for a given vector configuration."""
-    print(f"\n{'='*80}")
+    print(f"\n{'=' * 80}")
     print(f"Benchmark: Vector<{type_name}, {vector_size}>")
-    print(f"{'='*80}")
+    print(f"{'=' * 80}")
     print(f"Iterations: {iterations:,}")
 
     # Create test data
     from cassandra.cqltypes import lookup_casstype
-    cass_typename = f'org.apache.cassandra.db.marshal.{element_type.__name__}'
-    vector_typename = f'org.apache.cassandra.db.marshal.VectorType({cass_typename}, {vector_size})'
+
+    cass_typename = f"org.apache.cassandra.db.marshal.{element_type.__name__}"
+    vector_typename = (
+        f"org.apache.cassandra.db.marshal.VectorType({cass_typename}, {vector_size})"
+    )
     vector_type = lookup_casstype(vector_typename)
 
     serialized_data, expected_values = create_test_data(vector_size, element_type)
@@ -216,41 +251,51 @@ def run_benchmark_suite(vector_size, element_type, type_name, iterations=10000):
     # 1. Current implementation (baseline)
     print("1. Current implementation (baseline)...")
     elapsed, per_op, result_current = benchmark_current_implementation(
-        vector_type, serialized_data, iterations)
+        vector_type, serialized_data, iterations
+    )
     results.append(result_current)
     print(f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs")
     baseline_time = per_op
 
     # 2. Struct optimization
     print("2. Python struct.unpack optimization...")
     elapsed, per_op, result_struct = benchmark_struct_optimization(
-        vector_type, serialized_data, iterations)
+        vector_type, serialized_data, iterations
+    )
     results.append(result_struct)
     if per_op is not None:
         speedup = baseline_time / per_op
-        print(f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs, Speedup: {speedup:.2f}x")
+        print(
+            f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs, Speedup: {speedup:.2f}x"
+        )
     else:
         print("   Not applicable for this type")
 
     # 3. Numpy with tolist()
     print("3. Numpy frombuffer + tolist()...")
     elapsed, per_op, result_numpy = benchmark_numpy_optimization(
-        vector_type, serialized_data, iterations)
+        vector_type, serialized_data, iterations
+    )
     results.append(result_numpy)
     if per_op is not None:
         speedup = baseline_time / per_op
-        print(f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs, Speedup: {speedup:.2f}x")
+        print(
+            f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs, Speedup: {speedup:.2f}x"
+        )
     else:
         print("   Numpy not available")
 
     # 4. Cython deserializer
     print("4. Cython DesVectorType deserializer...")
     elapsed, per_op, result_cython = benchmark_cython_deserializer(
-        vector_type, serialized_data, iterations)
+        vector_type, serialized_data, iterations
+    )
     if per_op is not None:
         results.append(result_cython)
         speedup = baseline_time / per_op
-        print(f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs, Speedup: {speedup:.2f}x")
+        print(
+            f"   Total: {elapsed:.4f}s, Per-op: {per_op:.2f} μs, Speedup: {speedup:.2f}x"
+        )
     else:
         print("   Cython deserializers not available")
 
@@ -269,30 +314,28 @@ def main():
     # Pin to single CPU core for consistent measurements
     try:
         import os
+
         os.sched_setaffinity(0, {0})  # Pin to CPU core 0
         print("Pinned to CPU core 0 for consistent measurements")
     except (AttributeError, OSError) as e:
         print(f"Could not pin to single core: {e}")
         print("Running without CPU affinity...")
 
-    print("="*80)
+    print("=" * 80)
     print("VectorType Deserialization Performance Benchmark")
-    print("="*80)
+    print("=" * 80)
 
     # Test configurations: (vector_size, element_type, type_name, iterations)
     test_configs = [
         # Small vectors
         (3, FloatType, "float", 50000),
         (4, FloatType, "float", 50000),
-
         # Medium vectors (common in ML)
         (128, FloatType, "float", 10000),
         (384, FloatType, "float", 10000),
-
         # Large vectors (embeddings)
         (768, FloatType, "float", 5000),
         (1536, FloatType, "float", 2000),
-
         # Other types (smaller iteration counts)
         (128, DoubleType, "double", 10000),
         (768, DoubleType, "double", 5000),
@@ -308,16 +351,16 @@ def main():
         summary.append((f"Vector<{type_name}, {vector_size}>", baseline))
 
     # Print summary
-    print("\n" + "="*80)
+    print("\n" + "=" * 80)
     print("SUMMARY - Current Implementation Performance")
-    print("="*80)
+    print("=" * 80)
     for config, baseline_time in summary:
         print(f"{config:30s}: {baseline_time:8.2f} μs")
 
-    print("\n" + "="*80)
+    print("\n" + "=" * 80)
     print("Benchmark complete!")
-    print("="*80)
+    print("=" * 80)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()

tests/integration/standard/test_types.py

@@ -723,7 +723,7 @@ def test_can_insert_tuples_all_collection_datatypes(self):
 
         # make sure we're testing all non primitive data types in the future
         if set(COLLECTION_TYPES) != set(["tuple", "list", "map", "set"]):
-            raise NotImplemented(
+            raise NotImplementedError(
                 "Missing datatype not implemented: {}".format(
                     set(COLLECTION_TYPES) - set(["tuple", "list", "map", "set"])
                 )

tests/unit/test_types.py

@@ -747,6 +747,10 @@ def test_vector_cython_deserializer_variable_size_subtype(self):
         and should raise ValueError from DesVectorType._deserialize_generic.
         The pure Python VectorType.deserialize handles these correctly.
 
+        Note: This test is forward-looking — it validates the Cython deserializer
+        that is introduced in a companion PR.  The skipTest guards below ensure
+        the test is silently skipped when the extension is not yet compiled.
+
         @since 3.x
         @expected_result Cython deserializer raises ValueError for variable-size subtypes;
                          pure Python path correctly deserializes them
@@ -787,7 +791,6 @@ def test_vector_numpy_large_deserialization(self):
         @test_category data_types:vector
         """
         import struct
-        from cassandra.cqltypes import DoubleType
 
         vector_size = 64  # >= 32 threshold for numpy path