Create app.py

app.py

@@ -0,0 +1,333 @@
+import gradio as gr
+import boto3
+import json
+import os
+from typing import Optional, Tuple
+import nbformat
+from io import StringIO
+import sys
+
+class CodingCopilot:
+    def __init__(self):
+        """Initialize the coding copilot with AWS Bedrock client."""
+        self.setup_aws_client()
+        
+    def setup_aws_client(self):
+        """Setup AWS Bedrock client with credentials from environment variables."""
+        try:
+            self.bedrock_client = boto3.client(
+                'bedrock-runtime',
+                aws_access_key_id=os.getenv('AWS_ACCESS_KEY_ID'),
+                aws_secret_access_key=os.getenv('AWS_SECRET_ACCESS_KEY'),
+                region_name='us-east-1'  # Claude is available in us-east-1
+            )
+        except Exception as e:
+            print(f"Error setting up AWS client: {e}")
+            self.bedrock_client = None
+
+    def call_claude(self, prompt: str, max_tokens: int = 4000) -> str:
+        """Call Claude 3 Haiku via AWS Bedrock."""
+        if not self.bedrock_client:
+            return "Error: AWS Bedrock client not initialized. Please check your credentials."
+        
+        try:
+            # Prepare the request payload for Claude
+            body = {
+                "anthropic_version": "bedrock-2023-05-31",
+                "max_tokens": max_tokens,
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": prompt
+                    }
+                ],
+                "temperature": 0.1,
+                "top_p": 0.9,
+            }
+            
+            response = self.bedrock_client.invoke_model(
+                modelId="anthropic.claude-3-haiku-20240307-v1:0",
+                contentType='application/json',
+                accept='application/json',
+                body=json.dumps(body)
+            )
+            
+            response_body = json.loads(response['body'].read())
+            return response_body['content'][0]['text']
+            
+        except Exception as e:
+            return f"Error calling Claude: {str(e)}"
+
+    def read_python_file(self, file_path: str) -> str:
+        """Read content from a Python file."""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+        except Exception as e:
+            return f"Error reading file: {str(e)}"
+
+    def read_notebook_file(self, file_path: str) -> str:
+        """Read and extract code from a Jupyter notebook file."""
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                nb = nbformat.read(f, as_version=4)
+            
+            code_cells = []
+            for cell in nb.cells:
+                if cell.cell_type == 'code':
+                    code_cells.append(f"# Cell {len(code_cells) + 1}")
+                    code_cells.append(cell.source)
+                    code_cells.append("")  # Add empty line between cells
+            
+            return '\n'.join(code_cells)
+        except Exception as e:
+            return f"Error reading notebook: {str(e)}"
+
+    def analyze_code(self, code_content: str, analysis_type: str) -> str:
+        """Analyze code using Claude."""
+        prompts = {
+            "review": f"""Please review this code and provide:
+1. Code quality assessment
+2. Potential bugs or issues
+3. Performance improvements
+4. Best practices suggestions
+5. Security considerations
+
+Code:
+```python
+{code_content}
+```""",
+            
+            "explain": f"""Please explain this code in detail:
+1. What does this code do?
+2. How does it work?
+3. Key functions and their purposes
+4. Dependencies and requirements
+5. Usage examples
+
+Code:
+```python
+{code_content}
+```""",
+            
+            "optimize": f"""Please optimize this code:
+1. Suggest performance improvements
+2. Refactor for better readability
+3. Reduce complexity where possible
+4. Improve memory usage
+5. Provide the optimized version
+
+Code:
+```python
+{code_content}
+```""",
+            
+            "debug": f"""Please help debug this code:
+1. Identify potential bugs
+2. Suggest fixes
+3. Add error handling
+4. Improve robustness
+5. Provide corrected version
+
+Code:
+```python
+{code_content}
+```""",
+            
+            "document": f"""Please add comprehensive documentation to this code:
+1. Add docstrings to functions/classes
+2. Add inline comments
+3. Create usage examples
+4. Document parameters and return values
+5. Add type hints where appropriate
+
+Code:
+```python
+{code_content}
+```"""
+        }
+        
+        prompt = prompts.get(analysis_type, prompts["review"])
+        return self.call_claude(prompt)
+
+    def generate_code(self, description: str, language: str = "python") -> str:
+        """Generate code based on description."""
+        prompt = f"""Please generate {language} code based on this description:
+
+{description}
+
+Requirements:
+1. Write clean, well-documented code
+2. Include error handling
+3. Add type hints where appropriate
+4. Provide usage examples
+5. Follow best practices
+
+Please provide only the code with comments."""
+        
+        return self.call_claude(prompt)
+
+    def chat_with_code(self, code_content: str, question: str) -> str:
+        """Chat about specific code."""
+        prompt = f"""Given this code:
+
+```python
+{code_content}
+```
+
+Question: {question}
+
+Please provide a detailed answer about the code."""
+        
+        return self.call_claude(prompt)
+
+# Initialize the copilot
+copilot = CodingCopilot()
+
+def process_file_upload(file) -> Tuple[str, str]:
+    """Process uploaded file and return content."""
+    if file is None:
+        return "", "No file uploaded"
+    
+    file_path = file.name
+    file_extension = os.path.splitext(file_path)[1].lower()
+    
+    if file_extension == '.py':
+        content = copilot.read_python_file(file_path)
+    elif file_extension == '.ipynb':
+        content = copilot.read_notebook_file(file_path)
+    else:
+        return "", f"Unsupported file type: {file_extension}. Please upload .py or .ipynb files."
+    
+    return content, f"Successfully loaded {file_extension} file"
+
+def analyze_uploaded_code(file, analysis_type):
+    """Analyze uploaded code file."""
+    if file is None:
+        return "Please upload a file first."
+    
+    content, status = process_file_upload(file)
+    if not content or content.startswith("Error"):
+        return status or content
+    
+    return copilot.analyze_code(content, analysis_type)
+
+def generate_new_code(description, language):
+    """Generate new code based on description."""
+    if not description.strip():
+        return "Please provide a description of what you want to generate."
+    
+    return copilot.generate_code(description, language)
+
+def chat_about_code(file, question):
+    """Chat about uploaded code."""
+    if file is None:
+        return "Please upload a file first."
+    
+    if not question.strip():
+        return "Please ask a question about the code."
+    
+    content, status = process_file_upload(file)
+    if not content or content.startswith("Error"):
+        return status or content
+    
+    return copilot.chat_with_code(content, question)
+
+# Create Gradio interface
+with gr.Blocks(title="Coding Copilot", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🤖 Coding Copilot")
+    gr.Markdown("Upload your Python files (.py) or Jupyter notebooks (.ipynb) for analysis, or generate new code!")
+    
+    with gr.Tabs():
+        # File Analysis Tab
+        with gr.TabItem("📁 Analyze Code"):
+            with gr.Row():
+                with gr.Column():
+                    file_input = gr.File(
+                        label="Upload Python File (.py) or Jupyter Notebook (.ipynb)",
+                        file_types=[".py", ".ipynb"]
+                    )
+                    analysis_type = gr.Dropdown(
+                        choices=["review", "explain", "optimize", "debug", "document"],
+                        value="review",
+                        label="Analysis Type"
+                    )
+                    analyze_btn = gr.Button("Analyze Code", variant="primary")
+                
+                with gr.Column():
+                    analysis_output = gr.Textbox(
+                        label="Analysis Result",
+                        lines=20,
+                        max_lines=30
+                    )
+            
+            analyze_btn.click(
+                analyze_uploaded_code,
+                inputs=[file_input, analysis_type],
+                outputs=analysis_output
+            )
+        
+        # Code Generation Tab
+        with gr.TabItem("⚡ Generate Code"):
+            with gr.Row():
+                with gr.Column():
+                    code_description = gr.Textbox(
+                        label="Describe what you want to code",
+                        lines=5,
+                        placeholder="E.g., Create a function to sort a list of dictionaries by a specific key..."
+                    )
+                    code_language = gr.Dropdown(
+                        choices=["python", "javascript", "java", "cpp", "c"],
+                        value="python",
+                        label="Programming Language"
+                    )
+                    generate_btn = gr.Button("Generate Code", variant="primary")
+                
+                with gr.Column():
+                    generated_code = gr.Code(
+                        label="Generated Code",
+                        language="python",
+                        lines=20
+                    )
+            
+            generate_btn.click(
+                generate_new_code,
+                inputs=[code_description, code_language],
+                outputs=generated_code
+            )
+        
+        # Code Chat Tab
+        with gr.TabItem("💬 Chat About Code"):
+            with gr.Row():
+                with gr.Column():
+                    chat_file_input = gr.File(
+                        label="Upload Code File",
+                        file_types=[".py", ".ipynb"]
+                    )
+                    code_question = gr.Textbox(
+                        label="Ask a question about your code",
+                        lines=3,
+                        placeholder="E.g., How can I improve the performance of this function?"
+                    )
+                    chat_btn = gr.Button("Ask Question", variant="primary")
+                
+                with gr.Column():
+                    chat_output = gr.Textbox(
+                        label="Answer",
+                        lines=15,
+                        max_lines=25
+                    )
+            
+            chat_btn.click(
+                chat_about_code,
+                inputs=[chat_file_input, code_question],
+                outputs=chat_output
+            )
+    
+    # Footer
+    gr.Markdown("---")
+    gr.Markdown("**Note:** This copilot uses Claude 3 Haiku for intelligent code analysis and generation.")
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch()