Format code with Black and isort

- Auto-format all 69 Python files with Black (line length: 120)
- Sort imports with isort (black-compatible profile)
- Ensures code meets repository formatting standards
- Fixes CI code-quality workflow failures

All files now pass black --check and isort --check-only

Author: RonaldRonnie

app/__init__.py

@@ -13,11 +13,12 @@
 # Lazy import to avoid requiring FastAPI when only using models
 try:
     from .api.app import app
+
     _has_fastapi = True
 except ImportError:
     app = None
     _has_fastapi = False
 
 from .utils.config import *
 
-__all__ = ["app"] + [name for name in dir() if not name.startswith('_')] 
+__all__ = ["app"] + [name for name in dir() if not name.startswith("_")]

app/api/__init__.py

@@ -7,4 +7,4 @@
 
 from .app import app
 
-__all__ = ["app"] 
+__all__ = ["app"]

app/api/app.py

@@ -1,25 +1,27 @@
 """FastAPI application for BioAnalyzer backend API."""
-from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from fastapi.exceptions import RequestValidationError
+
 import logging
 import os
 import sys
 import traceback
 
+from fastapi import FastAPI, Request
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+
 sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
 
-from app.api.routers import bugsigdb_analysis, bugsigdb_analysis_v2, system, study_analysis
 from app.api.middleware.rate_limit import RateLimitMiddleware
 from app.api.middleware.request_id import RequestIDMiddleware
+from app.api.routers import bugsigdb_analysis, bugsigdb_analysis_v2, study_analysis, system
 from app.utils.config import (
     CORS_ORIGINS,
     ENABLE_RATE_LIMITING,
-    RATE_LIMIT_PER_MINUTE,
     ENABLE_REQUEST_ID,
     ENVIRONMENT,
-    setup_logging
+    RATE_LIMIT_PER_MINUTE,
+    setup_logging,
 )
 
 setup_logging()
@@ -39,13 +41,10 @@
     tags_metadata=[
         {
             "name": "BugSigDB Analysis",
-            "description": "Core endpoints for analyzing papers for the 6 essential BugSigDB fields."
+            "description": "Core endpoints for analyzing papers for the 6 essential BugSigDB fields.",
         },
-        {
-            "name": "System",
-            "description": "System endpoints for health checks, configuration, and metrics."
-        }
-    ]
+        {"name": "System", "description": "System endpoints for health checks, configuration, and metrics."},
+    ],
 )
 
 app.add_middleware(
@@ -61,18 +60,15 @@
     app.add_middleware(RequestIDMiddleware)
 
 if ENABLE_RATE_LIMITING:
-    app.add_middleware(
-        RateLimitMiddleware,
-        requests_per_minute=RATE_LIMIT_PER_MINUTE,
-        enabled=ENABLE_RATE_LIMITING
-    )
+    app.add_middleware(RateLimitMiddleware, requests_per_minute=RATE_LIMIT_PER_MINUTE, enabled=ENABLE_RATE_LIMITING)
     logger.info(f"Rate limiting enabled: {RATE_LIMIT_PER_MINUTE} requests/minute")
 
 app.include_router(bugsigdb_analysis.router)
 app.include_router(bugsigdb_analysis_v2.router)
 app.include_router(study_analysis.router)
 app.include_router(system.router)
 
+
 @app.get("/")
 async def root():
     """API root endpoint."""
@@ -82,14 +78,15 @@ async def root():
         "description": "AI-powered Curatable Signature analysis API",
         "documentation": "/docs",
         "health_check": "/health",
-        "metrics": "/metrics"
+        "metrics": "/metrics",
     }
 
 
 @app.get("/health")
 async def health_check():
     """Health check endpoint."""
     from app.api.routers.system import health_check as system_health_check
+
     return await system_health_check()
 
 
@@ -102,41 +99,42 @@ async def validation_exception_handler(request: Request, exc: RequestValidationE
         content={
             "error": "Validation Error",
             "detail": exc.errors(),
-            "request_id": getattr(request.state, "request_id", None)
-        }
+            "request_id": getattr(request.state, "request_id", None),
+        },
     )
 
 
 @app.exception_handler(Exception)
 async def global_exception_handler(request: Request, exc: Exception):
     """Handle unexpected exceptions."""
     from app.utils.credential_masking import mask_exception_message, mask_string
-    
+
     # Mask any credentials in exception message and traceback
     safe_exc_msg = mask_exception_message(exc)
     safe_traceback = mask_string(traceback.format_exc())
-    
+
     logger.error(
         f"Unhandled exception: {safe_exc_msg}\n"
         f"Traceback: {safe_traceback}\n"
         f"Request ID: {getattr(request.state, 'request_id', None)}"
     )
-    
+
     if ENVIRONMENT == "production":
         detail = "An internal error occurred. Please try again later."
     else:
         detail = safe_exc_msg
-    
+
     return JSONResponse(
         status_code=500,
         content={
             "error": "Internal Server Error",
             "detail": detail,
-            "request_id": getattr(request.state, "request_id", None)
-        }
+            "request_id": getattr(request.state, "request_id", None),
+        },
     )
 
 
 if __name__ == "__main__":
     import uvicorn
+
     uvicorn.run(app, host="0.0.0.0", port=8000)

