linting issue fixed

Signed-off-by: Nikhil Suri <[email protected]>

Author: nikhilsuri-db

src/databricks/sql/common/unified_http_client.py

@@ -264,25 +264,22 @@ def request_context(
             yield response
         except MaxRetryError as e:
             logger.error("HTTP request failed after retries: %s", e)
-            
+
             # Try to extract HTTP status code from the MaxRetryError
             http_code = None
-            if hasattr(e, 'reason') and hasattr(e.reason, 'response'):
+            if hasattr(e, "reason") and hasattr(e.reason, "response"):
                 # The reason may contain a response object with status
-                http_code = getattr(e.reason.response, 'status', None)
-            elif hasattr(e, 'response') and hasattr(e.response, 'status'):
+                http_code = getattr(e.reason.response, "status", None)
+            elif hasattr(e, "response") and hasattr(e.response, "status"):
                 # Or the error itself may have a response
                 http_code = e.response.status
-            
+
             context = {}
             if http_code is not None:
                 context["http-code"] = http_code
                 logger.error("HTTP request failed with status code: %d", http_code)
-            
-            raise RequestError(
-                f"HTTP request failed: {e}",
-                context=context
-            )
+
+            raise RequestError(f"HTTP request failed: {e}", context=context)
         except Exception as e:
             logger.error("HTTP request error: %s", e)
             raise RequestError(f"HTTP request error: {e}")

src/databricks/sql/exc.py

@@ -131,4 +131,5 @@ class CursorAlreadyClosedError(RequestError):
 class TelemetryRateLimitError(Exception):
     """Raised when telemetry endpoint returns 429 or 503, indicating rate limiting or service unavailable.
     This exception is used exclusively by the circuit breaker to track telemetry rate limiting events."""
+
     pass

src/databricks/sql/telemetry/circuit_breaker_manager.py

@@ -181,7 +181,6 @@ def _create_noop_circuit_breaker(cls) -> CircuitBreaker:
         return breaker
 
 
-
 def is_circuit_breaker_error(exception: Exception) -> bool:
     """
     Check if an exception is a circuit breaker error.

src/databricks/sql/telemetry/telemetry_client.py

@@ -274,7 +274,7 @@ def _send_telemetry(self, events):
     def _send_with_unified_client(self, url, data, headers, timeout=900):
         """
         Helper method to send telemetry using the telemetry push client.
-        
+
         The push client implementation handles circuit breaker logic internally,
         so this method just forwards the request and handles any errors generically.
         """

src/databricks/sql/telemetry/telemetry_push_client.py

@@ -36,7 +36,7 @@ def request(
         method: HttpMethod,
         url: str,
         headers: Optional[Dict[str, str]] = None,
-        **kwargs
+        **kwargs,
     ) -> BaseHTTPResponse:
         """Make an HTTP request."""
         pass
@@ -60,7 +60,7 @@ def request(
         method: HttpMethod,
         url: str,
         headers: Optional[Dict[str, str]] = None,
-        **kwargs
+        **kwargs,
     ) -> BaseHTTPResponse:
         """Make an HTTP request using the underlying HTTP client."""
         return self._http_client.request(method, url, headers, **kwargs)
@@ -91,10 +91,11 @@ def __init__(self, delegate: ITelemetryPushClient, host: str):
     def _create_mock_success_response(self) -> BaseHTTPResponse:
         """
         Create a mock success response for when circuit breaker is open.
-        
+
         This allows telemetry to fail silently without raising exceptions.
         """
         from unittest.mock import Mock
+
         mock_response = Mock(spec=BaseHTTPResponse)
         mock_response.status = 200
         mock_response.data = b'{"numProtoSuccess": 0, "errors": []}'
@@ -105,77 +106,81 @@ def request(
         method: HttpMethod,
         url: str,
         headers: Optional[Dict[str, str]] = None,
-        **kwargs
+        **kwargs,
     ) -> BaseHTTPResponse:
         """
         Make an HTTP request with circuit breaker protection.
-        
+
         Circuit breaker only opens for 429/503 responses (rate limiting).
         If circuit breaker is open, silently drops the telemetry request.
         Other errors fail silently without triggering circuit breaker.
         """
-        
+
         def _make_request_and_check_status():
             """
             Inner function that makes the request and checks response status.
-            
+
             Raises TelemetryRateLimitError ONLY for 429/503 so circuit breaker counts them as failures.
             For all other errors, returns mock success response so circuit breaker does NOT count them.
-            
+
             This ensures circuit breaker only opens for rate limiting, not for network errors,
             timeouts, or server errors.
             """
             try:
                 response = self._delegate.request(method, url, headers, **kwargs)
-                
+
                 # Check for rate limiting or service unavailable in successful response
                 # (case where urllib3 returns response without exhausting retries)
                 if response.status in [429, 503]:
                     logger.warning(
                         "Telemetry endpoint returned %d for host %s, triggering circuit breaker",
                         response.status,
-                        self._host
+                        self._host,
                     )
                     raise TelemetryRateLimitError(
                         f"Telemetry endpoint rate limited or unavailable: {response.status}"
                     )
-                
+
                 return response
-                
+
             except Exception as e:
                 # Don't catch TelemetryRateLimitError - let it propagate to circuit breaker
                 if isinstance(e, TelemetryRateLimitError):
                     raise
-                
+
                 # Check if it's a RequestError with rate limiting status code (exhausted retries)
                 if isinstance(e, RequestError):
-                    http_code = e.context.get("http-code") if hasattr(e, "context") and e.context else None
-                    
+                    http_code = (
+                        e.context.get("http-code")
+                        if hasattr(e, "context") and e.context
+                        else None
+                    )
+
                     if http_code in [429, 503]:
                         logger.warning(
                             "Telemetry retries exhausted with status %d for host %s, triggering circuit breaker",
                             http_code,
-                            self._host
+                            self._host,
                         )
                         raise TelemetryRateLimitError(
                             f"Telemetry rate limited after retries: {http_code}"
                         )
-                
+
                 # NOT rate limiting (500 errors, network errors, timeouts, etc.)
                 # Return mock success response so circuit breaker does NOT see this as a failure
                 logger.debug(
                     "Non-rate-limit telemetry error for host %s: %s, failing silently",
                     self._host,
-                    e
+                    e,
                 )
                 return self._create_mock_success_response()
-        
+
         try:
             # Use circuit breaker to protect the request
             # The inner function will raise TelemetryRateLimitError for 429/503
             # which the circuit breaker will count as a failure
             return self._circuit_breaker.call(_make_request_and_check_status)
-            
+
         except Exception as e:
             # All telemetry errors are consumed and return mock success
             # Log appropriate message based on exception type
@@ -188,10 +193,13 @@ def _make_request_and_check_status():
                 logger.debug(
                     "Telemetry rate limited for host %s (already counted by circuit breaker): %s",
                     self._host,
-                    e
+                    e,
                 )
             else:
-                logger.debug("Unexpected telemetry error for host %s: %s, failing silently", self._host, e)
-            
-            return self._create_mock_success_response()
+                logger.debug(
+                    "Unexpected telemetry error for host %s: %s, failing silently",
+                    self._host,
+                    e,
+                )
 
+            return self._create_mock_success_response()