# Install Anthropic Python SDK
pip install anthropic

# Set up your API key
export ANTHROPIC_API_KEY="your-api-key-here"

import anthropic
import json
from typing import List, Dict, Any

class ClaudeCodingAssistant:
    def __init__(self, api_key: str):
        self.client = anthropic.Anthropic(api_key=api_key)
    
    def get_coding_assistance(self, prompt: str, context: str = "") -> str:
        """Get coding assistance from Claude 3.5 Sonnet"""
        full_prompt = f"""
        You are an expert software engineer. Help me with this coding task:
        
        Task: {prompt}
        
        Context: {context}
        
        Please provide:
        1. Complete, working code
        2. Explanation of the approach
        3. Best practices used
        4. Potential improvements
        """
        
        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=4000,
            messages=[{"role": "user", "content": full_prompt}]
        )
        return response.content[0].text
    
    def generate_function(self, description: str, language: str = "python") -> Dict[str, str]:
        """Generate a complete function based on description"""
        prompt = f"""
        Generate a {language} function based on this description: {description}
        
        Include:
        - Function signature with proper type hints
        - Complete implementation
        - Error handling
        - Docstring with examples
        - Unit tests
        """
        
        result = self.get_coding_assistance(prompt)
        return {
            "code": result,
            "language": language,
            "description": description
        }

# Example usage
assistant = ClaudeCodingAssistant("your-api-key-here")

# Generate a sorting function
sorting_result = assistant.generate_function(
    "Sort a list of dictionaries by a specific key with custom comparison",
    "python"
)
print(sorting_result["code"])

# Generate a complete REST API endpoint
api_prompt = """
Create a FastAPI endpoint for user management that:
1. Accepts user registration data (name, email, password)
2. Validates email format and password strength
3. Hashes password using bcrypt
4. Stores user in PostgreSQL database
5. Returns JSON response with success/error status
6. Includes proper error handling and logging
7. Uses Pydantic models for validation
"""

api_code = assistant.get_coding_assistance(api_prompt)
print(api_code)

# Example: Generate a complete microservice
microservice_prompt = """
Create a Python microservice for order processing that:
1. Uses FastAPI framework
2. Connects to Redis for caching
3. Integrates with PostgreSQL for persistence
4. Implements JWT authentication
5. Includes rate limiting
6. Has comprehensive error handling
7. Uses async/await for performance
8. Includes logging and monitoring
9. Has health check endpoints
10. Implements proper data validation
"""

# This will generate a complete, production-ready microservice
microservice_code = assistant.get_coding_assistance(microservice_prompt)

# Before: Legacy code that needs refactoring
legacy_code = """
def process_orders(orders):
    results = []
    for order in orders:
        if order['status'] == 'pending':
            if order['amount'] > 100:
                order['discount'] = 0.1
            else:
                order['discount'] = 0.05
            order['total'] = order['amount'] * (1 - order['discount'])
            results.append(order)
    return results
"""

# Refactor with Claude 3.5 Sonnet
refactor_prompt = f"""
Refactor this legacy code to modern Python standards:

{legacy_code}

Requirements:
1. Use type hints
2. Implement proper error handling
3. Use dataclasses or Pydantic models
4. Add comprehensive logging
5. Make it async if beneficial
6. Add unit tests
7. Follow SOLID principles
8. Add documentation
"""

refactored_code = assistant.get_coding_assistance(refactor_prompt)

def review_code_with_claude(code_snippet):
    review_prompt = f"""
    Please review this code and provide:
    1. Performance improvements
    2. Security considerations
    3. Best practices suggestions
    4. Potential bugs
    
    Code:
    {code_snippet}
    """
    
    return get_coding_assistance(review_prompt)

def debug_with_claude(error_message, code_context):
    debug_prompt = f"""
    I'm getting this error: {error_message}
    
    Here's the relevant code:
    {code_context}
    
    Please help me identify the issue and provide a solution.
    """
    
    return get_coding_assistance(debug_prompt)

{
  "name": "Claude 3.5 Sonnet Assistant",
  "version": "1.0.0",
  "description": "AI-powered coding assistant using Claude 3.5 Sonnet",
  "main": "extension.js",
  "contributes": {
    "commands": [
      {
        "command": "claude.generateCode",
        "title": "Generate Code with Claude"
      }
    ]
  }
}

# Custom Claude integration for code completion
class ClaudeCodeAssistant:
    def __init__(self, api_key):
        self.client = anthropic.Anthropic(api_key=api_key)
    
    def get_code_suggestion(self, context, cursor_position):
        prompt = f"""
        Based on this code context, suggest the next few lines:
        
        {context}
        
        Cursor position: {cursor_position}
        """
        
        response = self.client.messages.create(
            model="claude-3-5-sonnet-20241022",
            max_tokens=500,
            messages=[{"role": "user", "content": prompt}]
        )
        
        return response.content[0].text

# Good prompt example
prompt = """
I'm building a Python web scraper for e-commerce sites. 
Requirements:
- Handle dynamic content (JavaScript)
- Respect robots.txt
- Implement rate limiting
- Store data in PostgreSQL
- Include error handling and logging

Please provide a complete implementation with proper structure.
"""

# Generate complete React component
react_prompt = """
Create a React component for a user dashboard that:
- Displays user profile information
- Shows recent activity
- Includes settings panel
- Has responsive design
- Uses TypeScript
"""

# Machine learning pipeline
ml_prompt = """
Build a machine learning pipeline for customer churn prediction:
- Data preprocessing
- Feature engineering
- Model training (try multiple algorithms)
- Model evaluation
- Deployment considerations
"""

# Infrastructure as Code
devops_prompt = """
Create a Terraform configuration for:
- AWS EKS cluster
- RDS PostgreSQL database
- Application Load Balancer
- Auto-scaling groups
- Security groups and IAM roles
"""