fix: apply ruff formatting to pass CI linting checks

Author: ascherj

classifier/app.py

@@ -56,35 +56,36 @@
 # Metrics tracking
 class ServiceMetrics:
     """In-memory metrics tracking for observability"""
+
     def __init__(self):
         self.start_time = datetime.now()
         self.issues_processed = 0
         self.openai_api_errors = 0
         self.classification_times_ms = []
-        
+
     def record_issue_processed(self):
         self.issues_processed += 1
-    
+
     def record_openai_error(self):
         self.openai_api_errors += 1
-    
+
     def record_classification_time(self, duration_ms: float):
         self.classification_times_ms.append(duration_ms)
         # Keep only last 1000 measurements
         if len(self.classification_times_ms) > 1000:
             self.classification_times_ms = self.classification_times_ms[-1000:]
-    
+
     def get_percentile(self, percentile: int) -> float:
         """Calculate percentile from classification times"""
         if not self.classification_times_ms:
             return 0.0
         sorted_times = sorted(self.classification_times_ms)
         index = int(len(sorted_times) * percentile / 100)
         return round(sorted_times[min(index, len(sorted_times) - 1)], 2)
-    
+
     def get_uptime_seconds(self) -> int:
         return int((datetime.now() - self.start_time).total_seconds())
-    
+
     def to_dict(self) -> Dict[str, Any]:
         return {
             "service": "classifier",
@@ -98,6 +99,7 @@ def to_dict(self) -> Dict[str, Any]:
             "uptime_seconds": self.get_uptime_seconds(),
         }
 
+
 metrics = ServiceMetrics()
 
 
@@ -309,7 +311,7 @@ async def classify_issue(issue: IssueData):
             confidence=result.confidence,
             processing_time_ms=result.processing_time_ms,
         )
-        
+
         # Record metrics
         metrics.record_issue_processed()
         metrics.record_classification_time(result.processing_time_ms)
@@ -673,9 +675,11 @@ async def process_kafka_message(message):
                 if key == "correlation_id":
                     correlation_id = value.decode("utf-8")
                     break
-        
-        bound_logger = logger.bind(correlation_id=correlation_id) if correlation_id else logger
-        
+
+        bound_logger = (
+            logger.bind(correlation_id=correlation_id) if correlation_id else logger
+        )
+
         # Parse the message
         issue_data = json.loads(message.value.decode("utf-8"))
 
@@ -714,9 +718,12 @@ async def process_kafka_message(message):
         )
 
     except Exception as e:
-        error_correlation_id = correlation_id if 'correlation_id' in locals() else None
+        error_correlation_id = correlation_id if "correlation_id" in locals() else None
         logger.error(
-            "Failed to process Kafka message", error=str(e), message=message.value, correlation_id=error_correlation_id
+            "Failed to process Kafka message",
+            error=str(e),
+            message=message.value,
+            correlation_id=error_correlation_id,
         )
 
 

gateway/app.py

@@ -96,35 +96,36 @@
 # Metrics tracking
 class ServiceMetrics:
     """In-memory metrics tracking for observability"""
+
     def __init__(self):
         self.start_time = datetime.now()
         self.messages_broadcast = 0
         self.api_requests = 0
         self.api_latencies_ms = []
-        
+
     def record_message_broadcast(self):
         self.messages_broadcast += 1
-    
+
     def record_api_request(self):
         self.api_requests += 1
-    
+
     def record_api_latency(self, latency_ms: float):
         self.api_latencies_ms.append(latency_ms)
         # Keep only last 1000 measurements
         if len(self.api_latencies_ms) > 1000:
             self.api_latencies_ms = self.api_latencies_ms[-1000:]
-    
+
     def get_percentile(self, percentile: int) -> float:
         """Calculate percentile from API latencies"""
         if not self.api_latencies_ms:
             return 0.0
         sorted_times = sorted(self.api_latencies_ms)
         index = int(len(sorted_times) * percentile / 100)
         return round(sorted_times[min(index, len(sorted_times) - 1)], 2)
-    
+
     def get_uptime_seconds(self) -> int:
         return int((datetime.now() - self.start_time).total_seconds())
-    
+
     def to_dict(self, active_connections: int) -> Dict[str, Any]:
         return {
             "service": "gateway",
@@ -139,6 +140,7 @@ def to_dict(self, active_connections: int) -> Dict[str, Any]:
             "uptime_seconds": self.get_uptime_seconds(),
         }
 
+
 metrics = ServiceMetrics()
 
 
