Merge pull request #26 from eifrach/add_linter

NO-ISSUE: adding linter and test linter to build flow

Author: eifrach

.github/workflows/python-lint.yaml

@@ -0,0 +1,20 @@
+name: python-lint
+on:
+  pull_request:
+    branches:
+      - "*"
+jobs:
+  build:
+    name: python Lint
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
+
+      - name: Run flake8
+        run: uv sync && uv run flake8 src/ --max-line-length=120 --ignore=E501,W503
+        with:
+          python-version: "3.11"

pyproject.toml

@@ -21,4 +21,6 @@ build-backend = "hatchling.build"
 packages = ["src"]
 
 [tool.uv]
-dev-dependencies = [] 
+dev-dependencies = [
+    "flake8>=7.3.0",
+] 

src/config.py

@@ -30,7 +30,8 @@
 
 # Check if Prometheus is available
 try:
-    from prometheus_client import Counter, Histogram, Gauge, CONTENT_TYPE_LATEST, generate_latest
+    # These imports are used in metrics.py
+    from prometheus_client import Counter, Histogram, Gauge, CONTENT_TYPE_LATEST, generate_latest  # noqa: F401
     PROMETHEUS_AVAILABLE = True
 except ImportError:
-    PROMETHEUS_AVAILABLE = False 
+    PROMETHEUS_AVAILABLE = False

src/database.py

@@ -1,23 +1,21 @@
-import os
 import json
-import re
 import time
 import logging
 from typing import Any, List, Dict, Optional
 
 import httpx
 
 from config import (
-    MCP_TRANSPORT, 
-    SNOWFLAKE_BASE_URL, 
-    SNOWFLAKE_DATABASE, 
+    SNOWFLAKE_BASE_URL,
+    SNOWFLAKE_DATABASE,
     SNOWFLAKE_SCHEMA,
     SNOWFLAKE_TOKEN
 )
 from metrics import track_snowflake_query
 
 logger = logging.getLogger(__name__)
 
+
 def sanitize_sql_value(value: str) -> str:
     """Sanitize a SQL value to prevent injection attacks"""
     if not isinstance(value, str):
@@ -26,37 +24,38 @@ def sanitize_sql_value(value: str) -> str:
     # For string values, we'll escape single quotes by doubling them
     return value.replace("'", "''")
 
+
 async def make_snowflake_request(
-    endpoint: str, 
-    method: str = "POST", 
+    endpoint: str,
+    method: str = "POST",
     data: dict[str, Any] = None,
     snowflake_token: Optional[str] = None
 ) -> dict[str, Any] | None:
     """Make a request to Snowflake API"""
     # Use provided token or fall back to config
     token = snowflake_token or SNOWFLAKE_TOKEN
-    
+
     if not token:
         logger.error("SNOWFLAKE_TOKEN environment variable is required but not set")
         return None
-        
+
     headers = {
         "Authorization": f"Bearer {token}",
         "Accept": "application/json",
         "Content-Type": "application/json"
     }
-    
+
     url = f"{SNOWFLAKE_BASE_URL}/{endpoint}"
-    
+
     try:
         async with httpx.AsyncClient(timeout=30.0) as client:
             if method.upper() == "GET":
                 response = await client.request(method, url, headers=headers, params=data)
             else:
                 response = await client.request(method, url, headers=headers, json=data)
-            
+
             response.raise_for_status()
-            
+
             # Try to parse JSON, but handle cases where response is not valid JSON
             try:
                 return response.json()
