Update app.py

app.py

@@ -137,7 +137,7 @@ class WebhookHandler(BaseHTTPRequestHandler):
 
         event = self.headers.get('X-GitHub-Event')
         delivery_id = self.headers.get('X-GitHub-Delivery')
-        logger.info(f"Received GitHub webhook event: {{}event}}  (Delivery ID: {{delivery_id}})")
+        logger.info(f"Received GitHub webhook event: {{}}event}}  (Delivery ID: {{delivery_id}})")
 
         if event == 'issues' and WebhookHandler.manager_instance and WebhookHandler.main_loop:
             action = payload.get('action')
@@ -168,7 +168,7 @@ class WebhookHandler(BaseHTTPRequestHandler):
 # ========== AI-Powered Issue Manager ==========
 class IssueManager:
     def __init__(self):
-        self.issues: Dict[int, dict] = {{}
+        self.issues: Dict[int, dict] = {{}}
         self.repo_url: Optional[str] = None
         self.repo_owner: Optional[str] = None
         self.repo_name: Optional[str] = None
@@ -176,7 +176,7 @@ class IssueManager:
         self.repo: Optional[Repo] = None
         self.github_token: Optional[str] = None
         self.hf_token: Optional[str] = None
-        self.collaborators: Dict[str, dict] = {{}
+        self.collaborators: Dict[str, dict] = {{}}
         self.points: int = 0
         self.severity_rules: Dict[str, List[str]] = {{
             "Critical": ["critical", "urgent", "security", "crash", "blocker", "p0", "s0"],
@@ -184,21 +184,21 @@ class IssueManager:
             "Medium": ["medium", "bug", "performance", "minor", "p2", "s2"],
             "Low": ["low", "documentation", "enhancement", "trivial", "feature", "p3", "s3", "chore", "refactor", "question", "help wanted"]
         }
-        self.issue_clusters: Dict[int, List[int]] = {{}
+        self.issue_clusters: Dict[int, List[int]] = {{}}
         self.issue_list_for_clustering: List[dict] = []
         self.ws_clients: List[WebSocketServerProtocol] = []
-        self.code_editors: Dict[int, OTCodeEditor] = {{}
+        self.code_editors: Dict[int, OTCodeEditor] = {{}}
         self.main_loop = asyncio.get_event_loop()
         self.broadcast_task: Optional[asyncio.Task] = None
         self.idle_task: Optional[asyncio.Task] = None
 
         # --- State for Idle Processing Results ---
-        self.precomputed_context: Dict[int, Dict[str, Any]] = {{}
-        self.precomputed_summaries: Dict[int, Dict[str, Any]] = {{}
-        self.precomputed_missing_info: Dict[int, Dict[str, Any]] = {{}
-        self.precomputed_analysis: Dict[int, Dict[str, Any]] = {{}
-        self.code_embeddings: Dict[str, List[float]] = {{}
-        self.potential_duplicates: Dict[int, List[int]] = {{}
+        self.precomputed_context: Dict[int, Dict[str, Any]] = {{}}
+        self.precomputed_summaries: Dict[int, Dict[str, Any]] = {{}}
+        self.precomputed_missing_info: Dict[int, Dict[str, Any]] = {{}}
+        self.precomputed_analysis: Dict[int, Dict[str, Any]] = {{}}
+        self.code_embeddings: Dict[str, List[float]] = {{}}
+        self.potential_duplicates: Dict[int, List[int]] = {{}}
         self.stale_issues: List[int] = []
         self.high_priority_candidates: List[int] = []
         self.last_webhook_time: float = 0.0
@@ -368,7 +368,7 @@ class IssueManager:
              empty_fig = go.Figure()
              empty_fig.update_layout(title="Issue Severity Distribution", xaxis={{"visible": False}}, yaxis={{"visible": False}}),
                                annotations=[{{"text": "Scan needed.", "xref": "paper", "yref": "paper", "showarrow": False}}],
-                               plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)')
+                               plot_bgcolor='rgba(0,0,0,0)', paper_bgcolor='rgba(0,0,0,0)'
              return [], empty_fig, "Error: Repository URL and Hugging Face Token are required.", empty_fig
 
         logger.info(f"Starting new issue crawl and setup for {{repo_url}}")
@@ -376,17 +376,17 @@ class IssueManager:
         # --- Reset Manager State ---
         self.stop_idle_processing()
         self.stop_broadcast_loop()
-        self.issues = {{}
-        self.code_editors = {{}
-        self.issue_clusters = {{}
+        self.issues = {{}}
+        self.code_editors = {{}}
+        self.issue_clusters = {{}}
         self.issue_list_for_clustering = []
         self.cached_suggestion.cache_clear()
-        self.precomputed_context = {{}
-        self.precomputed_summaries = {{}
-        self.precomputed_missing_info = {{}
-        self.precomputed_analysis = {{}
-        self.code_embeddings = {{}
-        self.potential_duplicates = {{}
+        self.precomputed_context = {{}}
+        self.precomputed_summaries = {{}}
+        self.precomputed_missing_info = {{}}
+        self.precomputed_analysis = {{}}
+        self.code_embeddings = {{}}
+        self.potential_duplicates = {{}}
         self.stale_issues = []
         self.high_priority_candidates = []
         self.needs_recluster = False
@@ -526,7 +526,7 @@ class IssueManager:
             # --- Prepare Dataframe Output & Stats ---
             dataframe_data = []
             severity_counts = {{"Critical": 0, "High": 0, "Medium": 0, "Low": 0, "Unknown": 0}
-            index_to_cluster_id: Dict[int, int] = {{}
+            index_to_cluster_id: Dict[int, int] = {{}}
             for cluster_id, indices in self.issue_clusters.items():
                 for index in indices:
                     if 0 <= index < len(self.issue_list_for_clustering):
@@ -620,11 +620,11 @@ class IssueManager:
         """Generates embeddings and clusters issues using HDBSCAN. Uses self.issue_list_for_clustering."""
         if not self.issue_list_for_clustering:
             logger.warning("Cannot cluster issues: No issues loaded or list is empty.")
-            self.issue_clusters = {{}
+            self.issue_clusters = {{}}
             return
         if not self.hf_token:
             logger.error("Cannot cluster issues: Hugging Face token missing.")
-            self.issue_clusters = {{}
+            self.issue_clusters = {{}}
             return
 
         num_issues = len(self.issue_list_for_clustering)
@@ -638,14 +638,14 @@ class IssueManager:
 
             if embeddings is None or not isinstance(embeddings, list) or len(embeddings) != num_issues:
                  logger.error(f"Failed to generate valid embeddings for clustering. Expected {{num_issues}, got {{type(embeddings)}} len {{len(embeddings) if embeddings else 'N/A'}.")
-                 self.issue_clusters = {{}
+                 self.issue_clusters = {{}}
                  return
 
             logger.info(f"Generated {{len(embeddings)}}  embeddings. Running HDBSCAN clustering...")
             clusterer = HDBSCAN(min_cluster_size=2, metric='cosine', allow_single_cluster=True, gen_min_span_tree=True)
             clusters = clusterer.fit_predict(embeddings)
 
-            new_issue_clusters: Dict[int, List[int]] = {{}
+            new_issue_clusters: Dict[int, List[int]] = {{}}
             noise_count = 0
             for i, cluster_id in enumerate(clusters):
                 cluster_id_int = int(cluster_id)
@@ -666,16 +666,16 @@ class IssueManager:
 
         except Exception as e:
             logger.exception(f"Error during issue clustering: {{e}}")
-            self.issue_clusters = {{}
+            self.issue_clusters = {{}}
 
     def _identify_potential_duplicates(self):
         """Populates self.potential_duplicates based on self.issue_clusters and self.issue_list_for_clustering."""
-        self.potential_duplicates = {{}
+        self.potential_duplicates = {{}}
         if not self.issue_clusters or not self.issue_list_for_clustering:
             logger.debug("Skipping duplicate identification: No clusters or issue list.")
             return
 
-        index_to_id = {{}
+        index_to_id = {{}}
         try:
             for i, issue in enumerate(self.issue_list_for_clustering):
                 issue_id = issue.get('id')
@@ -1906,7 +1906,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                 }
 
             issue_data = manager.issues[selected_id]
-            files_content: Dict[str, str] = {{}
+            files_content: Dict[str, str] = {{}}
             context_source_msg = "Error determining context source"
             context_load_start = time.time()
 
@@ -2199,7 +2199,7 @@ def create_ui(manager: IssueManager) -> gr.Blocks:
                     function updateCollabList(collaborators) {{
                         const collabListDiv = document.getElementById('collab-list');
                         if (!collabListDiv) return;
-                        const activeCollaborators = Object.entries(collaborators || {{}})
+                        const activeCollaborators = Object.entries(collaborators || {{}}})
                             .filter(([id, info]) => id !== clientId);
                         if (activeCollaborators.length > 0) {{
                             collabListDiv.innerHTML = activeCollaborators