@@ -499,12 +501,12 @@ async def get_issues(
     try:
         user_id = current_user["sub"]
         is_dev_mode = current_user.get("dev_mode", False)
-        
+
         conn = psycopg2.connect(DATABASE_URL)
         with conn.cursor(cursor_factory=RealDictCursor) as cur:
             where_conditions = []
             params = []
-            
+
             if not is_dev_mode:
                 where_conditions.append(
                     """(
@@ -834,7 +836,7 @@ async def get_stats(current_user: dict = Depends(get_current_user_required)):
     try:
         user_id = current_user["sub"]
         is_dev_mode = current_user.get("dev_mode", False)
-        
+
         conn = psycopg2.connect(DATABASE_URL)
         with conn.cursor(cursor_factory=RealDictCursor) as cur:
             if is_dev_mode:
@@ -1772,8 +1774,10 @@ async def _process_message(self, message):
                     if key == "correlation_id":
                         correlation_id = value.decode("utf-8")
                         break
-            
-            print(f"DEBUG: Processing message from {message.topic}, correlation_id={correlation_id}")
+
+            print(
+                f"DEBUG: Processing message from {message.topic}, correlation_id={correlation_id}"
+            )
 
             event_data = json.loads(message.value.decode("utf-8"))
 
@@ -1831,7 +1835,7 @@ def user_can_see_issue(user: Optional[Dict[str, Any]]) -> bool:
             await self.manager.broadcast(
                 json.dumps(websocket_message), user_filter=user_can_see_issue
             )
-            
+
             # Record metrics
             metrics.record_message_broadcast()
 
@@ -1849,7 +1853,9 @@ def user_can_see_issue(user: Optional[Dict[str, Any]]) -> bool:
             )
 
         except Exception as e:
-            error_correlation_id = correlation_id if 'correlation_id' in locals() else None
+            error_correlation_id = (
+                correlation_id if "correlation_id" in locals() else None
+            )
             logger.error(
                 "Error processing Kafka message",
                 error=str(e),

ingress/app.py

@@ -138,43 +138,44 @@ def _get_client_ip(self, request: Request) -> str:
 # Metrics tracking
 class ServiceMetrics:
     """In-memory metrics tracking for observability"""
+
     def __init__(self):
         self.start_time = time.time()
         self.webhooks_received = 0
         self.webhooks_accepted = 0
         self.webhooks_rejected = 0
         self.kafka_publish_errors = 0
         self.processing_times_ms = []
-        
+
     def record_webhook_received(self):
         self.webhooks_received += 1
-    
+
     def record_webhook_accepted(self):
         self.webhooks_accepted += 1
-    
+
     def record_webhook_rejected(self):
         self.webhooks_rejected += 1
-    
+
     def record_kafka_error(self):
         self.kafka_publish_errors += 1
-    
+
     def record_processing_time(self, duration_ms: float):
         self.processing_times_ms.append(duration_ms)
         # Keep only last 1000 measurements to prevent memory issues
         if len(self.processing_times_ms) > 1000:
             self.processing_times_ms = self.processing_times_ms[-1000:]
-    
+
     def get_percentile(self, percentile: int) -> float:
         """Calculate percentile from processing times"""
         if not self.processing_times_ms:
             return 0.0
         sorted_times = sorted(self.processing_times_ms)
         index = int(len(sorted_times) * percentile / 100)
         return round(sorted_times[min(index, len(sorted_times) - 1)], 2)
-    
+
     def get_uptime_seconds(self) -> int:
         return int(time.time() - self.start_time)
-    
+
     def to_dict(self) -> Dict[str, Any]:
         return {
             "service": "ingress",
@@ -190,6 +191,7 @@ def to_dict(self) -> Dict[str, Any]:
             "uptime_seconds": self.get_uptime_seconds(),
         }
 
+
 metrics = ServiceMetrics()
 
 
@@ -360,7 +362,9 @@ def verify_github_signature(payload_body: bytes, signature_header: str) -> bool:
         return False
 
 
-async def publish_to_kafka(topic: str, key: str, message: dict, correlation_id: Optional[str] = None):
+async def publish_to_kafka(
+    topic: str, key: str, message: dict, correlation_id: Optional[str] = None
+):
     """
     Publish message to Kafka/Redpanda topic with optional correlation ID in headers
     """
@@ -369,7 +373,7 @@ async def publish_to_kafka(topic: str, key: str, message: dict, correlation_id:
         headers = []
         if correlation_id:
             headers.append(("correlation_id", correlation_id.encode("utf-8")))
-        
+
         future = producer.send(topic, key=key, value=message, headers=headers)
         record_metadata = future.get(timeout=10)
 
@@ -383,7 +387,13 @@ async def publish_to_kafka(topic: str, key: str, message: dict, correlation_id:
         )
 
     except Exception as e:
-        logger.error("Failed to publish to Kafka", topic=topic, key=key, correlation_id=correlation_id, error=str(e))
+        logger.error(
+            "Failed to publish to Kafka",
+            topic=topic,
+            key=key,
+            correlation_id=correlation_id,
+            error=str(e),
+        )
         metrics.record_kafka_error()
         raise
 
@@ -412,10 +422,10 @@ async def github_webhook(
     """
     start_time = time.time()
     metrics.record_webhook_received()
-    
+
     try:
         correlation_id = str(uuid.uuid4())
-        
+
         # Get raw body for signature verification
         body = await request.body()
 
@@ -428,7 +438,9 @@ async def github_webhook(
         try:
             payload = json.loads(body.decode("utf-8"))
         except json.JSONDecodeError as e:
-            logger.error("Invalid JSON payload", error=str(e), correlation_id=correlation_id)
+            logger.error(
+                "Invalid JSON payload", error=str(e), correlation_id=correlation_id
+            )
             raise HTTPException(status_code=400, detail="Invalid JSON payload")
 
         # Get event type and validate
@@ -561,7 +573,12 @@ async def github_webhook(
         message_key = f"{event_data['repository']['full_name']}:{event_data['event_type']}:{event_data.get('issue', event_data.get('pull_request', {})).get('number', 'unknown')}"
         print(f"Publishing to Kafka: {message_key}")
 
-        await publish_to_kafka(KAFKA_TOPIC_RAW_ISSUES, message_key, event_data, correlation_id=correlation_id)
+        await publish_to_kafka(
+            KAFKA_TOPIC_RAW_ISSUES,
+            message_key,
+            event_data,
+            correlation_id=correlation_id,
+        )
 
         logger.info(
             "Webhook processed successfully",
@@ -571,7 +588,7 @@ async def github_webhook(
             message_key=message_key,
             correlation_id=correlation_id,
         )
-        
+
         # Record successful processing
         metrics.record_webhook_accepted()
         processing_time_ms = (time.time() - start_time) * 1000