app/api/middleware/__init__.py

@@ -1,4 +1,3 @@
 """
 API Middleware for production-ready features.
 """
-

app/api/middleware/rate_limit.py

@@ -1,12 +1,14 @@
 """
 Rate limiting middleware for API endpoints.
 """
+
+import logging
 import time
-from typing import Dict, Optional
 from collections import defaultdict
-from fastapi import Request, HTTPException, status
+from typing import Dict, Optional
+
+from fastapi import HTTPException, Request, status
 from starlette.middleware.base import BaseHTTPMiddleware
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -17,19 +19,14 @@
 class RateLimitMiddleware(BaseHTTPMiddleware):
     """
     Rate limiting middleware to prevent abuse.
-    
+
     Uses sliding window algorithm for rate limiting.
     """
-    
-    def __init__(
-        self,
-        app,
-        requests_per_minute: int = 60,
-        enabled: bool = True
-    ):
+
+    def __init__(self, app, requests_per_minute: int = 60, enabled: bool = True):
         """
         Initialize rate limiting middleware.
-        
+
         Args:
             app: FastAPI application
             requests_per_minute: Maximum requests per minute per IP
@@ -38,79 +35,72 @@ def __init__(
         super().__init__(app)
         self.requests_per_minute = requests_per_minute
         self.enabled = enabled
-    
+
     async def dispatch(self, request: Request, call_next):
         """Process request with rate limiting."""
         if not self.enabled:
             return await call_next(request)
-        
+
         # Skip rate limiting for health checks and docs
         if request.url.path in ["/health", "/docs", "/redoc", "/openapi.json"]:
             return await call_next(request)
-        
+
         # Get client IP
         client_ip = self._get_client_ip(request)
-        
+
         # Check rate limit
         if not self._check_rate_limit(client_ip):
             logger.warning(f"Rate limit exceeded for IP: {client_ip}")
             raise HTTPException(
                 status_code=status.HTTP_429_TOO_MANY_REQUESTS,
-                detail=f"Rate limit exceeded. Maximum {self.requests_per_minute} requests per minute."
+                detail=f"Rate limit exceeded. Maximum {self.requests_per_minute} requests per minute.",
             )
-        
+
         # Process request
         response = await call_next(request)
-        
+
         # Add rate limit headers
         response.headers["X-RateLimit-Limit"] = str(self.requests_per_minute)
-        response.headers["X-RateLimit-Remaining"] = str(
-            self._get_remaining_requests(client_ip)
-        )
-        
+        response.headers["X-RateLimit-Remaining"] = str(self._get_remaining_requests(client_ip))
+
         return response
-    
+
     def _get_client_ip(self, request: Request) -> str:
         """Extract client IP address from request."""
         # Check for forwarded IP (behind proxy)
         forwarded_for = request.headers.get("X-Forwarded-For")
         if forwarded_for:
             return forwarded_for.split(",")[0].strip()
-        
+
         real_ip = request.headers.get("X-Real-IP")
         if real_ip:
             return real_ip
-        
+
         return request.client.host if request.client else "unknown"
-    
+
     def _check_rate_limit(self, client_ip: str) -> bool:
         """Check if client IP is within rate limit."""
         current_time = time.time()
         window_start = current_time - 60  # 1 minute window
-        
+
         # Clean old entries
         requests = _rate_limit_store[client_ip]
-        _rate_limit_store[client_ip] = [
-            req_time for req_time in requests if req_time > window_start
-        ]
-        
+        _rate_limit_store[client_ip] = [req_time for req_time in requests if req_time > window_start]
+
         # Check limit
         if len(_rate_limit_store[client_ip]) >= self.requests_per_minute:
             return False
-        
+
         # Add current request
         _rate_limit_store[client_ip].append(current_time)
         return True
-    
+
     def _get_remaining_requests(self, client_ip: str) -> int:
         """Get remaining requests for client IP."""
         current_time = time.time()
         window_start = current_time - 60
-        
+
         requests = _rate_limit_store[client_ip]
-        valid_requests = [
-            req_time for req_time in requests if req_time > window_start
-        ]
-        
-        return max(0, self.requests_per_minute - len(valid_requests))
+        valid_requests = [req_time for req_time in requests if req_time > window_start]
 
+        return max(0, self.requests_per_minute - len(valid_requests))

app/api/middleware/request_id.py

@@ -1,11 +1,13 @@
 """
 Request ID middleware for request tracking.
 """
+
+import logging
 import uuid
+
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.responses import Response
-import logging
 
 logger = logging.getLogger(__name__)
 
@@ -14,22 +16,21 @@ class RequestIDMiddleware(BaseHTTPMiddleware):
     """
     Middleware to add unique request ID to each request for tracking.
     """
-    
+
     async def dispatch(self, request: Request, call_next):
         """Process request with request ID."""
         # Get or create request ID
         request_id = request.headers.get("X-Request-ID")
         if not request_id:
             request_id = str(uuid.uuid4())
-        
+
         # Add to request state
         request.state.request_id = request_id
-        
+
         # Process request
         response = await call_next(request)
-        
+
         # Add request ID to response headers
         response.headers["X-Request-ID"] = request_id
-        
-        return response
 
+        return response