Update app.py

app.py

@@ -4,9 +4,7 @@ import time
 import os
 from typing import List, Dict, Any, Optional
 import random
-
-# Import Hugging Face inference API
-from huggingface_hub import InferenceClient
+import requests
 
 # API key validation
 def validate_api_key(api_key: str) -> bool:
@@ -17,199 +15,269 @@ def validate_api_key(api_key: str) -> bool:
         return False
     return api_key == expected_key
 
-# AI Quiz generation with Hugging Face models
+# Improved AI Quiz generation
 class AIQuizGenerator:
     def __init__(self):
         self.api_key = os.environ.get("HUGGINGFACE_API_KEY")
-        if not self.api_key:
-            print("WARNING: HUGGINGFACE_API_KEY not set in environment variables")
+        self.api_url = "https://api-inference.huggingface.co/models/microsoft/DialoGPT-large"
         
-        # Use a more capable model for better quiz generation
-        self.default_model = "microsoft/DialoGPT-medium"
-        self.fallback_model = "google/flan-t5-base"
+        # Backup models to try
+        self.models = [
+            "microsoft/DialoGPT-large",
+            "google/flan-t5-large", 
+            "facebook/blenderbot-400M-distill",
+            "microsoft/DialoGPT-medium"
+        ]
         
-        # Initialize the client
-        self.client = InferenceClient(token=self.api_key) if self.api_key else None
+        print(f"AI Generator initialized. API key available: {bool(self.api_key)}")
         
     def generate_quiz(self, tema: str, antall: int = 3, språk: str = "no") -> List[Dict[str, Any]]:
-        """Generate quiz questions using AI - NO RESTRICTIONS ON TOPIC"""
-        if not self.client:
-            print("No Hugging Face API key available, generating basic questions")
-            return self._generate_basic_questions(tema, antall)
-            
-        try:
-            # Build flexible prompt that works with ANY topic
-            prompt = self._build_flexible_prompt(tema, antall, språk)
-            
-            # Try primary model first
-            start_time = time.time()
+        """Generate quiz questions using Hugging Face Inference API"""
+        
+        if not self.api_key:
+            print("❌ No Hugging Face API key - using enhanced fallback")
+            return self._generate_enhanced_fallback(tema, antall)
+        
+        # Try multiple models until one works
+        for model in self.models:
             try:
-                response = self.client.text_generation(
-                    prompt,
-                    model=self.default_model,
-                    max_new_tokens=1500,
-                    temperature=0.8,
-                    repetition_penalty=1.1,
-                    do_sample=True
-                )
-            except:
-                # Fallback to more reliable model
-                response = self.client.text_generation(
-                    prompt,
-                    model=self.fallback_model,
-                    max_new_tokens=1200,
-                    temperature=0.7,
-                    repetition_penalty=1.2,
-                )
-            
-            generation_time = time.time() - start_time
-            
-            print(f"AI response received in {generation_time:.2f}s for topic: {tema}")
-            print(f"Response preview: {response[:300]}...")
-            
-            # Parse the response into questions
-            questions = self._parse_flexible_response(response, tema, antall)
-            
-            # If we couldn't parse enough questions, generate more basic ones
-            if len(questions) < antall:
-                additional = self._generate_basic_questions(tema, antall - len(questions))
-                questions.extend(additional)
-                
-            return questions[:antall]
-            
-        except Exception as e:
-            print(f"Error generating quiz with AI: {str(e)}")
-            return self._generate_basic_questions(tema, antall)
+                print(f"🤖 Trying model: {model}")
+                questions = self._try_model(model, tema, antall, språk)
+                if questions and len(questions) > 0:
+                    print(f"✅ Success with model: {model}")
+                    return questions
+                    
+            except Exception as e:
+                print(f"❌ Model {model} failed: {str(e)}")
+                continue
+        
+        print("❌ All AI models failed - using enhanced fallback")
+        return self._generate_enhanced_fallback(tema, antall)
     
-    def _build_flexible_prompt(self, tema: str, antall: int, språk: str) -> str:
-        """Build a flexible prompt that works with ANY topic"""
-        language = "norsk" if språk == "no" else "English"
+    def _try_model(self, model: str, tema: str, antall: int, språk: str) -> List[Dict[str, Any]]:
+        """Try a specific model"""
         
