stopping wrapping of driver exceptions as is maintenance issue

Author: millerjp

src/async_cassandra/session.py

@@ -10,8 +10,25 @@
 import time
 from typing import Any, Dict, Optional
 
-from cassandra import DriverException
+from cassandra import (
+    AlreadyExists,
+    AuthenticationFailed,
+    CDCWriteFailure,
+    CoordinationFailure,
+    FunctionFailure,
+    InvalidRequest,
+    OperationTimedOut,
+    ReadFailure,
+    ReadTimeout,
+    Unauthorized,
+    Unavailable,
+    UnsupportedOperation,
+    WriteFailure,
+    WriteTimeout,
+)
 from cassandra.cluster import _NOT_SET, EXEC_PROFILE_DEFAULT, Cluster, NoHostAvailable, Session
+from cassandra.connection import ConnectionBusy, ConnectionShutdown, ProtocolError
+from cassandra.pool import NoConnectionsAvailable
 from cassandra.protocol import ErrorMessage
 from cassandra.query import BatchStatement, PreparedStatement, SimpleStatement
 
@@ -177,13 +194,37 @@ async def execute(
             return result
 
         except (
-            DriverException,  # Base class for all Cassandra driver exceptions
+            # These exceptions should NOT be wrapped - pass through as-is
+            ReadTimeout,
+            WriteTimeout,
+            OperationTimedOut,
+            Unavailable,
+            InvalidRequest,
+            AlreadyExists,
+            Unauthorized,
+            AuthenticationFailed,
             ErrorMessage,  # Base class for protocol-level errors like SyntaxException
             NoHostAvailable,  # Not a DriverException but should pass through
         ) as e:
-            # Re-raise Cassandra exceptions without wrapping
+            # Re-raise these specific Cassandra exceptions without wrapping
             error_type = type(e).__name__
             raise
+        except (
+            # These exceptions SHOULD be wrapped in QueryError
+            UnsupportedOperation,
+            ReadFailure,
+            WriteFailure,
+            FunctionFailure,
+            CDCWriteFailure,
+            CoordinationFailure,
+            ProtocolError,
+            ConnectionBusy,
+            ConnectionShutdown,
+            NoConnectionsAvailable,
+        ) as e:
+            # Wrap these exceptions in QueryError
+            error_type = type(e).__name__
+            raise QueryError(f"Query execution failed: {str(e)}", cause=e) from e
         except asyncio.TimeoutError:
             # Re-raise timeout errors without wrapping
             error_type = "TimeoutError"
@@ -290,12 +331,40 @@ async def execute_stream(
             return result
 
         except (
-            DriverException,  # Base class for all Cassandra driver exceptions
+            # These exceptions should NOT be wrapped - pass through as-is
+            ReadTimeout,
+            WriteTimeout,
+            OperationTimedOut,
+            Unavailable,
+            InvalidRequest,
+            AlreadyExists,
+            Unauthorized,
+            AuthenticationFailed,
             ErrorMessage,  # Base class for protocol-level errors like SyntaxException
             NoHostAvailable,  # Not a DriverException but should pass through
         ) as e:
-            # Re-raise Cassandra exceptions without wrapping
+            # Re-raise these specific Cassandra exceptions without wrapping
+            error_type = type(e).__name__
+            raise
+        except (
+            # These exceptions SHOULD be wrapped in QueryError
+            UnsupportedOperation,
+            ReadFailure,
+            WriteFailure,
+            FunctionFailure,
+            CDCWriteFailure,
+            CoordinationFailure,
+            ProtocolError,
+            ConnectionBusy,
+            ConnectionShutdown,
+            NoConnectionsAvailable,
+        ) as e:
+            # Wrap these exceptions in QueryError
             error_type = type(e).__name__
+            raise QueryError(f"Streaming query execution failed: {str(e)}", cause=e) from e
+        except asyncio.TimeoutError:
+            # Re-raise timeout errors without wrapping
+            error_type = "TimeoutError"
             raise
         except Exception as e:
             # Only wrap non-Cassandra exceptions
@@ -395,9 +464,34 @@ async def prepare(
             return prepared
         except asyncio.TimeoutError:
             raise
-        except (DriverException, ErrorMessage, NoHostAvailable):
-            # Re-raise Cassandra exceptions without wrapping
+        except (
+            # These exceptions should NOT be wrapped - pass through as-is
+            ReadTimeout,
+            WriteTimeout,
+            OperationTimedOut,
+            Unavailable,
+            InvalidRequest,
+            AlreadyExists,
+            ErrorMessage,  # Base class for protocol-level errors like SyntaxException
+            NoHostAvailable,  # Not a DriverException but should pass through
+        ):
+            # Re-raise these specific Cassandra exceptions without wrapping
             raise
+        except (
+            # These exceptions SHOULD be wrapped in QueryError
+            UnsupportedOperation,
+            ReadFailure,
+            WriteFailure,
+            FunctionFailure,
+            CDCWriteFailure,
+            CoordinationFailure,
+            ProtocolError,
+            ConnectionBusy,
+            ConnectionShutdown,
+            NoConnectionsAvailable,
+        ) as e:
+            # Wrap these exceptions in QueryError
+            raise QueryError(f"Statement preparation failed: {str(e)}", cause=e) from e
         except Exception as e:
             raise QueryError(f"Statement preparation failed: {str(e)}") from e