Update app.py

app.py

@@ -4,7 +4,7 @@ import json
 import tempfile
 import shutil
 from pathlib import Path
-from typing import Dict, Any, Tuple, List
+from typing import Dict, Any, Tuple, List, Generator
 from dotenv import load_dotenv
 
 # Import all the analyzer modules
@@ -20,111 +20,79 @@ from prompt_analyzer import create_handler
 load_dotenv()
 
 class StyleAnalyzerApp:
-    """Modern Gradio application for GitHub code style analysis"""
-    
     def __init__(self):
-        """Initialize the application with temporary directory and handler"""
         self.temp_dir = tempfile.mkdtemp()
         self.handler = create_handler()
         
     def cleanup(self):
-        """Clean up temporary files on application shutdown"""
         if os.path.exists(self.temp_dir):
             shutil.rmtree(self.temp_dir)
 
-    async def process_upload(self, 
+    def process_analysis(self, user_path: Path, sources_to_analyze: List[str]) -> Tuple[str, Dict]:
+        """Perform the main analysis steps"""
+        sources_data = analyze_repository_structure(sources_to_analyze, user_path)
+        code_style = analyze_code_style(sources_data)
+        temporal_patterns = analyze_temporal_patterns(sources_data, self.report_data)
+        project_preferences = analyze_project_preferences(sources_data)
+        
+        identity_confidence = calculate_identity_confidence(
+            sources_data,
+            code_style,
+            project_preferences,
+            temporal_patterns
+        )
+
+        return {
+            "code_style_metrics": code_style,
+            "temporal_patterns": temporal_patterns,
+            "project_preferences": project_preferences,
+            "identity_confidence": identity_confidence,
+        }
+
+    def process_files(self, 
                      files: List[gr.File],
                      username: str,
                      github_token: str = None,
                      gemini_key: str = None) -> Tuple[str, Dict]:
-        """
-        Process uploaded files and perform analysis asynchronously
-        
-        Args:
-            files: List of uploaded files
-            username: GitHub username
-            github_token: Optional GitHub API token
-            gemini_key: Optional Google Gemini API key
-            
-        Returns:
-            Tuple containing status message and analysis results
-        """
-        
-        # Set environment variables if provided
-        gemini_key="AIzaSyBHtQa-YQwhlDGihbyUUlS2MiclnXxiN8E" 
-        github_token="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"
+        """Process uploaded files and run analysis"""
+        try:
+            # Set environment variables if provided
+            gemini_key="AIzaSyBHtQa-YQwhlDGihbyUUlS2MiclnXxiN8E" 
+            github_token="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"
 
-        # Create user directory
-        user_path = Path(self.temp_dir) / username
-        user_path.mkdir(parents=True, exist_ok=True)
+            # Create user directory
+            user_path = Path(self.temp_dir) / username
+            user_path.mkdir(parents=True, exist_ok=True)
 
-        # Process uploaded files
-        report_data = None
-        try:
+            # Process uploaded files
+            report_data = None
             for file in files:
                 file_path = file.name
                 if file_path.endswith('report.json'):
                     with open(file_path, 'r') as f:
                         report_data = json.load(f)
-                        # Save to user directory
                         with open(user_path / 'report.json', 'w') as out_f:
                             json.dump(report_data, out_f)
                 else:
-                    # Copy other files to user directory
                     shutil.copy2(file_path, user_path)
 
             if not report_data:
-                return gr.update(value="Error: No report.json file found in uploads"), None
+                return "Error: No report.json file found in uploads", None
 
-            # Initialize repository selector
+            self.report_data = report_data
             repo_selector = RepositorySelector(self.temp_dir, username)
             sources_to_analyze = repo_selector.select_repositories(report_data)
-
-            # Update status
-            yield gr.update(value="Analyzing repository structure..."), None
-
-            # Analyze repository structure
-            sources_data = analyze_repository_structure(sources_to_analyze, user_path)
-
-            # Perform analyses with status updates
-            yield gr.update(value="Analyzing code style patterns..."), None
-            code_style = analyze_code_style(sources_data)
-
-            yield gr.update(value="Analyzing temporal patterns..."), None
-            temporal_patterns = analyze_temporal_patterns(sources_data, report_data)
-
-            yield gr.update(value="Analyzing project preferences..."), None
-            project_preferences = analyze_project_preferences(sources_data)
             
-            yield gr.update(value="Calculating identity confidence..."), None
-            identity_confidence = calculate_identity_confidence(
-                sources_data,
-                code_style,
-                project_preferences,
-                temporal_patterns
-            )
-
-            # Combine results
-            analysis_results = {
-                "code_style_metrics": code_style,
-                "temporal_patterns": temporal_patterns,
-                "project_preferences": project_preferences,
-                "identity_confidence": identity_confidence,
-            }
-
-            yield gr.update(value="Analysis completed successfully!"), analysis_results
+            analysis_results = self.process_analysis(user_path, sources_to_analyze)
+            return "Analysis completed successfully!", analysis_results
 
         except Exception as e:
-            yield gr.update(value=f"Error during analysis: {str(e)}"), None
+            return f"Error during analysis: {str(e)}", None
 
     def create_interface(self) -> gr.Blocks:
-        """Create the Gradio interface with modern styling and features"""
-        
-        # Custom CSS for better styling
+        """Create the Gradio interface"""
         css = """
-        .gradio-container {
-            font-family: 'Helvetica Neue', Arial, sans-serif;
-        }
+        .gradio-container { font-family: 'Helvetica Neue', Arial, sans-serif; }
         .analyze-btn {
             background-color: #2196F3;
             color: white;
@@ -133,9 +101,7 @@ class StyleAnalyzerApp:
             border-radius: 5px;
             cursor: pointer;
         }
-        .analyze-btn:hover {
-            background-color: #1976D2;
-        }
+        .analyze-btn:hover { background-color: #1976D2; }
         """
         
         with gr.Blocks(css=css, theme=gr.themes.Base()) as interface:
@@ -143,12 +109,6 @@ class StyleAnalyzerApp:
             # GitHub Stylometry Analyzer
             
             Analyze coding patterns and style from GitHub repositories.
-            
-            ## Instructions
-            1. Enter your GitHub username
-            2. Upload your repository files including report.json
-            3. Optionally provide API tokens for enhanced analysis
-            4. Click Analyze to begin
             """)
 
             with gr.Group():
@@ -156,35 +116,30 @@ class StyleAnalyzerApp:
                     with gr.Column(scale=1):
                         username = gr.Textbox(
                             label="GitHub Username",
-                            placeholder="Enter your GitHub username",
-                            scale=2
+                            placeholder="Enter your GitHub username"
                         )
                         
                         with gr.Accordion("API Configuration", open=False):
                             github_token = gr.Textbox(
                                 label="GitHub Token", 
                                 placeholder="Your GitHub API token",
-                                type="password",
-                                show_label=True
+                                type="password"
                             )
                             gemini_key = gr.Textbox(
                                 label="Google Gemini API Key",
                                 placeholder="Your Gemini API key",
-                                type="password",
-                                show_label=True
+                                type="password"
                             )
                         
                         files = gr.File(
                             label="Upload Repository Files",
                             file_count="multiple",
-                            file_types=[".json", ".git", ".zip"],
-                            scale=2
+                            file_types=[".json", ".git", ".zip"]
                         )
                         
                         analyze_btn = gr.Button(
                             "Start Analysis",
-                            elem_classes=["analyze-btn"],
-                            variant="primary"
+                            elem_classes=["analyze-btn"]
                         )
 
                     with gr.Column(scale=1):
@@ -197,46 +152,24 @@ class StyleAnalyzerApp:
                             interactive=False
                         )
 
-            # Event handlers
             analyze_btn.click(
-                fn=self.process_upload,
+                fn=self.process_files,
                 inputs=[files, username, github_token, gemini_key],
-                outputs=[status, results],
-                api_name="analyze"
+                outputs=[status, results]
             )
 
-            # Example usage section
-            with gr.Accordion("Example Usage", open=False):
-                gr.Markdown("""
-                ### Example Repository Analysis
-                
-                1. Export your GitHub repository data using gh-analyze
-                2. Upload the generated report.json and repository files
-                3. The analyzer will process:
-                   - Code style patterns
-                   - Temporal commit patterns
-                   - Project preferences
-                   - Developer identity confidence
-                
-                Results include detailed metrics and analysis across multiple dimensions.
-                """)
-
         return interface
 
 def main():
-    """Main application entry point"""
     app = StyleAnalyzerApp()
     interface = app.create_interface()
     
     try:
-        # Launch with modern Gradio configurations
-        interface.queue(max_size=5).launch(
+        interface.queue().launch(
             server_name="0.0.0.0",
             server_port=7860,
             share=True,
-            show_error=True,
-            favicon_path="favicon.ico",
-            auth=None,  # Add authentication if needed
+            show_error=True
         )
     finally:
         app.cleanup()