-        return f"""Create {antall} quiz questions about "{tema}" in {language}.
-
-IMPORTANT: Generate questions about ANY topic the user requests - there are NO restrictions.
-Whether it's about science, history, pop culture, technology, sports, entertainment, food, travel, or anything else - create relevant questions.
-
-Format each question EXACTLY like this:
+        # Create a very specific prompt
+        prompt = self._create_specific_prompt(tema, antall, språk)
+        
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json"
+        }
+        
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 800,
+                "temperature": 0.7,
+                "do_sample": True,
+                "top_p": 0.9
+            }
+        }
+        
+        api_url = f"https://api-inference.huggingface.co/models/{model}"
+        
+        start_time = time.time()
+        response = requests.post(api_url, headers=headers, json=payload, timeout=30)
+        generation_time = time.time() - start_time
+        
+        print(f"API Response Status: {response.status_code}")
+        
+        if response.status_code != 200:
+            raise Exception(f"API returned {response.status_code}: {response.text}")
+        
+        result = response.json()
+        
+        if isinstance(result, list) and len(result) > 0:
+            generated_text = result[0].get("generated_text", "")
+        else:
+            generated_text = str(result)
+        
+        print(f"Generated text preview: {generated_text[:200]}...")
+        
+        # Parse the response
+        questions = self._parse_ai_response(generated_text, tema, antall)
+        
+        # Add metadata
+        for q in questions:
+            q["_metadata"] = {
+                "model": model,
+                "generation_time": generation_time,
+                "ai_generated": True
+            }
+        
+        return questions
+    
+    def _create_specific_prompt(self, tema: str, antall: int, språk: str) -> str:
+        """Create a very specific prompt for better results"""
+        
+        if språk == "no":
+            return f"""Lag {antall} quiz-spørsmål om {tema} på norsk.
 
-Q1: [Clear question about {tema}]
-A) [First option]
-B) [Second option] 
-C) [Third option]
-D) [Fourth option]
-CORRECT: [A, B, C, or D]
-EXPLANATION: [Brief explanation why this is correct]
+Format: 
+SPØRSMÅL: [konkret spørsmål om {tema}]
+A) [første alternativ]
+B) [andre alternativ] 
+C) [tredje alternativ]
+D) [fjerde alternativ]
+SVAR: [A, B, C eller D]
+FORKLARING: [kort forklaring]
 
-Q2: [Second question about {tema}]
-A) [First option]
-B) [Second option]
-C) [Third option] 
-D) [Fourth option]
-CORRECT: [A, B, C, or D]
-EXPLANATION: [Brief explanation]
+Eksempel om fotball:
+SPØRSMÅL: Hvem vant Ballon d'Or i 2023?
+A) Lionel Messi
+B) Erling Haaland
+C) Kylian Mbappé
+D) Karim Benzema
+SVAR: A
+FORKLARING: Lionel Messi vant sin åttende Ballon d'Or i 2023.
 
-Continue for all {antall} questions about "{tema}".
+Nå lag {antall} spørsmål om {tema}:"""
+        else:
+            return f"""Create {antall} quiz questions about {tema} in English.
 
-Make the questions interesting and educational. Use your knowledge to create accurate, relevant questions about this topic.
+Format:
+QUESTION: [specific question about {tema}]
+A) [first option]
+B) [second option]
+C) [third option] 
+D) [fourth option]
+ANSWER: [A, B, C or D]
+EXPLANATION: [brief explanation]
 
-Topic: {tema}
-Generate {antall} questions now:
-"""
+Now create {antall} questions about {tema}:"""
     
-    def _parse_flexible_response(self, response: str, tema: str, expected_count: int) -> List[Dict[str, Any]]:
-        """Parse AI response with flexible parsing for any topic"""
+    def _parse_ai_response(self, text: str, tema: str, expected_count: int) -> List[Dict[str, Any]]:
+        """Parse AI response into structured questions"""
         questions = []
         
