CodeReviewApp Architecture

# integrations/huggingface.py
import os
from typing import Optional, Dict, Any
import httpx
from app.core.config import settings
from app.core.logging import logger

HF_API_URL = "https://api-inference.huggingface.co/models"
HF_API_KEY = settings.HF_API_KEY

async def query_hf_model(
    model: str,
    prompt: str,
    parameters: Optional[Dict[str, Any]] = None
) -> Optional[Dict[str, Any]]:
    """Query HuggingFace inference API"""
    
    headers = {
        "Authorization": f"Bearer {HF_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "inputs": prompt,
        "parameters": parameters or {
            "max_new_tokens": 1024,
            "temperature": 0.7,
            "return_full_text": False
        }
    }
    
    try:
        async with httpx.AsyncClient(timeout=30.0) as client:
            response = await client.post(
                f"{HF_API_URL}/{model}",
                headers=headers,
                json=payload
            )
            
            if response.status_code == 200:
                return response.json()
            elif response.status_code == 503:
                # Model is loading, wait and retry
                logger.info(f"Model {model} is loading, retrying...")
                await asyncio.sleep(10)
                return await query_hf_model(model, prompt, parameters)
            else:
                logger.error(
                    f"HF API error: {response.status_code} - {response.text}"
                )
                return None
                
    except Exception as e:
        logger.error(f"Error querying HF API: {str(e)}")
        return None

# services/model_selector.py
from enum import Enum
from typing import Optional, Dict, Any
from app.integrations.huggingface import query_hf_model

class ModelType(str, Enum):
    CODE_ANALYSIS = "code_analysis"
    SECURITY = "security"
    DOCUMENTATION = "documentation"

MODEL_MAP = {
    ModelType.CODE_ANALYSIS: "codellama/CodeLlama-34b-Instruct-hf",
    ModelType.SECURITY: "deepset/roberta-base-squad2",
    ModelType.DOCUMENTATION: "bigcode/starcoder"
}

def get_model_for_task(task_type: ModelType) -> str:
    """Get appropriate model for given task type"""
    return MODEL_MAP.get(task_type, MODEL_MAP[ModelType.CODE_ANALYSIS])

async def analyze_with_model(
    code: str,
    task_type: ModelType,
    language: str = "python"
) -> Optional[Dict[str, Any]]:
    """Analyze code with task-specific model"""
    
    model = get_model_for_task(task_type)
    prompt = generate_prompt_for_task(task_type, code, language)
    
    parameters = {
        "max_new_tokens": 1024,
        "temperature": 0.5 if task_type == ModelType.SECURITY else 0.7
    }
    
    return await query_hf_model(model, prompt, parameters)

def generate_prompt_for_task(
    task_type: ModelType,
    code: str,
    language: str
) -> str:
    """Generate task-specific prompt"""
    
    if task_type == ModelType.SECURITY:
        return f"""Analyze this {language} code for security vulnerabilities:
        {code}
        
        Return JSON with:
        - vulnerability_type
        - severity (low/medium/high/critical)
        - description
        - line_number
        - recommendation
        """
    elif task_type == ModelType.DOCUMENTATION:
        return f"""Generate documentation for this {language} code:
        {code}
        
        Include:
        - Function description
        - Parameters
        - Return value
        - Usage example
        """
    else:  # Default code analysis
        return f"""Analyze this {language} code for quality issues:
        {code}
        
        Return JSON with:
        - issue_type (style/performance/bug)
        - severity (low/medium/high)
        - message
        - line_number
        - recommendation
        """

# Dockerfile
FROM python:3.9-slim as base

# Install system dependencies
RUN apt-get update && apt-get install -y \
    build-essential \
    curl \
    && rm -rf /var/lib/apt/lists/*

# Create and activate virtual environment
ENV VIRTUAL_ENV=/opt/venv
RUN python3 -m venv $VIRTUAL_ENV
ENV PATH="$VIRTUAL_ENV/bin:$PATH"

# Install Python dependencies
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application code
COPY . .

# Frontend build stage
FROM node:16 as frontend-builder
WORKDIR /app/frontend
COPY frontend/package.json frontend/package-lock.json ./
RUN npm install
COPY frontend .
RUN npm run build

# Final production image
FROM base as production
COPY --from=frontend-builder /app/frontend/dist /app/frontend/dist

# Set environment variables
ENV PYTHONUNBUFFERED=1
ENV PORT=8000
ENV MODE=production

# Run application
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "$PORT"]

# .github/workflows/deploy.yml
name: Deploy to HuggingFace Spaces

on:
  push:
    branches: [ main ]
  pull_request:
    branches: [ main ]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Set up Python
        uses: actions/setup-python@v4
        with:
          python-version: '3.9'
      
      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt
      
      - name: Set up Node.js
        uses: actions/setup-node@v3
        with:
          node-version: '16'
      
      - name: Build frontend
        working-directory: ./frontend
        run: |
          npm install
          npm run build
      
      - name: Configure Docker
        run: |
          echo "${{ secrets.HF_TOKEN }}" | docker login \
            -u ${{ secrets.HF_USERNAME }} \
            --password-stdin \
            ghcr.io
      
      - name: Build and push Docker image
        run: |
          docker build -t ghcr.io/${{ secrets.HF_USERNAME }}/deepsite:latest .
          docker push ghcr.io/${{ secrets.HF_USERNAME }}/deepsite:latest
      
      - name: Deploy to Spaces
        uses: huggingface/huggingface_hub@main
        with:
          huggingface_token: ${{ secrets.HF_TOKEN }}
          repo_id: ${{ secrets.HF_USERNAME }}/deepsite
          space_sdk: docker
          space_hardware: cpu-basic
          space_storage: small