@@ -65,19 +64,20 @@ async def make_snowflake_request(
                 logger.error(f"Response content: {response.text[:500]}...")  # Log first 500 chars
                 # Return None to indicate error, which will be handled by calling functions
                 return None
-                
+
     except httpx.HTTPStatusError as http_error:
         logger.error(f"HTTP error from Snowflake API: {http_error.response.status_code} - {http_error.response.text}")
         return None
     except Exception as e:
         logger.error(f"Unexpected error in Snowflake API request: {str(e)}")
         return None
 
+
 async def execute_snowflake_query(sql: str, snowflake_token: Optional[str] = None) -> List[Dict[str, Any]]:
     """Execute a SQL query against Snowflake and return results"""
     start_time = time.time()
     success = False
-    
+
     try:
         # Use the statements endpoint to execute SQL
         endpoint = "statements"
@@ -87,16 +87,16 @@ async def execute_snowflake_query(sql: str, snowflake_token: Optional[str] = Non
             "database": SNOWFLAKE_DATABASE,
             "schema": SNOWFLAKE_SCHEMA
         }
-        
+
         logger.info(f"Executing Snowflake query: {sql[:100]}...")  # Log first 100 chars of query
-        
+
         response = await make_snowflake_request(endpoint, "POST", payload, snowflake_token)
-        
+
         # Check if response is None (indicating an error in API request or JSON parsing)
         if response is None:
             logger.error("Failed to get valid response from Snowflake API")
             return []
-        
+
         # Parse the response to extract data
         if response and "data" in response:
             logger.info(f"Successfully got {len(response['data'])} rows from Snowflake")
@@ -109,109 +109,112 @@ async def execute_snowflake_query(sql: str, snowflake_token: Optional[str] = Non
                 logger.info(f"Successfully got {len(result_set['data'])} rows from Snowflake (resultSet format)")
                 success = True
                 return result_set["data"]
-        
+
         logger.warning("No data found in Snowflake response")
         success = True  # No data is still a successful query
         return []
-        
+
     except Exception as e:
         logger.error(f"Error executing Snowflake query: {str(e)}")
         logger.error(f"Query that failed: {sql}")
         return []
     finally:
         track_snowflake_query(start_time, success)
 
+
 def format_snowflake_row(row_data: List[Any], columns: List[str]) -> Dict[str, Any]:
     """Convert Snowflake row data to dictionary using column names"""
     if len(row_data) != len(columns):
         return {}
-    
+
     return {columns[i]: row_data[i] for i in range(len(columns))}
 
+
 async def get_issue_labels(issue_ids: List[str], snowflake_token: Optional[str] = None) -> Dict[str, List[str]]:
     """Get labels for given issue IDs from Snowflake"""
     if not issue_ids:
         return {}
-    
+
     labels_data = {}
-    
+
     try:
         # Sanitize and validate issue IDs (should be numeric)
         sanitized_ids = []
         for issue_id in issue_ids:
             # Ensure issue IDs are numeric to prevent injection
             if isinstance(issue_id, (str, int)) and str(issue_id).isdigit():
                 sanitized_ids.append(str(issue_id))
-        
+
         if not sanitized_ids:
             return {}
-        
+
         # Create comma-separated list for IN clause
         ids_str = "'" + "','".join(sanitized_ids) + "'"
-        
+
         sql = f"""
-        SELECT ISSUE, LABEL 
-        FROM JIRA_LABEL_RHAI 
+        SELECT ISSUE, LABEL
+        FROM JIRA_LABEL_RHAI
         WHERE ISSUE IN ({ids_str}) AND LABEL IS NOT NULL
         """
-        
+
         rows = await execute_snowflake_query(sql, snowflake_token)
         columns = ["ISSUE", "LABEL"]
-        
+
         for row in rows:
             row_dict = format_snowflake_row(row, columns)
             issue_id = str(row_dict.get("ISSUE"))
             label = row_dict.get("LABEL")
-            
+
             if issue_id and label:
                 if issue_id not in labels_data:
                     labels_data[issue_id] = []
                 labels_data[issue_id].append(label)
-    
+
     except Exception as e:
         logger.error(f"Error fetching labels: {str(e)}")
-    
+
     return labels_data
 
+
 async def get_issue_comments(issue_ids: List[str], snowflake_token: Optional[str] = None) -> Dict[str, List[Dict[str, Any]]]:
     """Get comments for given issue IDs from Snowflake"""
     if not issue_ids:
         return {}
-    
+
     comments_data = {}
-    
+
     try:
         # Sanitize and validate issue IDs (should be numeric)
         sanitized_ids = []
         for issue_id in issue_ids:
             # Ensure issue IDs are numeric to prevent injection
             if isinstance(issue_id, (str, int)) and str(issue_id).isdigit():
                 sanitized_ids.append(str(issue_id))
-        
+
         if not sanitized_ids:
             return {}
-        
+
         # Create comma-separated list for IN clause
         ids_str = "'" + "','".join(sanitized_ids) + "'"
-        
+
         sql = f"""
         SELECT ID, ISSUEID, ROLELEVEL, BODY, CREATED, UPDATED
-        FROM JIRA_COMMENT_NON_PII 
+        FROM JIRA_COMMENT_NON_PII
         WHERE ISSUEID IN ({ids_str}) AND BODY IS NOT NULL
         ORDER BY ISSUEID, CREATED ASC
         """
-        
+
         rows = await execute_snowflake_query(sql, snowflake_token)
         columns = ["ID", "ISSUEID", "ROLELEVEL", "BODY", "CREATED", "UPDATED"]
-        
+
         for row in rows:
             row_dict = format_snowflake_row(row, columns)
             issue_id = str(row_dict.get("ISSUEID"))
-            
+
             if issue_id:
                 if issue_id not in comments_data:
                     comments_data[issue_id] = []
-                
+
                 comment = {
                     "id": row_dict.get("ID"),
                     "role_level": row_dict.get("ROLELEVEL"),
@@ -220,8 +223,8 @@ async def get_issue_comments(issue_ids: List[str], snowflake_token: Optional[str
                     "updated": row_dict.get("UPDATED")
                 }
                 comments_data[issue_id].append(comment)
-    
+
     except Exception as e:
         logger.error(f"Error fetching comments: {str(e)}")
-    
-    return comments_data 
+
+    return comments_data

src/mcp_server.py

@@ -17,17 +17,18 @@
 # Get logger
 logger = logging.getLogger(__name__)
 
+
 def main():
     """Main entry point for the MCP server"""
     # Initialize FastMCP server
     mcp = FastMCP("jira-mcp-snowflake")
-    
+
     # Register all tools
     register_tools(mcp)
-    
+
     # Start metrics server in background thread if enabled
     start_metrics_thread()
-    
+
     # Run the MCP server
     try:
         logger.info("Starting JIRA MCP Server for Snowflake")
@@ -42,5 +43,6 @@ def main():
         set_active_connections(0)
         logger.info("MCP server shutdown complete")
 
+
 if __name__ == "__main__":
     main()