-        # Split response into potential question blocks
-        lines = response.split('\n')
-        current_question = {}
-        current_options = []
+        # Split into sections
+        sections = text.split("SPØRSMÅL:") if "SPØRSMÅL:" in text else text.split("QUESTION:")
         
-        for line in lines:
-            line = line.strip()
-            if not line:
+        for section in sections[1:]:  # Skip first empty section
+            try:
+                question = self._parse_single_question(section, tema)
+                if question:
+                    questions.append(question)
+            except Exception as e:
+                print(f"Error parsing question section: {e}")
                 continue
-                
-            # Look for question patterns
-            if line.startswith(('Q1:', 'Q2:', 'Q3:', 'Q4:', 'Q5:')) or 'SPØRSMÅL:' in line.upper():
-                # Save previous question if complete
-                if self._is_complete_question(current_question, current_options):
-                    current_question["alternativer"] = current_options
-                    questions.append(current_question)
-                    
-                # Start new question
-                question_text = line.split(':', 1)[1].strip() if ':' in line else line
-                current_question = {"spørsmål": question_text}
-                current_options = []
-                
-            elif line.startswith(('A)', 'B)', 'C)', 'D)')):
-                option = line[2:].strip()
-                if option:
-                    current_options.append(option)
-                    
-            elif 'CORRECT:' in line.upper() or 'KORREKT:' in line.upper():
-                correct_part = line.upper().split('CORRECT:')[-1].split('KORREKT:')[-1].strip()
-                if correct_part and correct_part[0] in ['A', 'B', 'C', 'D']:
-                    current_question["korrekt_svar"] = ['A', 'B', 'C', 'D'].index(correct_part[0])
-                    
-            elif 'EXPLANATION:' in line.upper() or 'FORKLARING:' in line.upper():
-                explanation = line.split(':')[1].strip() if ':' in line else line
-                current_question["forklaring"] = explanation
-        
-        # Add the last question if complete
-        if self._is_complete_question(current_question, current_options):
-            current_question["alternativer"] = current_options
-            questions.append(current_question)
-            
-        return questions
+        
+        return questions[:expected_count]
     
-    def _is_complete_question(self, question: Dict, options: List) -> bool:
-        """Check if a question is complete"""
-        return (
-            "spørsmål" in question and 
-            len(options) >= 3 and  # At least 3 options
-            "korrekt_svar" in question and
-            question["korrekt_svar"] < len(options)
-        )
+    def _parse_single_question(self, section: str, tema: str) -> Optional[Dict[str, Any]]:
+        """Parse a single question from text"""
+        lines = [line.strip() for line in section.split('\n') if line.strip()]
+        
+        if not lines:
+            return None
+        
+        question_text = lines[0].strip()
+        options = []
+        correct_answer = 0
+        explanation = ""
+        
+        for line in lines[1:]:
+            if line.startswith(('A)', 'B)', 'C)', 'D)')):
+                options.append(line[2:].strip())
+            elif line.startswith(('SVAR:', 'ANSWER:')):
+                answer_part = line.split(':', 1)[1].strip()
+                if answer_part in ['A', 'B', 'C', 'D']:
+                    correct_answer = ['A', 'B', 'C', 'D'].index(answer_part)
+            elif line.startswith(('FORKLARING:', 'EXPLANATION:')):
+                explanation = line.split(':', 1)[1].strip()
+        
+        if len(options) >= 3 and question_text:
+            # Ensure we have 4 options
+            while len(options) < 4:
+                options.append(f"Alternativ {len(options) + 1}")
+            
+            return {
+                "spørsmål": question_text,
+                "alternativer": options[:4],
+                "korrekt_svar": correct_answer,
+                "forklaring": explanation or f"Spørsmål om {tema}"
+            }
+        
+        return None
     
-    def _generate_basic_questions(self, tema: str, antall: int) -> List[Dict[str, Any]]:
-        """Generate basic questions when AI fails - works with ANY topic"""
+    def _generate_enhanced_fallback(self, tema: str, antall: int) -> List[Dict[str, Any]]:
+        """Generate better fallback questions based on topic analysis"""
+        
+        # Analyze topic to create better questions
+        tema_lower = tema.lower()
         questions = []
         
