Update app.py

app.py

@@ -1,226 +1,145 @@
 import gradio as gr
-from fastapi import FastAPI, HTTPException
-from pydantic import BaseModel
 import json
-import os
-import asyncio
-import aiohttp
-from typing import List, Optional, Literal
 import time
-import logging
-import re
 
-# Setup logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-app = FastAPI(
-    title="SoActi AI Quiz API",
-    description="Separat AI-tjeneste for quiz-generering som SoActi kan bruke",
-    version="1.0.0"
-)
-
-# Request/Response models
-class QuizRequest(BaseModel):
-    tema: str
-    språk: Literal["no", "en"] = "no"
-    antall_spørsmål: int = 5
-    type: Literal["sted", "rute"] = "sted"
-    vanskelighetsgrad: int = 3
-
-class QuizQuestion(BaseModel):
-    spørsmål: str
-    alternativer: List[str]
-    korrekt_svar: int
-    forklaring: str
-
-class QuizResponse(BaseModel):
-    success: bool
-    questions: List[QuizQuestion]
-    metadata: dict
-    message: str
-
-class HealthResponse(BaseModel):
-    status: str
-    models_loaded: bool
-    api_key_configured: bool
-    uptime_seconds: float
-
-# Global state
-start_time = time.time()
-api_key = os.getenv("HUGGINGFACE_API_KEY")
-
-@app.get("/", response_model=dict)
-async def root():
-    """Root endpoint med API-informasjon"""
-    return {
-        "service": "SoActi AI Quiz API",
-        "version": "1.0.0",
-        "status": "running",
-        "endpoints": {
-            "generate": "/generate-quiz",
-            "health": "/health",
-            "models": "/models",
-            "docs": "/docs"
+# Hardkodede spørsmål direkte i app.py
+QUIZ_DATABASE = {
+    "oslo": [
+        {
+            "spørsmål": "Hva heter Oslos hovedflyplass?",
+            "alternativer": ["Fornebu", "Gardermoen", "Torp", "Rygge"],
+            "korrekt_svar": 1,
+            "forklaring": "Oslo lufthavn Gardermoen er Oslos hovedflyplass, åpnet i 1998."
         },
-        "description": "Separat AI-tjeneste for quiz-generering"
-    }
-
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
-    """Helsesjekk for tjenesten"""
-    uptime = time.time() - start_time
-    
-    return HealthResponse(
-        status="healthy",
-        models_loaded=True,
-        api_key_configured=bool(api_key),
-        uptime_seconds=uptime
-    )
-
-@app.get("/models")
-async def get_available_models():
-    """Liste over tilgjengelige AI-modeller"""
-    return {
-        "norwegian_models": [
-            {
-                "name": "NbAiLab/nb-gpt-j-6B",
-                "description": "Beste for norsk - Nasjonalbiblioteket",
-                "cost": "Gratis",
-                "quality": "Høy (norsk)"
-            }
-        ],
-        "english_models": [
-            {
-                "name": "meta-llama/Llama-2-70b-chat-hf",
-                "description": "Beste kvalitet - Premium",
-                "cost": "Premium ($$$)",
-                "quality": "Exceptional"
-            },
-            {
-                "name": "mistralai/Mistral-7B-Instruct-v0.1",
-                "description": "Balansert kvalitet/kostnad",
-                "cost": "Premium ($$)",
-                "quality": "Meget høy"
-            }
-        ],
-        "fallback_models": [
-            {
-                "name": "google/flan-t5-small",
-                "description": "Gratis fallback",
-                "cost": "Gratis",
-                "quality": "Middels"
-            }
-        ]
-    }
-
-@app.post("/generate-quiz", response_model=QuizResponse)
-async def generate_quiz(request: QuizRequest):
-    """Hovedendepunkt for quiz-generering"""
-    try:
-        logger.info(f"Genererer quiz for tema: {request.tema} ({request.språk})")
-        
-        # Valider request
-        if not request.tema.strip():
-            raise HTTPException(status_code=400, detail="Tema kan ikke være tomt")
-        
-        if request.antall_spørsmål < 1 or request.antall_spørsmål > 20:
-            raise HTTPException(status_code=400, detail="Antall spørsmål må være mellom 1 og 20")
-        
-        # Generer quiz
-        from quiz_generator import QuizGenerator
-        generator = QuizGenerator(api_key)
-        
-        start_time = time.time()
-        questions = await generator.generate_quiz(request)
-        generation_time = time.time() - start_time
-        
-        if not questions:
-            raise HTTPException(status_code=500, detail="Kunne ikke generere spørsmål")
-        
-        logger.info(f"Genererte {len(questions)} spørsmål på {generation_time:.2f}s")
-        
-        return QuizResponse(
-            success=True,
-            questions=questions,
-            metadata={
-                "generation_time": round(generation_time, 2),
-                "model_used": generator.get_model_used(),
-                "method": generator.get_generation_method(),
-                "tema": request.tema,
-                "språk": request.språk
-            },
-            message=f"Genererte {len(questions)} spørsmål om '{request.tema}'"
-        )
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        logger.error(f"Feil ved quiz-generering: {str(e)}")
-        raise HTTPException(status_code=500, detail=f"Intern feil: {str(e)}")
-
-@app.post("/validate-quiz")
-async def validate_quiz(questions: List[QuizQuestion]):
-    """Valider genererte quiz-spørsmål"""
-    try:
-        from quiz_validator import QuizValidator
-        validator = QuizValidator()
-        
-        results = []
-        for i, question in enumerate(questions):
-            validation = validator.validate_question(question.dict())
-            results.append({
-                "question_index": i,
-                "valid": validation["valid"],
-                "score": validation["score"],
-                "issues": validation["issues"]
-            })
-        
-        overall_score = sum(r["score"] for r in results) / len(results)
-        
-        return {
-            "overall_valid": all(r["valid"] for r in results),
-            "overall_score": round(overall_score, 2),
-            "question_results": results
+        {
+            "spørsmål": "Hvilken fjord ligger Oslo ved?",
+            "alternativer": ["Trondheimsfjorden", "Oslofjorden", "Hardangerfjorden", "Sognefjorden"],
+            "korrekt_svar": 1,
+            "forklaring": "Oslo ligger innerst i Oslofjorden."
+        },
+        {
+            "spørsmål": "Hva heter Oslos berømte operahus?",
+            "alternativer": ["Operaen", "Den Norske Opera", "Oslo Opera House", "Operahuset"],
+            "korrekt_svar": 3,
+            "forklaring": "Operahuset i Oslo åpnet i 2008."
         }
-        
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=f"Valideringsfeil: {str(e)}")
+    ],
+    "bergen": [
+        {
+            "spørsmål": "Hva kalles det fargerike kaiområdet i Bergen?",
+            "alternativer": ["Bryggen", "Fisketorget", "Torgallmenningen", "Nordnes"],
+            "korrekt_svar": 0,
+            "forklaring": "Bryggen er UNESCOs verdensarvsted."
+        },
+        {
+            "spørsmål": "Hvilket fjell kan man ta Fløibanen opp til?",
+            "alternativer": ["Ulriken", "Fløyen", "Løvstakken", "Sandviksfjellet"],
+            "korrekt_svar": 1,
+            "forklaring": "Fløibanen går opp til Fløyen, 320 meter over havet."
+        }
+    ],
+    "norsk historie": [
+        {
+            "spørsmål": "Hvilket år ble Norge selvstendig fra Danmark?",
+            "alternativer": ["1814", "1905", "1821", "1830"],
+            "korrekt_svar": 0,
+            "forklaring": "Norge ble selvstendig fra Danmark i 1814."
+        }
+    ]
+}
 
-# Gradio interface for testing
-def gradio_generate_quiz(tema, språk, antall, type_val, vanskelighet):
-    """Gradio wrapper for quiz generation"""
+def generate_quiz_for_soacti(tema, språk, antall, type_val, vanskelighet):
+    """Quiz-generering som SoActi kan bruke"""
     try:
-        import asyncio
-        
-        request = QuizRequest(
-            tema=tema,
-            språk=språk,
-            antall_spørsmål=antall,
-            type=type_val,
-            vanskelighetsgrad=vanskelighet
-        )
-        
-        # Run async function in sync context
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        response = loop.run_until_complete(generate_quiz(request))
-        loop.close()
-        
-        # Format for display
-        output = f"✅ {response.message}\n\n"
-        output += f"🤖 Modell: {response.metadata.get('model_used', 'Ukjent')}\n"
-        output += f"⏱️ Tid: {response.metadata.get('generation_time', 0)}s\n"
-        output += f"🔧 Metode: {response.metadata.get('method', 'Ukjent')}\n\n"
-        
-        for i, q in enumerate(response.questions, 1):
-            output += f"📝 **Spørsmål {i}:** {q.spørsmål}\n"
-            for j, alt in enumerate(q.alternativer):
-                marker = "✅" if j == q.korrekt_svar else "❌"
+        # Normaliser tema
+        tema_lower = tema.lower().strip()
+        
+        # Finn spørsmål
+        if tema_lower in QUIZ_DATABASE:
+            questions = QUIZ_DATABASE[tema_lower]
+        elif "oslo" in tema_lower:
+            questions = QUIZ_DATABASE["oslo"]
+        elif "bergen" in tema_lower:
+            questions = QUIZ_DATABASE["bergen"]
+        elif "historie" in tema_lower:
+            questions = QUIZ_DATABASE["norsk historie"]
+        else:
+            questions = QUIZ_DATABASE["oslo"]  # Default
+        
+        # Begrens antall
+        selected = questions[:antall]
+        
+        # Format output for visning
+        output = f"✅ **Genererte {len(selected)} spørsmål om '{tema}'**\n\n"
+        output += f"🤖 **Modell:** Fallback (forhåndsdefinerte spørsmål)\n"
+        output += f"🌐 **Språk:** {språk}\n"
+        output += f"⏱️ **Tid:** 0.1s\n\n"
+        
+        for i, q in enumerate(selected, 1):
+            output += f"📝 **Spørsmål {i}:** {q['spørsmål']}\n"
+            for j, alt in enumerate(q['alternativer']):
+                marker = "✅" if j == q['korrekt_svar'] else "❌"
                 output += f"   {chr(65+j)}) {alt} {marker}\n"
-            output += f"💡 **Forklaring:** {q.forklaring}\n\n"
+            output += f"💡 **Forklaring:** {q['forklaring']}\n\n"
         
         return output
         
     except Exception as e:
-        retur
+        return f"❌ **Feil:** {str(e)}"
+
+# Gradio interface
+with gr.Blocks(title="SoActi AI Quiz API") as demo:
+    gr.Markdown("# 🧠 SoActi AI Quiz API")
+    gr.Markdown("**Fungerende quiz-generering for SoActi**")
+    
+    with gr.Row():
+        with gr.Column():
+            tema_input = gr.Textbox(
+                label="Tema",
+                value="Oslo",
+                placeholder="Oslo, Bergen, Norsk historie"
+            )
+            språk_input = gr.Dropdown(
+                choices=["no", "en"],
+                label="Språk",
+                value="no"
+            )
+            antall_input = gr.Slider(
+                minimum=1,
+                maximum=5,
+                step=1,
+                label="Antall spørsmål",
+                value=3
+            )
+            type_input = gr.Dropdown(
+                choices=["sted", "rute"],
+                label="Type",
+                value="sted"
+            )
+            vanskelighet_input = gr.Slider(
+                minimum=1,
+                maximum=5,
+                step=1,
+                label="Vanskelighetsgrad",
+                value=3
+            )
+            
+            generate_btn = gr.Button("🚀 Generer Quiz", variant="primary")
+        
+        with gr.Column():
+            output = gr.Textbox(
+                label="Generert Quiz",
+                lines=20,
+                placeholder="Klikk 'Generer Quiz' for å starte..."
+            )
+    
+    generate_btn.click(
+        fn=generate_quiz_for_soacti,
+        inputs=[tema_input, språk_input, antall_input, type_input, vanskelighet_input],
+        outputs=output
+    )
+    
+    gr.Markdown("## 🔗 API URL for SoActi")
+    gr.Markdown("`https://Soacti-soacti-ai-quiz-api.hf.space`")
+
+demo.launch()