Refactored ruff rules

Author: IgorChvyrov-sm

pyproject.toml

@@ -137,12 +137,6 @@ ignore = [
     "PLR2004",
     # PLR0915: Too many statements (generated code has large functions)
     "PLR0915",
-    # G004: Logging statement uses f-string (acceptable for performance)
-    "G004",
-    # B904: Within an `except` clause, raise exceptions with `raise ... from err`
-    "B904",
-    # RUF012: Mutable class attributes should be annotated with `typing.ClassVar` (generated code)
-    "RUF012",
     # PLW1641: Object does not implement `__hash__` method (generated code)
     "PLW1641",
     # PYI063: Use PEP 570 syntax for positional-only parameters (backward compatibility)

src/conductor/client/adapters/models/bulk_response_adapter.py

@@ -1,14 +1,15 @@
+from typing import ClassVar, Dict
 from conductor.client.codegen.models import BulkResponse
 
 
 class BulkResponseAdapter(BulkResponse):
-    swagger_types = {
+    swagger_types: ClassVar[Dict[str, str]] = {
         "bulk_error_results": "dict(str, str)",
         "bulk_successful_results": "list[str]",
         "message": "str",
     }
 
-    attribute_map = {
+    attribute_map: ClassVar[Dict[str, str]] = {
         "bulk_error_results": "bulkErrorResults",
         "bulk_successful_results": "bulkSuccessfulResults",
         "message": "message",

src/conductor/client/adapters/models/health.py

@@ -1,3 +1,4 @@
+from typing import ClassVar, Dict
 import pprint
 import re  # noqa: F401
 
@@ -17,13 +18,13 @@ class Health(object):
       attribute_map (dict): The key is attribute name
                             and the value is json key in definition.
     """
-    swagger_types = {
+    swagger_types: ClassVar[Dict[str, str]] = {
         "details": "dict(str, object)",
         "error_message": "str",
         "healthy": "bool",
     }
 
-    attribute_map = {
+    attribute_map: ClassVar[Dict[str, str]] = {
         "details": "details",
         "error_message": "errorMessage",
         "healthy": "healthy",

src/conductor/client/adapters/models/health_check_status.py

@@ -1,3 +1,4 @@
+from typing import ClassVar, Dict
 import pprint
 
 import six
@@ -16,13 +17,13 @@ class HealthCheckStatus(object):
       attribute_map (dict): The key is attribute name
                             and the value is json key in definition.
     """
-    swagger_types = {
+    swagger_types: ClassVar[Dict[str, str]] = {
         "health_results": "list[Health]",
         "suppressed_health_results": "list[Health]",
         "healthy": "bool",
     }
 
-    attribute_map = {
+    attribute_map: ClassVar[Dict[str, str]] = {
         "health_results": "healthResults",
         "suppressed_health_results": "suppressedHealthResults",
         "healthy": "healthy",

src/conductor/client/adapters/models/integration_def_api_adapter.py

@@ -1,3 +1,4 @@
+from typing import ClassVar, Dict
 import pprint
 
 import six
@@ -12,15 +13,15 @@ class IntegrationDefApi(object):  # Model from v5.2.6 spec
                             and the value is json key in definition.
     """
 
-    swagger_types = {
+    swagger_types: ClassVar[Dict[str, str]] = {
         "api": "str",
         "description": "str",
         "input_schema": "SchemaDef",
         "integration_type": "str",
         "output_schema": "SchemaDef",
     }
 
-    attribute_map = {
+    attribute_map: ClassVar[Dict[str, str]] = {
         "api": "api",
         "description": "description",
         "input_schema": "inputSchema",

src/conductor/client/adapters/models/state_change_event_adapter.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Dict, List, Union, Optional
+from typing import ClassVar, Dict, List, Union, Optional
 
 from typing_extensions import Self
 
@@ -17,9 +17,9 @@ class StateChangeEventType(Enum):
 
 
 class StateChangeConfig:
-    swagger_types = {"type": "str", "events": "list[StateChangeEvent]"}
+    swagger_types: ClassVar[Dict[str, str]] = {"type": "str", "events": "list[StateChangeEvent]"}
 
-    attribute_map = {"type": "type", "events": "events"}
+    attribute_map: ClassVar[Dict[str, str]] = {"type": "type", "events": "events"}
 
     # Keep original init for backward compatibility
     def __init__(

src/conductor/client/adapters/models/task_result_adapter.py

@@ -15,10 +15,10 @@ def status(self, status):
         if isinstance(status, str):
             try:
                 status = TaskResultStatus(status)
-            except ValueError:
+            except ValueError as e:
                 raise ValueError(
                     f"Invalid value for `status` ({status}), must be one of {[e.value for e in TaskResultStatus]}"
-                )
+                ) from e
         elif not isinstance(status, TaskResultStatus):
             raise TypeError(f"status must be a TaskStatus enum or string, got {type(status)}")
 

src/conductor/client/adapters/rest_adapter.py

@@ -28,15 +28,7 @@ def __init__(self, response: Response):
 
         # Log HTTP protocol version
         http_version = getattr(response, "http_version", "Unknown")
-        logger.debug(f"HTTP response received - Status: {self.status}, Protocol: {http_version}")
-
-        # Log HTTP/2 usage
-        if http_version == "HTTP/2":
-            logger.info(f"HTTP/2 connection established - URL: {response.url}")
-        elif http_version == "HTTP/1.1":
-            logger.debug(f"HTTP/1.1 connection used - URL: {response.url}")
-        else:
-            logger.debug(f"HTTP protocol version: {http_version} - URL: {response.url}")
+        logger.debug("HTTP response received - Status: %s, Protocol: %s", self.status, http_version)
 
     def getheaders(self):
         """Get response headers."""
@@ -123,18 +115,12 @@ def close(self):
     def check_http2_support(self, url: str) -> bool:
         """Check if the server supports HTTP/2 by making a test request."""
         try:
-            logger.info(f"Checking HTTP/2 support for: {url}")
             response = self.GET(url)
             is_http2 = response.is_http2()
 
-            if is_http2:
-                logger.info(f"✓ HTTP/2 supported by {url}")
-            else:
-                logger.info(f"✗ HTTP/2 not supported by {url}, using {response.http_version}")
-
             return is_http2
         except Exception as e:
-            logger.error(f"Failed to check HTTP/2 support for {url}: {e}")
+            logger.error("Failed to check HTTP/2 support for %s: %s", url, e)
             return False
 
     def request(
@@ -185,7 +171,7 @@ def request(
 
         try:
             # Log the request attempt
-            logger.debug(f"Making HTTP request - Method: {method}, URL: {url}")
+            logger.debug("Making HTTP request - Method: %s, URL: %s", method, url)
             # Prepare request parameters
             request_kwargs = {
                 "method": method,