-        # Generate generic but relevant questions for any topic
-        question_templates = [
-            f"Hva er det mest kjente ved {tema}?",
-            f"Hvilket år er viktig i historien til {tema}?", 
-            f"Hvor finner man vanligvis {tema}?",
-            f"Hva karakteriserer {tema}?",
-            f"Hvilken betydning har {tema}?"
-        ]
+        # Football/Soccer specific
+        if any(word in tema_lower for word in ['fotball', 'football', 'soccer', 'messi', 'ronaldo', 'haaland']):
+            questions = [
+                {
+                    "spørsmål": "Hvem regnes som en av verdens beste fotballspillere gjennom tidene?",
+                    "alternativer": ["Lionel Messi", "Michael Jordan", "Tiger Woods", "Usain Bolt"],
+                    "korrekt_svar": 0,
+                    "forklaring": "Lionel Messi regnes som en av de beste fotballspillerne noensinne med 8 Ballon d'Or-priser."
+                },
+                {
+                    "spørsmål": "Hvilket land har vunnet flest VM i fotball?",
+                    "alternativer": ["Tyskland", "Argentina", "Brasil", "Frankrike"],
+                    "korrekt_svar": 2,
+                    "forklaring": "Brasil har vunnet VM i fotball 5 ganger (1958, 1962, 1970, 1994, 2002)."
+                },
+                {
+                    "spørsmål": "Hva kalles den prestisjetunge individuelle prisen i fotball?",
+                    "alternativer": ["Golden Boot", "Ballon d'Or", "FIFA Award", "Champions Trophy"],
+                    "korrekt_svar": 1,
+                    "forklaring": "Ballon d'Or er den mest prestisjetunge individuelle prisen i fotball."
+                }
+            ]
         
-        for i in range(min(antall, len(question_templates))):
-            questions.append({
-                "spørsmål": question_templates[i],
-                "alternativer": [
-                    f"Alternativ A om {tema}",
-                    f"Alternativ B om {tema}", 
-                    f"Alternativ C om {tema}",
-                    f"Alternativ D om {tema}"
-                ],
-                "korrekt_svar": 0,  # Always A for simplicity
-                "forklaring": f"Dette er et generert spørsmål om {tema}. For mer nøyaktige spørsmål, prøv igjen - AI-systemet lærer kontinuerlig."
-            })
-            
-        return questions
+        # Technology specific
+        elif any(word in tema_lower for word in ['teknologi', 'technology', 'ai', 'computer', 'programming']):
+            questions = [
+                {
+                    "spørsmål": f"Hva er en viktig utvikling innen {tema}?",
+                    "alternativer": ["Kunstig intelligens", "Dampmaskin", "Hjulet", "Ild"],
+                    "korrekt_svar": 0,
+                    "forklaring": f"Kunstig intelligens er en av de viktigste utviklingene innen moderne {tema}."
+                }
+            ]
+        
+        # Generic but better questions
+        if not questions:
+            questions = [
+                {
+                    "spørsmål": f"Hva er karakteristisk for {tema}?",
+                    "alternativer": [f"Viktig egenskap ved {tema}", "Irrelevant faktor", "Tilfeldig element", "Ukjent aspekt"],
+                    "korrekt_svar": 0,
+                    "forklaring": f"Dette spørsmålet handler om de karakteristiske egenskapene ved {tema}."
+                },
+                {
+                    "spørsmål": f"Hvor er {tema} mest relevant?",
+                    "alternativer": ["I relevant kontekst", "I irrelevant sammenheng", "Ingen steder", "Overalt"],
+                    "korrekt_svar": 0,
+                    "forklaring": f"{tema} er mest relevant i sin naturlige kontekst."
+                }
+            ]
+        
+        # Add metadata to show these are fallbacks
+        for q in questions:
+            q["_metadata"] = {
+                "model": "enhanced_fallback",
+                "generation_time": 0.1,
+                "ai_generated": False
+            }
+        
+        return questions[:antall]
 
 # Initialize the AI generator
 quiz_generator = AIQuizGenerator()
 
-# API endpoint for quiz generation - NO TOPIC RESTRICTIONS
+# API endpoint for quiz generation
 def generate_quiz_api(tema: str, språk: str = "no", antall_spørsmål: int = 3, 
                      type: str = "sted", vanskelighetsgrad: int = 3, 
                      api_key: str = None) -> Dict[str, Any]:
-    """API endpoint for quiz generation - ACCEPTS ANY TOPIC"""
+    """API endpoint for quiz generation"""
     
-    # Validate API key
     if not validate_api_key(api_key):
         return {
             "success": False,
@@ -217,7 +285,6 @@ def generate_quiz_api(tema: str, språk: str = "no", antall_spørsmål: int = 3,
             "questions": []
         }
     
-    # NO TOPIC FILTERING - Accept absolutely anything
     if not tema or len(tema.strip()) < 2:
         return {
             "success": False,
@@ -226,21 +293,26 @@ def generate_quiz_api(tema: str, språk: str = "no", antall_spørsmål: int = 3,
         }
     
     try:
-        # Generate questions with AI - NO RESTRICTIONS
         start_time = time.time()
         questions = quiz_generator.generate_quiz(tema.strip(), antall_spørsmål, språk)
-        generation_time = time.time() - start_time
+        total_time = time.time() - start_time
+        
+        # Check if we got real AI questions or fallbacks
+        ai_generated = any(q.get("_metadata", {}).get("ai_generated", False) for q in questions)
+        model_used = questions[0].get("_metadata", {}).get("model", "unknown") if questions else "none"
         
         return {
             "success": True,
             "questions": questions,
             "metadata": {
-                "generation_time": round(generation_time, 2),
-                "model_used": quiz_generator.default_model,
+                "generation_time": round(total_time, 2),
+                "model_used": model_used,
                 "topic": tema,
-                "unrestricted": True  # Flag to show no restrictions
+                "ai_generated": ai_generated,
+                "fallback_used": not ai_generated
             },
-            "message": f"Genererte {len(questions)} spørsmål om '{tema}' - ingen begrensninger!"
+            "message": f"Genererte {len(questions)} spørsmål om '{tema}'" + 
+                      (" med AI" if ai_generated else " med forbedret fallback")
         }
     except Exception as e:
         print(f"Error in generate_quiz_api: {str(e)}")
@@ -250,9 +322,9 @@ def generate_quiz_api(tema: str, språk: str = "no", antall_spørsmål: int = 3,
             "questions": []
         }
 
-# Gradio interface - emphasize NO RESTRICTIONS
+# Gradio interface
 def generate_quiz_gradio(tema, antall, api_key=None):
-    """Gradio wrapper - accepts ANY topic"""
+    """Gradio wrapper"""
     if api_key and not validate_api_key(api_key):
         return "❌ **Ugyldig API-nøkkel**"
         
@@ -266,13 +338,20 @@ def generate_quiz_gradio(tema, antall, api_key=None):
             return f"❌ **Feil:** {result['message']}"
             
         questions = result["questions"]
-        model = result["metadata"]["model_used"]
-        time_taken = result["metadata"]["generation_time"]
+        metadata = result["metadata"]
+        
+        # Show different info based on whether AI was used
+        if metadata.get("ai_generated", False):
+            status_icon = "🤖"
+            status_text = "AI-generert"
+        else:
+            status_icon = "🔄"
+            status_text = "Forbedret fallback"
         
         output = f"✅ **Genererte {len(questions)} spørsmål om '{tema}'**\n\n"
-        output += f"🤖 **Modell:** {model}\n"
-        output += f"⏱️ **Tid:** {time_taken}s\n"
-        output += f"🔓 **Ingen begrensninger** - alle temaer er tillatt!\n\n"
+        output += f"{status_icon} **Type:** {status_text}\n"
+        output += f"⚙️ **Modell:** {metadata['model_used']}\n"
+        output += f"⏱️ **Tid:** {metadata['generation_time']}s\n\n"
         
         for i, q in enumerate(questions, 1):
             output += f"📝 **Spørsmål {i}:** {q['spørsmål']}\n"
@@ -286,21 +365,25 @@ def generate_quiz_gradio(tema, antall, api_key=None):
     except Exception as e:
         return f"❌ **Feil:** {str(e)}"
 
-# Health check endpoint
+# Health check
 def health_check():
-    return {"status": "healthy", "timestamp": time.time(), "unrestricted": True}
+    return {
+        "status": "healthy", 
+        "timestamp": time.time(),
+        "ai_available": bool(os.environ.get("HUGGINGFACE_API_KEY"))
+    }
 
-# Gradio interface - emphasize freedom
-with gr.Blocks(title="SoActi AI Quiz API - Ubegrenset") as demo:
-    gr.Markdown("# 🧠 SoActi AI Quiz API - Ubegrenset")
-    gr.Markdown("**🔓 Lag quiz om ABSOLUTT HVASOM HELST - ingen begrensninger!**")
+# Gradio interface
+with gr.Blocks(title="SoActi AI Quiz API - Forbedret") as demo:
+    gr.Markdown("# 🧠 SoActi AI Quiz API - Forbedret")
+    gr.Markdown("**🚀 Ekte AI-generering med forbedret fallback**")
     
     with gr.Row():
         with gr.Column():
             tema_input = gr.Textbox(
-                label="Tema (skriv hva som helst!)",
-                value="",
-                placeholder="Fotball, Harry Potter, Kvantfysikk, Baking, TikTok, Dinosaurer, Programmering, K-pop, Filosofi, Gaming..."
+                label="Tema",
+                value="verdens beste fotballspillere",
+                placeholder="Fotball, teknologi, historie, mat, filmer..."
             )
             antall_input = gr.Slider(
                 minimum=1,
@@ -310,18 +393,18 @@ with gr.Blocks(title="SoActi AI Quiz API - Ubegrenset") as demo:
                 value=3
             )
             api_key_input = gr.Textbox(
-                label="API-nøkkel (for testing)",
+                label="API-nøkkel",
                 placeholder="Skriv inn API-nøkkel...",
                 type="password"
             )
             
-            generate_btn = gr.Button("🚀 Generer Quiz om HVASOM HELST!", variant="primary")
+            generate_btn = gr.Button("🚀 Generer Forbedret Quiz!", variant="primary")
         
         with gr.Column():
             output = gr.Textbox(
                 label="Generert Quiz",
                 lines=20,
-                placeholder="Skriv inn HVILKET SOM HELST tema og klikk 'Generer Quiz'!\n\nEksempler:\n- Marvel filmer\n- Norsk rap\n- Kryptovaluta\n- Yoga\n- Sushi\n- Elon Musk\n- Klimaendringer\n- Netflix serier\n- Fotografi\n- Skateboard"
+                placeholder="Skriv inn et tema og test den forbedrede AI-genereringen!"
             )
     
     generate_btn.click(
@@ -330,16 +413,15 @@ with gr.Blocks(title="SoActi AI Quiz API - Ubegrenset") as demo:
         outputs=output
     )
     
-    gr.Markdown("## 🔗 API for SoActi")
+    gr.Markdown("## 🔗 API Endepunkt")
     gr.Markdown("`POST https://Soacti-soacti-ai-quiz-api.hf.space/generate-quiz`")
-    gr.Markdown("**🔓 Ingen begrensninger - brukere kan spørre om hva som helst!**")
 
-# FastAPI setup with CORS for unrestricted access
+# FastAPI setup
 from fastapi import FastAPI, HTTPException, Depends, Header
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
-app = FastAPI(title="SoActi Quiz API - Ubegrenset")
+app = FastAPI(title="SoActi Quiz API - Forbedret")
 
 app.add_middleware(
     CORSMiddleware,
@@ -350,7 +432,7 @@ app.add_middleware(
 )
 
 class QuizRequest(BaseModel):
-    tema: str  # NO restrictions on what this can be
+    tema: str
     språk: str = "no"
     antall_spørsmål: int = 3
     type: str = "sted"
@@ -368,9 +450,8 @@ async def get_api_key(authorization: str = Header(None)):
 
 @app.post("/generate-quiz")
 async def api_generate_quiz(request: QuizRequest, api_key: str = Depends(get_api_key)):
-    """Generate quiz about ANY topic - no restrictions"""
     result = generate_quiz_api(
-        request.tema,  # Accept ANY topic
+        request.tema, 
         request.språk, 
         request.antall_spørsmål, 
         request.type,