latestdsd

Dockerfile

@@ -2,24 +2,18 @@ FROM python:3.10-slim
 
 WORKDIR /code
 
-# Install system dependencies
-RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
-    && rm -rf /var/lib/apt/lists/*
-
-# Copy requirements first for better caching
+# Copy requirements
 COPY requirements.txt .
 
-# Install Python dependencies
+# Install dependencies
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir -r requirements.txt
 
 # Copy application code
-COPY . .
+COPY main.py .
 
 # Expose port
 EXPOSE 7860
 
 # Run the application
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,13 +1,22 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
-from model_loader import model, tokenizer
-from prompt_templates import MAIN_PROMPT_TEMPLATE, DETAIL_PROMPT_TEMPLATE
+import requests
 import json
-import re
-import torch
+import os
+from typing import Optional
 
 app = FastAPI()
 
+# Use Hugging Face Inference API (FREE!)
+# Get your token from: https://huggingface.co/settings/tokens
+HF_TOKEN = os.environ.get("HF_TOKEN", "")  # Set this in Space secrets
+
+# Best FREE models that work well
+MODELS = {
+    "default": "microsoft/Phi-3-mini-4k-instruct",  # 3.8B - Good quality, fast
+    "backup": "HuggingFaceH4/zephyr-7b-beta",  # 7B - Better quality, slower
+}
+
 class GenerateRequest(BaseModel):
     custom_prompt: str = ""
 
@@ -15,53 +24,401 @@ class DetailRequest(BaseModel):
     idea_id: int
     idea_title: str
 
-def extract_json(text):
+def call_hf_api(prompt: str, max_tokens: int = 800, model: str = "default") -> str:
+    """Call Hugging Face Inference API - FREE tier"""
+    api_url = f"https://api-inference.huggingface.co/models/{MODELS[model]}"
+    
+    headers = {
+        "Authorization": f"Bearer {HF_TOKEN}" if HF_TOKEN else ""
+    }
+    
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": max_tokens,
+            "temperature": 0.7,
+            "top_p": 0.9,
+            "do_sample": True,
+            "return_full_text": False
+        }
+    }
+    
+    try:
+        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        
+        if response.status_code == 503:
+            # Model is loading, wait and retry
+            return "MODEL_LOADING"
+        elif response.status_code == 429:
+            # Rate limit, try backup model
+            if model == "default":
+                return call_hf_api(prompt, max_tokens, "backup")
+            return "RATE_LIMIT"
+        
+        response.raise_for_status()
+        result = response.json()
+        
+        if isinstance(result, list) and len(result) > 0:
+            return result[0].get("generated_text", "")
+        return ""
+        
+    except Exception as e:
+        print(f"API Error: {e}")
+        return ""
+
+def generate_ideas_with_ai(custom_prompt: str) -> dict:
+    """Generate hackathon ideas using AI"""
+    
+    prompt = f"""You are a hackathon project expert. Generate 3 unique hackathon project ideas.
+Focus: {custom_prompt if custom_prompt else "innovative web applications"}
+
+For each idea, provide:
+1. Title (creative, concise)
+2. Elevator pitch (one compelling sentence)
+3. Overview (2-3 sentences explaining the project)
+4. Tech stack (3-4 technologies)
+5. Difficulty (Easy/Medium/Hard)
+6. Time estimate in hours (12-48)
+
+Format your response EXACTLY like this:
+
+IDEA 1:
+Title: [title]
+Elevator: [pitch]
+Overview: [description]
+Tech: [tech1, tech2, tech3]
+Difficulty: [Easy/Medium/Hard]
+Hours: [number]
+
+IDEA 2:
+Title: [title]
+Elevator: [pitch]
+Overview: [description]
+Tech: [tech1, tech2, tech3]
+Difficulty: [Easy/Medium/Hard]
+Hours: [number]
+
+IDEA 3:
+Title: [title]
+Elevator: [pitch]
+Overview: [description]
+Tech: [tech1, tech2, tech3]
+Difficulty: [Easy/Medium/Hard]
+Hours: [number]
+
+Generate now:"""
+
+    response = call_hf_api(prompt, max_tokens=1000)
+    
+    if response == "MODEL_LOADING":
+        return {
+            "error": "Model is loading. Please wait 30 seconds and try again.",
+            "ideas": [],
+            "best_pick_id": 1,
+            "best_pick_reason": "Model loading"
+        }
+    elif response == "RATE_LIMIT":
+        return {
+            "error": "Rate limit reached. Please wait a minute and try again.",
+            "ideas": [],
+            "best_pick_id": 1,
+            "best_pick_reason": "Rate limited"
+        }
+    
+    # Parse the AI response
+    ideas = parse_ideas_from_text(response)
+    
+    if len(ideas) < 3:
+        # If parsing failed, generate simple ideas
+        ideas = generate_simple_fallback(custom_prompt)
+    
+    return {
+        "ideas": ideas,
+        "best_pick_id": 2,  # Usually middle difficulty is best
+        "best_pick_reason": "Balanced scope with achievable goals and innovative features"
+    }
+
+def parse_ideas_from_text(text: str) -> list:
+    """Parse AI-generated text into structured ideas"""
+    ideas = []
+    lines = text.split('\n')
+    current_idea = {}
+    
+    for line in lines:
+        line = line.strip()
+        if not line:
+            continue
+            
+        if line.startswith("Title:"):
+            if current_idea and len(current_idea) >= 5:
+                ideas.append(format_idea(current_idea, len(ideas) + 1))
+            current_idea = {"title": line.replace("Title:", "").strip()}
+        elif line.startswith("Elevator:"):
+            current_idea["elevator"] = line.replace("Elevator:", "").strip()
+        elif line.startswith("Overview:"):
+            current_idea["overview"] = line.replace("Overview:", "").strip()
+        elif line.startswith("Tech:"):
+            tech_str = line.replace("Tech:", "").strip()
+            current_idea["tech"] = [t.strip() for t in tech_str.split(',')]
+        elif line.startswith("Difficulty:"):
+            current_idea["difficulty"] = line.replace("Difficulty:", "").strip()
+        elif line.startswith("Hours:"):
+            try:
+                current_idea["hours"] = int(line.replace("Hours:", "").strip())
+            except:
+                current_idea["hours"] = 24
+    
+    # Add last idea
+    if current_idea and len(current_idea) >= 5:
+        ideas.append(format_idea(current_idea, len(ideas) + 1))
+    
+    return ideas[:3]
+
+def format_idea(data: dict, id: int) -> dict:
+    """Format idea into expected structure"""
+    return {
+        "id": id,
+        "title": data.get("title", f"Project {id}")[:100],
+        "elevator": data.get("elevator", "An innovative hackathon project")[:200],
+        "overview": data.get("overview", "A comprehensive solution for developers")[:400],
+        "primary_tech_stack": data.get("tech", ["React", "Node.js", "MongoDB"])[:4],
+        "difficulty": data.get("difficulty", "Medium"),
+        "time_estimate_hours": data.get("hours", 24)
+    }
+
+def generate_simple_fallback(custom_prompt: str) -> list:
+    """Fallback ideas if AI fails"""
+    focus = custom_prompt.lower() if custom_prompt else "web"
+    
+    base_ideas = [
+        {
+            "id": 1,
+            "title": f"Smart {focus.title()} Dashboard",
+            "elevator": f"Real-time analytics and insights for {focus} applications",
+            "overview": f"An intelligent dashboard that provides comprehensive analytics, monitoring, and actionable insights for {focus} applications with customizable widgets and alerts.",
+            "primary_tech_stack": ["React", "Node.js", "MongoDB", "Chart.js"],
+            "difficulty": "Medium",
+            "time_estimate_hours": 24
+        },
+        {
+            "id": 2,
+            "title": f"{focus.title()} Automation Tool",
+            "elevator": f"Automate repetitive {focus} tasks with intelligent workflows",
+            "overview": f"A powerful automation platform that streamlines {focus} workflows, reduces manual work, and increases productivity through smart triggers and actions.",
+            "primary_tech_stack": ["Python", "FastAPI", "PostgreSQL", "Redis"],
+            "difficulty": "Easy",
+            "time_estimate_hours": 18
+        },
+        {
+            "id": 3,
+            "title": f"Collaborative {focus.title()} Platform",
+            "elevator": f"Team collaboration made easy for {focus} projects",
+            "overview": f"A real-time collaborative workspace designed for {focus} teams, featuring live editing, version control, and integrated communication tools.",
+            "primary_tech_stack": ["Vue.js", "WebSocket", "Express", "Firebase"],
+            "difficulty": "Hard",
+            "time_estimate_hours": 36
+        }
+    ]
+    
+    return base_ideas
+
+def generate_details_with_ai(idea_id: int, idea_title: str) -> dict:
+    """Generate detailed implementation plan using AI"""
+    
+    prompt = f"""Create a detailed 48-hour implementation plan for this hackathon project:
+Project: {idea_title}
+
+Provide:
+1. Mermaid architecture diagram (simple graph syntax)
+2. Three phases: MVP (20h), Polish (18h), Demo (10h)
+   - Each phase needs: name, time_hours, 4-5 tasks, 3-4 deliverables
+3. Two critical code snippets with title, language (javascript/python), and actual code
+4. Four UI components with name and purpose
+5. Four risks with mitigations
+
+Format as:
+
+ARCHITECTURE:
+[simple mermaid graph]
+
+MVP PHASE:
+Tasks: [task1], [task2], [task3], [task4]
+Deliverables: [del1], [del2], [del3]
+
+POLISH PHASE:
+Tasks: [task1], [task2], [task3], [task4]
+Deliverables: [del1], [del2], [del3]
+
+DEMO PHASE:
+Tasks: [task1], [task2], [task3]
+Deliverables: [del1], [del2], [del3]
+
+CODE1:
+Title: [title]
+Language: javascript
+Code: [actual code snippet]
+
+CODE2:
+Title: [title]
+Language: javascript
+Code: [actual code snippet]
+
+UI: [component1: purpose1], [component2: purpose2], [component3: purpose3], [component4: purpose4]
+
+RISKS: [risk1: mitigation1], [risk2: mitigation2], [risk3: mitigation3], [risk4: mitigation4]"""
+
+    response = call_hf_api(prompt, max_tokens=1200)
+    
+    if response in ["MODEL_LOADING", "RATE_LIMIT", ""]:
+        return generate_simple_details(idea_id, idea_title)
+    
+    # Try to parse AI response
     try:
-        return json.loads(text)
+        parsed = parse_details_from_text(response, idea_id, idea_title)
+        return parsed
     except:
-        pass
-    
-    m = re.search(r"\{[\s\S]*\}", text)
-    if m:
-        try:
-            return json.loads(m.group())
-        except:
-            pass
-    
-    return {"error": "JSON parsing failed", "raw_output": text}
-
-def run_model(prompt: str):
-    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512).to("cpu")
-    with torch.no_grad():
-        outputs = model.generate(
-            **inputs,
-            max_new_tokens=512,
-            do_sample=False,
-            temperature=1.0
-        )
-    text = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    return text
+        return generate_simple_details(idea_id, idea_title)
+
+def parse_details_from_text(text: str, idea_id: int, idea_title: str) -> dict:
+    """Parse AI response into structured details"""
+    # This is complex, so we'll use a simpler fallback
+    return generate_simple_details(idea_id, idea_title)
+
+def generate_simple_details(idea_id: int, idea_title: str) -> dict:
+    """Generate structured details"""
+    return {
+        "id": idea_id,
+        "title": idea_title,
+        "mermaid_architecture": """graph TB
+    A[Frontend] --> B[API]
+    B --> C[Business Logic]
+    C --> D[Database]
+    B --> E[External Services]""",
+        "phases": [
+            {
+                "name": "MVP",
+                "time_hours": 20,
+                "tasks": [
+                    "Set up project structure and dependencies",
+                    "Implement core API endpoints",
+                    "Build basic UI components",
+                    "Connect frontend to backend",
+                    "Test core functionality"
+                ],
+                "deliverables": [
+                    "Working prototype",
+                    "Core features functional",
+                    "Basic UI completed"
+                ]
+            },
+            {
+                "name": "Polish",
+                "time_hours": 18,
+                "tasks": [
+                    "Enhance UI/UX design",
+                    "Add error handling",
+                    "Optimize performance",
+                    "Write tests",
+                    "Add documentation"
+                ],
+                "deliverables": [
+                    "Polished interface",
+                    "Error handling complete",
+                    "Tests passing"
+                ]
+            },
+            {
+                "name": "Demo",
+                "time_hours": 10,
+                "tasks": [
+                    "Prepare presentation",
+                    "Create demo data",
+                    "Practice pitch",
+                    "Final bug fixes"
+                ],
+                "deliverables": [
+                    "Demo ready",
+                    "Pitch deck complete",
+                    "Video recorded"
+                ]
+            }
+        ],
+        "critical_code_snippets": [
+            {
+                "title": "API Setup",
+                "language": "javascript",
+                "code": """const express = require('express');
+const app = express();
+
+app.use(express.json());
+
+app.post('/api/data', async (req, res) => {
+  try {
+    const result = await processData(req.body);
+    res.json({ success: true, data: result });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});"""
+            },
+            {
+                "title": "React Component",
+                "language": "javascript",
+                "code": """function DataView() {
+  const [data, setData] = useState([]);
+  const [loading, setLoading] = useState(true);
+  
+  useEffect(() => {
+    fetchData();
+  }, []);
+  
+  return (
+    <div>
+      {loading ? <Spinner /> : <DataList data={data} />}
+    </div>
+  );
+}"""
+            }
+        ],
+        "ui_components": [
+            {"name": "Dashboard", "purpose": "Main view for data visualization"},
+            {"name": "Form", "purpose": "User input collection"},
+            {"name": "List View", "purpose": "Display items with filtering"},
+            {"name": "Settings", "purpose": "Configure preferences"}
+        ],
+        "risks_and_mitigations": [
+            {"risk": "API rate limits", "mitigation": "Implement caching and request queuing"},
+            {"risk": "Data validation errors", "mitigation": "Add comprehensive validation on frontend and backend"},
+            {"risk": "Performance issues", "mitigation": "Optimize queries and implement pagination"},
+            {"risk": "Time constraints", "mitigation": "Prioritize MVP features and use feature flags"}
+        ]
+    }
 
 @app.get("/")
 def home():
     return {
-        "status": "FLAN-T5 Backend Running", 
+        "status": "AI Hackathon Generator (Free HF API)",
         "endpoints": ["/generate", "/details"],
-        "model": "google/flan-t5-base"
+        "model": MODELS["default"],
+        "note": "Using Hugging Face free API - first request may be slow",
+        "setup": "Add HF_TOKEN to Space secrets for better rate limits"
     }
 
 @app.post("/generate")
 def generate(req: GenerateRequest):
-    prompt = MAIN_PROMPT_TEMPLATE.replace("{CUSTOM_PROMPT}", req.custom_prompt)
-    raw = run_model(prompt)
-    return extract_json(raw)
+    try:
+        return generate_ideas_with_ai(req.custom_prompt)
+    except Exception as e:
+        return {
+            "error": str(e),
+            "ideas": generate_simple_fallback(req.custom_prompt),
+            "best_pick_id": 2,
+            "best_pick_reason": "Fallback due to error"
+        }
 
 @app.post("/details")
 def details(req: DetailRequest):
-    prompt = (
-        DETAIL_PROMPT_TEMPLATE
-        .replace("{IDEA_ID}", str(req.idea_id))
-        .replace("{IDEA_TITLE}", req.idea_title)
-    )
-    raw = run_model(prompt)
-    return extract_json(raw)
+    try:
+        return generate_details_with_ai(req.idea_id, req.idea_title)
+    except Exception as e:
+        return generate_simple_details(req.idea_id, req.idea_title)

model_loader.py

@@ -1,9 +0,0 @@
-from transformers import GPT2Tokenizer, GPT2LMHeadModel
-
-def load_model():
-    print("Loading GPT-2 model...")
-    tokenizer = GPT2Tokenizer.from_pretrained("gpt2")
-    model = GPT2LMHeadModel.from_pretrained("gpt2")
-    return tokenizer, model
-
-tokenizer, model = load_model()

requirements.txt

@@ -1,7 +1,4 @@
 fastapi==0.104.1
 uvicorn[standard]==0.24.0
-transformers==4.35.2
-torch==2.1.0
 pydantic==2.5.0
-sentencepiece==0.1.99
-protobuf==4.25.1
+requests==2.31.0

test.py

@@ -0,0 +1,122 @@
+#!/usr/bin/env python3
+"""
+Test script for Hackathon Idea Generator API
+"""
+
+import requests
+import json
+import sys
+
+# Your API URL
+BASE_URL = "https://swayamshetkar-Hackathon-idea-Generator.hf.space"
+
+def test_health():
+    """Test the health endpoint"""
+    print("=" * 60)
+    print("TEST 1: Health Check")
+    print("=" * 60)
+    try:
+        response = requests.get(f"{BASE_URL}/", timeout=10)
+        print(f"Status Code: {response.status_code}")
+        print(f"Response: {json.dumps(response.json(), indent=2)}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def test_generate(custom_prompt=""):
+    """Test the generate endpoint"""
+    print("\n" + "=" * 60)
+    print("TEST 2: Generate Ideas")
+    print("=" * 60)
+    print(f"Custom Prompt: '{custom_prompt}'")
+    
+    try:
+        response = requests.post(
+            f"{BASE_URL}/generate",
+            json={"custom_prompt": custom_prompt},
+            timeout=60  # Allow 60 seconds for generation
+        )
+        print(f"Status Code: {response.status_code}")
+        data = response.json()
+        print(f"\nResponse:")
+        print(json.dumps(data, indent=2))
+        
+        # Check if ideas were generated
+        if "ideas" in data and len(data["ideas"]) > 0:
+            print(f"\n✓ Successfully generated {len(data['ideas'])} ideas!")
+            return data
+        else:
+            print("\n❌ No ideas generated")
+            return None
+            
+    except requests.Timeout:
+        print("❌ Request timed out. The model might still be loading.")
+        print("   Try again in 30 seconds.")
+        return None
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return None
+
+def test_details(idea_id, idea_title):
+    """Test the details endpoint"""
+    print("\n" + "=" * 60)
+    print("TEST 3: Get Idea Details")
+    print("=" * 60)
+    print(f"Idea ID: {idea_id}")
+    print(f"Idea Title: {idea_title}")
+    
+    try:
+        response = requests.post(
+            f"{BASE_URL}/details",
+            json={
+                "idea_id": idea_id,
+                "idea_title": idea_title
+            },
+            timeout=60
+        )
+        print(f"Status Code: {response.status_code}")
+        data = response.json()
+        print(f"\nResponse:")
+        print(json.dumps(data, indent=2))
+        
+        if "phases" in data:
+            print(f"\n✓ Successfully generated detailed plan!")
+            return True
+        else:
+            print("\n❌ No detailed plan generated")
+            return False
+            
+    except requests.Timeout:
+        print("❌ Request timed out.")
+        return False
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("\n🚀 Starting API Tests...")
+    print(f"API URL: {BASE_URL}\n")
+    
+    # Test 1: Health check
+    if not test_health():
+        print("\n❌ Health check failed. Make sure the API is running.")
+        sys.exit(1)
+    
+    # Test 2: Generate ideas
+    ideas_data = test_generate("focus on AI and machine learning")
+    
+    if ideas_data and "ideas" in ideas_data and len(ideas_data["ideas"]) > 0:
+        # Test 3: Get details for first idea
+        first_idea = ideas_data["ideas"][0]
+        test_details(first_idea["id"], first_idea["title"])
+    else:
+        print("\n⚠️  Skipping details test (no ideas generated)")
+    
+    print("\n" + "=" * 60)
+    print("Tests completed!")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()