more defensive parsing, allow more method types in urllib3

Signed-off-by: varun-edachali-dbx <varun.edachali@databricks.com>

Author: varun-edachali-dbx

src/databricks/sql/auth/retry.py

@@ -130,8 +130,8 @@ def __init__(
             allowed_methods=["POST"],
             status_forcelist=[429, 503, *self.force_dangerous_codes],
         )
-
-        urllib3_kwargs.update(**_urllib_kwargs_we_care_about)
+        _urllib_kwargs_we_care_about.update(**urllib3_kwargs)
+        urllib3_kwargs = _urllib_kwargs_we_care_about
 
         super().__init__(
             **urllib3_kwargs,

src/databricks/sql/backend/sea/utils/http_client.py

@@ -12,7 +12,12 @@
 from databricks.sql.auth.authenticators import AuthProvider
 from databricks.sql.auth.retry import CommandType, DatabricksRetryPolicy
 from databricks.sql.types import SSLOptions
-from databricks.sql.exc import RequestError, MaxRetryDurationError
+from databricks.sql.exc import (
+    RequestError,
+    MaxRetryDurationError,
+    SessionAlreadyClosedError,
+    CursorAlreadyClosedError,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -264,6 +269,12 @@ def _make_request(
             error_message = f"Request failed due to retry duration limit: {e}"
             # Construct RequestError with message, context, and specific error (like Thrift backend)
             raise RequestError(error_message, None, e)
+        except (SessionAlreadyClosedError, CursorAlreadyClosedError) as e:
+            # These exceptions are raised by DatabricksRetryPolicy when detecting
+            # "already closed" scenarios (404 responses with retry history)
+            error_message = f"Request failed: {e}"
+            # Construct RequestError with proper 3-argument format (message, context, error) like Thrift backend
+            raise RequestError(error_message, None, e)
 
         logger.debug(f"Response status: {response.status}")
 
@@ -282,34 +293,51 @@ def _make_request(
         # Handle error responses
         error_message = f"SEA HTTP request failed with status {response.status}"
 
+        # Try to extract additional error details from response, but don't fail if we can't
+        error_message = self._try_add_error_details_to_message(response, error_message)
+
+        raise RequestError(error_message, None)
+
+    def _try_add_error_details_to_message(self, response, error_message: str) -> str:
+        """
+        Try to extract error details from response and add to error message.
+        This method is defensive and will not raise exceptions if parsing fails.
+        It handles mock objects and malformed responses gracefully.
+        """
         try:
-            if response.data:
+            # Check if response.data exists and is accessible
+            if not hasattr(response, "data") or response.data is None:
+                return error_message
+
+            # Try to decode the response data
+            try:
                 decoded_data = response.data.decode("utf-8")
-                # Ensure we have a string before attempting JSON parsing
-                if isinstance(decoded_data, str):
-                    error_details = json.loads(decoded_data)
-                    if isinstance(error_details, dict) and "message" in error_details:
-                        error_message = f"{error_message}: {error_details['message']}"
-                    logger.error(f"Request failed: {error_details}")
-                else:
-                    # Handle case where decode returns non-string (e.g., MagicMock in tests)
-                    logger.error(
-                        f"Request failed with non-string response data: {type(decoded_data)}"
-                    )
-        except (json.JSONDecodeError, UnicodeDecodeError, TypeError):
-            # Log raw response if we can't parse JSON or if we get unexpected types
+            except (AttributeError, UnicodeDecodeError, TypeError):
+                # response.data might be a mock object or not bytes
+                return error_message
+
+            # Ensure we have a string before attempting JSON parsing
+            if not isinstance(decoded_data, str):
+                return error_message
+
+            # Try to parse as JSON
             try:
-                content = (
-                    response.data.decode("utf-8", errors="replace")
-                    if response.data
-                    else ""
+                error_details = json.loads(decoded_data)
+                if isinstance(error_details, dict) and "message" in error_details:
+                    enhanced_message = f"{error_message}: {error_details['message']}"
+                    logger.error(f"Request failed: {error_details}")
+                    return enhanced_message
+            except json.JSONDecodeError:
+                # Not valid JSON, log what we can
+                logger.debug(
+                    f"Request failed with non-JSON response: {decoded_data[:200]}"
                 )
-                logger.error(f"Request failed with non-JSON response: {content}")
-            except (AttributeError, TypeError):
-                # Handle case where response.data itself might be a mock
-                logger.error(f"Request failed with unparseable response data")
 
-        raise RequestError(error_message, None)
+        except Exception:
+            # Catch-all for any unexpected issues (e.g., mock objects with unexpected behavior)
+            logger.debug("Could not parse error response data")
+
+        return error_message
 
     def _get_command_type_from_path(self, path: str, method: str) -> CommandType:
         """