Upload 13 files

app.py

@@ -0,0 +1,520 @@
+import streamlit as st
+import sqlite3
+import json
+import random
+from datetime import datetime
+import os
+
+# Import our custom modules
+from components.mcq_generator import MCQGenerator
+from utils.wiki_api import WikiAPI
+from utils.translator import Translator
+
+# Page configuration
+st.set_page_config(
+    page_title="TriviaVerse - Multilingual Quiz Generator",
+    page_icon="🧠",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Initialize session state
+if 'current_quiz' not in st.session_state:
+    st.session_state.current_quiz = None
+if 'score' not in st.session_state:
+    st.session_state.score = 0
+if 'current_question' not in st.session_state:
+    st.session_state.current_question = 0
+if 'user_answers' not in st.session_state:
+    st.session_state.user_answers = []
+
+# Initialize components
+@st.cache_resource
+def initialize_components():
+    wiki_api = WikiAPI()
+    translator = Translator()
+    mcq_generator = MCQGenerator()
+    return wiki_api, translator, mcq_generator
+
+def initialize_database():
+    """Initialize SQLite database for offline storage"""
+    conn = sqlite3.connect('triviaverse.db')
+    cursor = conn.cursor()
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS cached_content (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            topic TEXT NOT NULL,
+            language TEXT NOT NULL,
+            content TEXT NOT NULL,
+            summary TEXT,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    cursor.execute('''
+        CREATE TABLE IF NOT EXISTS quiz_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            topic TEXT NOT NULL,
+            language TEXT NOT NULL,
+            difficulty TEXT NOT NULL,
+            mode TEXT NOT NULL,
+            score INTEGER,
+            total_questions INTEGER,
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        )
+    ''')
+    
+    conn.commit()
+    conn.close()
+
+def main():
+    # Initialize database
+    initialize_database()
+    
+    # Initialize components
+    wiki_api, translator, mcq_generator = initialize_components()
+    
+    # Custom CSS
+    st.markdown("""
+    <style>
+        .main-header {
+            text-align: center;
+            background: linear-gradient(90deg, #667eea 0%, #764ba2 100%);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            background-clip: text;
+            font-size: 3rem;
+            font-weight: bold;
+            margin-bottom: 2rem;
+        }
+        
+        .quiz-card {
+            background: white;
+            padding: 2rem;
+            border-radius: 15px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+            margin: 1rem 0;
+        }
+        
+        .score-display {
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            padding: 1rem;
+            border-radius: 10px;
+            text-align: center;
+            font-size: 1.2rem;
+            font-weight: bold;
+        }
+        
+        .question-card {
+            background: #f8f9fa;
+            padding: 1.5rem;
+            border-radius: 10px;
+            border-left: 4px solid #667eea;
+            margin: 1rem 0;
+        }
+        
+        .sidebar-section {
+            background: #f0f2f6;
+            padding: 1rem;
+            border-radius: 10px;
+            margin: 1rem 0;
+        }
+    </style>
+    """, unsafe_allow_html=True)
+    
+    # Main header
+    st.markdown('<h1 class="main-header">🧠 TriviaVerse</h1>', unsafe_allow_html=True)
+    st.markdown('<p style="text-align: center; font-size: 1.2rem; color: #666;">Multilingual AI-Powered Quiz Generator</p>', unsafe_allow_html=True)
+    
+    # Sidebar configuration
+    with st.sidebar:
+        st.markdown('<div class="sidebar-section">', unsafe_allow_html=True)
+        st.header("🎯 Quiz Configuration")
+        
+        # Language selection
+        languages = {
+            'en': 'English',
+            'hi': 'हिंदी (Hindi)',
+            'te': 'తెలుగు (Telugu)',
+            'ta': 'தமிழ் (Tamil)',
+            'kn': 'ಕನ್ನಡ (Kannada)',
+            'bn': 'বাংলা (Bengali)'
+        }
+        
+        selected_language = st.selectbox(
+            "🌐 Select Language",
+            options=list(languages.keys()),
+            format_func=lambda x: languages[x],
+            index=0
+        )
+        
+        # Topic input
+        topic = st.text_input("📚 Enter Topic", placeholder="e.g., Indian History, Science, Technology")
+        
+        # Mode selection
+        mode = st.selectbox(
+            "🎮 Select Mode",
+            options=['mcq', 'flashcard', 'game'],
+            format_func=lambda x: {
+                'mcq': '📝 Multiple Choice Questions',
+                'flashcard': '🃏 Flashcards',
+                'game': '🎲 Quiz Game'
+            }[x]
+        )
+        
+        # Difficulty level
+        difficulty = st.selectbox(
+            "⚡ Difficulty Level",
+            options=['easy', 'medium', 'hard'],
+            format_func=lambda x: {
+                'easy': '🟢 Easy',
+                'medium': '🟡 Medium', 
+                'hard': '🔴 Hard'
+            }[x]
+        )
+        
+        # Online/Offline toggle
+        is_online = st.toggle("🌐 Online Mode", value=True)
+        
+        # Number of questions
+        num_questions = st.slider("📊 Number of Questions", min_value=5, max_value=20, value=10)
+        
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Generate quiz button
+        if st.button("🚀 Generate Quiz", type="primary", use_container_width=True):
+            if topic:
+                generate_quiz(wiki_api, translator, mcq_generator, topic, selected_language, 
+                            difficulty, mode, is_online, num_questions)
+            else:
+                st.error("Please enter a topic!")
+        
+        # Quiz history
+        st.markdown('<div class="sidebar-section">', unsafe_allow_html=True)
+        st.subheader("📈 Recent Quizzes")
+        display_quiz_history()
+        st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Main content area
+    if st.session_state.current_quiz:
+        display_quiz()
+    else:
+        display_welcome_screen()
+
+def generate_quiz(wiki_api, translator, mcq_generator, topic, language, difficulty, mode, is_online, num_questions):
+    """Generate a new quiz based on user parameters"""
+    
+    with st.spinner(f"🔍 Fetching content about '{topic}'..."):
+        # Fetch content from Wikipedia
+        if is_online:
+            content = wiki_api.fetch_content(topic, language)
+            if not content:
+                st.error("❌ Could not fetch content. Try offline mode or a different topic.")
+                return
+        else:
+            content = load_cached_content(topic, language)
+            if not content:
+                st.error("❌ No cached content found. Please try online mode first.")
+                return
+    
+    with st.spinner("🧠 Generating quiz questions..."):
+        # Generate questions
+        questions = mcq_generator.generate_questions(
+            content, difficulty, num_questions, language, translator
+        )
+        
+        if not questions:
+            st.error("❌ Could not generate questions. Please try a different topic.")
+            return
+    
+    # Store quiz in session state
+    st.session_state.current_quiz = {
+        'topic': topic,
+        'language': language,
+        'difficulty': difficulty,
+        'mode': mode,
+        'questions': questions,
+        'created_at': datetime.now()
+    }
+    
+    # Reset quiz state
+    st.session_state.current_question = 0
+    st.session_state.score = 0
+    st.session_state.user_answers = []
+    
+    # Cache content for offline use
+    if is_online:
+        cache_content(topic, language, content)
+    
+    st.success(f"✅ Generated {len(questions)} questions successfully!")
+    st.rerun()
+
+def display_quiz():
+    """Display the current quiz"""
+    quiz = st.session_state.current_quiz
+    questions = quiz['questions']
+    current_q = st.session_state.current_question
+    
+    # Progress bar
+    progress = (current_q + 1) / len(questions)
+    st.progress(progress, text=f"Question {current_q + 1} of {len(questions)}")
+    
+    # Score display
+    if current_q > 0:
+        st.markdown(f'<div class="score-display">Score: {st.session_state.score}/{current_q}</div>', 
+                   unsafe_allow_html=True)
+    
+    if current_q < len(questions):
+        question = questions[current_q]
+        
+        # Display question
+        st.markdown(f'<div class="question-card">', unsafe_allow_html=True)
+        st.markdown(f"### Question {current_q + 1}")
+        st.markdown(f"**{question['question']}**")
+        st.markdown('</div>', unsafe_allow_html=True)
+        
+        # Display options
+        if quiz['mode'] == 'mcq':
+            display_mcq_options(question, current_q)
+        elif quiz['mode'] == 'flashcard':
+            display_flashcard(question, current_q)
+        else:  # game mode
+            display_game_mode(question, current_q)
+    
+    else:
+        # Quiz completed
+        display_quiz_results()
+
+def display_mcq_options(question, current_q):
+    """Display multiple choice options"""
+    options = question['options']
+    
+    # Use unique key for each question
+    selected_option = st.radio(
+        "Select your answer:",
+        options=options,
+        key=f"q_{current_q}",
+        index=None
+    )
+    
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        if st.button("Submit Answer", key=f"submit_{current_q}"):
+            if selected_option is not None:
+                answer_index = options.index(selected_option)
+                is_correct = answer_index == question['correct_answer']
+                
+                if is_correct:
+                    st.success("✅ Correct!")
+                    st.session_state.score += 1
+                else:
+                    st.error(f"❌ Incorrect! The correct answer is: {options[question['correct_answer']]}")
+                
+                # Show explanation
+                if question.get('explanation'):
+                    st.info(f"💡 Explanation: {question['explanation']}")
+                
+                st.session_state.user_answers.append({
+                    'question': question['question'],
+                    'user_answer': selected_option,
+                    'correct_answer': options[question['correct_answer']],
+                    'is_correct': is_correct
+                })
+                
+                st.session_state.current_question += 1
+                
+                # Auto-advance after 3 seconds
+                st.rerun()
+            else:
+                st.warning("Please select an answer!")
+    
+    with col2:
+        if st.button("Skip Question", key=f"skip_{current_q}"):
+            st.session_state.user_answers.append({
+                'question': question['question'],
+                'user_answer': "Skipped",
+                'correct_answer': options[question['correct_answer']],
+                'is_correct': False
+            })
+            st.session_state.current_question += 1
+            st.rerun()
+
+def display_flashcard(question, current_q):
+    """Display flashcard mode"""
+    if f"show_answer_{current_q}" not in st.session_state:
+        st.session_state[f"show_answer_{current_q}"] = False
+    
+    if not st.session_state[f"show_answer_{current_q}"]:
+        if st.button("🔍 Show Answer", key=f"show_{current_q}"):
+            st.session_state[f"show_answer_{current_q}"] = True
+            st.rerun()
+    else:
+        st.success(f"**Answer:** {question['options'][question['correct_answer']]}")
+        
+        if question.get('explanation'):
+            st.info(f"💡 Explanation: {question['explanation']}")
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("✅ I knew it!", key=f"correct_{current_q}"):
+                st.session_state.score += 1
+                st.session_state.current_question += 1
+                st.rerun()
+        
+        with col2:
+            if st.button("❌ I didn't know", key=f"incorrect_{current_q}"):
+                st.session_state.current_question += 1
+                st.rerun()
+
+def display_game_mode(question, current_q):
+    """Display game mode with timer"""
+    # Simple game mode - similar to MCQ but with time pressure
+    st.markdown("⏰ **Quick Answer Mode!**")
+    display_mcq_options(question, current_q)
+
+def display_quiz_results():
+    """Display final quiz results"""
+    quiz = st.session_state.current_quiz
+    total_questions = len(quiz['questions'])
+    score = st.session_state.score
+    percentage = (score / total_questions) * 100
+    
+    st.balloons()
+    
+    # Results header
+    st.markdown('<div class="score-display">', unsafe_allow_html=True)
+    st.markdown(f"## 🎉 Quiz Completed!")
+    st.markdown(f"### Final Score: {score}/{total_questions} ({percentage:.1f}%)")
+    st.markdown('</div>', unsafe_allow_html=True)
+    
+    # Performance message
+    if percentage >= 80:
+        st.success("🌟 Excellent! You're a trivia master!")
+    elif percentage >= 60:
+        st.info("👍 Good job! Keep learning!")
+    else:
+        st.warning("📚 Keep studying! You'll do better next time!")
+    
+    # Save to history
+    save_quiz_history(quiz, score, total_questions)
+    
+    # Detailed results
+    st.subheader("📊 Detailed Results")
+    for i, answer in enumerate(st.session_state.user_answers):
+        with st.expander(f"Question {i+1}: {answer['question'][:50]}..."):
+            st.write(f"**Your Answer:** {answer['user_answer']}")
+            st.write(f"**Correct Answer:** {answer['correct_answer']}")
+            if answer['is_correct']:
+                st.success("✅ Correct")
+            else:
+                st.error("❌ Incorrect")
+    
+    # Reset button
+    if st.button("🔄 Take Another Quiz", type="primary"):
+        st.session_state.current_quiz = None
+        st.session_state.current_question = 0
+        st.session_state.score = 0
+        st.session_state.user_answers = []
+        st.rerun()
+
+def display_welcome_screen():
+    """Display welcome screen when no quiz is active"""
+    col1, col2, col3 = st.columns([1, 2, 1])
+    
+    with col2:
+        st.markdown("""
+        <div style="text-align: center; padding: 2rem;">
+            <h2>🎯 Welcome to TriviaVerse!</h2>
+            <p style="font-size: 1.1rem; color: #666;">
+                Generate intelligent quizzes on any topic in multiple Indian languages
+            </p>
+            
+            <div style="margin: 2rem 0;">
+                <h3>✨ Features</h3>
+                <ul style="text-align: left; display: inline-block;">
+                    <li>🌐 Multi-language support (Hindi, Telugu, Tamil, Kannada, Bengali)</li>
+                    <li>📚 Wikipedia & Wikidata integration</li>
+                    <li>🧠 AI-powered question generation</li>
+                    <li>🎮 Multiple quiz modes (MCQ, Flashcards, Games)</li>
+                    <li>📊 Difficulty levels and progress tracking</li>
+                    <li>💾 Offline mode with caching</li>
+                </ul>
+            </div>
+            
+            <p style="color: #667eea; font-weight: bold;">
+                👈 Configure your quiz in the sidebar and click "Generate Quiz" to start!
+            </p>
+        </div>
+        """, unsafe_allow_html=True)
+
+def load_cached_content(topic, language):
+    """Load content from local cache"""
+    conn = sqlite3.connect('triviaverse.db')
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT content FROM cached_content 
+        WHERE topic = ? AND language = ? 
+        ORDER BY created_at DESC LIMIT 1
+    """, (topic, language))
+    
+    result = cursor.fetchone()
+    conn.close()
+    
+    return result[0] if result else None
+
+def cache_content(topic, language, content):
+    """Cache content for offline use"""
+    conn = sqlite3.connect('triviaverse.db')
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        INSERT INTO cached_content (topic, language, content)
+        VALUES (?, ?, ?)
+    """, (topic, language, content))
+    
+    conn.commit()
+    conn.close()
+
+def save_quiz_history(quiz, score, total_questions):
+    """Save quiz results to history"""
+    conn = sqlite3.connect('triviaverse.db')
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        INSERT INTO quiz_history (topic, language, difficulty, mode, score, total_questions)
+        VALUES (?, ?, ?, ?, ?, ?)
+    """, (quiz['topic'], quiz['language'], quiz['difficulty'], 
+          quiz['mode'], score, total_questions))
+    
+    conn.commit()
+    conn.close()
+
+def display_quiz_history():
+    """Display recent quiz history"""
+    conn = sqlite3.connect('triviaverse.db')
+    cursor = conn.cursor()
+    
+    cursor.execute("""
+        SELECT topic, score, total_questions, created_at
+        FROM quiz_history
+        ORDER BY created_at DESC
+        LIMIT 5
+    """)
+    
+    results = cursor.fetchall()
+    conn.close()
+    
+    if results:
+        for result in results:
+            topic, score, total, created_at = result
+            percentage = (score / total) * 100
+            st.write(f"📚 {topic}: {score}/{total} ({percentage:.0f}%)")
+    else:
+        st.write("No quiz history yet!")
+
+if __name__ == "__main__":
+    main()

assets/.gitkeep

@@ -0,0 +1 @@
+# Assets directory for images, icons, etc.

components/__init__.py

@@ -0,0 +1 @@
+# Components package

components/mcq_generator.py

@@ -0,0 +1,301 @@
+import random
+import re
+from typing import List, Dict, Any
+
+class MCQGenerator:
+    """Generate Multiple Choice Questions from content"""
+    
+    def __init__(self):
+        self.question_templates = {
+            'easy': [
+                "What is {entity}?",
+                "When did {event} happen?",
+                "Where is {place} located?",
+                "Who was {person}?"
+            ],
+            'medium': [
+                "What was the significance of {event}?",
+                "How did {process} work?",
+                "What caused {event}?",
+                "What were the effects of {action}?"
+            ],
+            'hard': [
+                "Analyze the relationship between {concept1} and {concept2}.",
+                "What would have happened if {event} had not occurred?",
+                "Compare and contrast {item1} and {item2}.",
+                "Evaluate the impact of {factor} on {outcome}."
+            ]
+        }
+    
+    def generate_questions(self, content: str, difficulty: str, num_questions: int, 
+                          language: str, translator) -> List[Dict[str, Any]]:
+        """Generate MCQ questions from content"""
+        
+        if not content or len(content.strip()) < 100:
+            return self._generate_fallback_questions(difficulty, num_questions, language, translator)
+        
+        # Extract key information from content
+        sentences = self._extract_sentences(content)
+        key_facts = self._extract_key_facts(sentences)
+        
+        questions = []
+        
+        for i in range(num_questions):
+            if i < len(key_facts):
+                question = self._create_question_from_fact(key_facts[i], difficulty, language, translator)
+            else:
+                # Generate additional questions using templates
+                question = self._generate_template_question(content, difficulty, language, translator)
+            
+            if question:
+                questions.append(question)
+        
+        return questions[:num_questions]
+    
+    def _extract_sentences(self, content: str) -> List[str]:
+        """Extract sentences from content"""
+        # Simple sentence splitting
+        sentences = re.split(r'[.!?]+', content)
+        sentences = [s.strip() for s in sentences if len(s.strip()) > 20]
+        return sentences[:50]  # Limit to first 50 sentences
+    
+    def _extract_key_facts(self, sentences: List[str]) -> List[Dict[str, str]]:
+        """Extract key facts from sentences"""
+        facts = []
+        
+        for sentence in sentences:
+            # Look for sentences with dates, numbers, or proper nouns
+            if self._contains_factual_info(sentence):
+                fact = {
+                    'sentence': sentence,
+                    'type': self._classify_fact_type(sentence)
+                }
+                facts.append(fact)
+        
+        return facts
+    
+    def _contains_factual_info(self, sentence: str) -> bool:
+        """Check if sentence contains factual information"""
+        # Look for dates, numbers, proper nouns, etc.
+        patterns = [
+            r'\b\d{4}\b',  # Years
+            r'\b\d+\b',    # Numbers
+            r'\b[A-Z][a-z]+\s+[A-Z][a-z]+\b',  # Proper nouns
+            r'\bin\s+\d{4}\b',  # "in 1947"
+            r'\bwas\s+born\b',  # Birth information
+            r'\bwas\s+founded\b',  # Foundation information
+        ]
+        
+        return any(re.search(pattern, sentence) for pattern in patterns)
+    
+    def _classify_fact_type(self, sentence: str) -> str:
+        """Classify the type of fact"""
+        if re.search(r'\b\d{4}\b', sentence):
+            return 'date'
+        elif re.search(r'\b\d+\b', sentence):
+            return 'number'
+        elif re.search(r'\b[A-Z][a-z]+\s+[A-Z][a-z]+\b', sentence):
+            return 'person_place'
+        else:
+            return 'general'
+    
+    def _create_question_from_fact(self, fact: Dict[str, str], difficulty: str, 
+                                  language: str, translator) -> Dict[str, Any]:
+        """Create a question from a fact"""
+        sentence = fact['sentence']
+        fact_type = fact['type']
+        
+        # Extract the main subject and predicate
+        question_text, correct_answer = self._generate_question_and_answer(sentence, fact_type, difficulty)
+        
+        if not question_text or not correct_answer:
+            return None
+        
+        # Generate distractors (wrong options)
+        options = self._generate_options(correct_answer, fact_type)
+        
+        # Translate if needed
+        if language != 'en':
+            question_text = translator.translate_text(question_text, language)
+            options = [translator.translate_text(opt, language) for opt in options]
+        
+        return {
+            'question': question_text,
+            'options': options,
+            'correct_answer': 0,  # Correct answer is always first, will be shuffled
+            'explanation': f"Based on the text: {sentence[:100]}...",
+            'difficulty': difficulty,
+            'type': fact_type
+        }
+    
+    def _generate_question_and_answer(self, sentence: str, fact_type: str, difficulty: str):
+        """Generate question and answer from sentence"""
+        
+        if fact_type == 'date':
+            # Extract year/date
+            date_match = re.search(r'\b(\d{4})\b', sentence)
+            if date_match:
+                year = date_match.group(1)
+                question = f"In which year did the event mentioned in this context occur?"
+                return question, year
+        
+        elif fact_type == 'number':
+            # Extract number
+            num_match = re.search(r'\b(\d+)\b', sentence)
+            if num_match:
+                number = num_match.group(1)
+                question = f"What is the number mentioned in this context?"
+                return question, number
+        
+        elif fact_type == 'person_place':
+            # Extract proper noun
+            name_match = re.search(r'\b([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)\b', sentence)
+            if name_match:
+                name = name_match.group(1)
+                question = f"Who or what is mentioned prominently in this context?"
+                return question, name
+        
+        # General question
+        words = sentence.split()
+        if len(words) > 5:
+            # Create a fill-in-the-blank question
+            blank_word = random.choice(words[2:-2])  # Avoid first and last words
+            question = sentence.replace(blank_word, "______", 1)
+            return f"Fill in the blank: {question}", blank_word
+        
+        return None, None
+    
+    def _generate_options(self, correct_answer: str, fact_type: str) -> List[str]:
+        """Generate multiple choice options"""
+        options = [correct_answer]
+        
+        if fact_type == 'date':
+            # Generate nearby years
+            try:
+                year = int(correct_answer)
+                distractors = [
+                    str(year - 1),
+                    str(year + 1),
+                    str(year - 5)
+                ]
+            except ValueError:
+                distractors = ["1947", "1950", "1960"]
+        
+        elif fact_type == 'number':
+            # Generate nearby numbers
+            try:
+                num = int(correct_answer)
+                distractors = [
+                    str(num + 1),
+                    str(num - 1),
+                    str(num * 2)
+                ]
+            except ValueError:
+                distractors = ["10", "20", "100"]
+        
+        else:
+            # Generate generic distractors
+            distractors = [
+                "Option B",
+                "Option C", 
+                "Option D"
+            ]
+        
+        options.extend(distractors[:3])  # Add up to 3 distractors
+        
+        # Shuffle options and remember correct position
+        correct_index = 0
+        random.shuffle(options)
+        correct_index = options.index(correct_answer)
+        
+        return options
+    
+    def _generate_template_question(self, content: str, difficulty: str, 
+                                   language: str, translator) -> Dict[str, Any]:
+        """Generate question using templates"""
+        
+        # Extract a random sentence for context
+        sentences = self._extract_sentences(content)
+        if not sentences:
+            return None
+        
+        sentence = random.choice(sentences)
+        
+        # Simple template-based question
+        question = f"Based on the content, which of the following is true?"
+        
+        # Create options
+        options = [
+            "Statement related to the main topic",
+            "Unrelated statement A",
+            "Unrelated statement B", 
+            "Unrelated statement C"
+        ]
+        
+        if language != 'en':
+            question = translator.translate_text(question, language)
+            options = [translator.translate_text(opt, language) for opt in options]
+        
+        return {
+            'question': question,
+            'options': options,
+            'correct_answer': 0,
+            'explanation': f"Based on the content about the topic.",
+            'difficulty': difficulty,
+            'type': 'general'
+        }
+    
+    def _generate_fallback_questions(self, difficulty: str, num_questions: int, 
+                                   language: str, translator) -> List[Dict[str, Any]]:
+        """Generate fallback questions when content is insufficient"""
+        
+        fallback_questions = {
+            'easy': [
+                {
+                    'question': 'What is the capital of India?',
+                    'options': ['New Delhi', 'Mumbai', 'Kolkata', 'Chennai'],
+                    'correct_answer': 0,
+                    'explanation': 'New Delhi is the capital of India.'
+                },
+                {
+                    'question': 'Which river is considered sacred in Hinduism?',
+                    'options': ['Ganges', 'Yamuna', 'Narmada', 'Godavari'],
+                    'correct_answer': 0,
+                    'explanation': 'The Ganges river is considered most sacred in Hinduism.'
+                }
+            ],
+            'medium': [
+                {
+                    'question': 'In which year did India gain independence?',
+                    'options': ['1947', '1946', '1948', '1950'],
+                    'correct_answer': 0,
+                    'explanation': 'India gained independence on August 15, 1947.'
+                },
+                {
+                    'question': 'Who was the first Prime Minister of India?',
+                    'options': ['Jawaharlal Nehru', 'Mahatma Gandhi', 'Sardar Patel', 'Subhas Chandra Bose'],
+                    'correct_answer': 0,
+                    'explanation': 'Jawaharlal Nehru was the first Prime Minister of India.'
+                }
+            ],
+            'hard': [
+                {
+                    'question': 'Which constitutional amendment is known as the "Mini Constitution"?',
+                    'options': ['42nd Amendment', '44th Amendment', '73rd Amendment', '74th Amendment'],
+                    'correct_answer': 0,
+                    'explanation': 'The 42nd Amendment is called the "Mini Constitution" due to its extensive changes.'
+                }
+            ]
+        }
+        
+        questions = fallback_questions.get(difficulty, fallback_questions['easy'])
+        selected_questions = random.sample(questions, min(num_questions, len(questions)))
+        
+        # Translate if needed
+        if language != 'en':
+            for q in selected_questions:
+                q['question'] = translator.translate_text(q['question'], language)
+                q['options'] = [translator.translate_text(opt, language) for opt in q['options']]
+                q['explanation'] = translator.translate_text(q['explanation'], language)
+        
+        return selected_questions

requirements.txt

@@ -0,0 +1,8 @@
+streamlit>=1.28.0
+requests>=2.31.0
+googletrans==4.0.0rc1
+sqlite3
+transformers>=4.21.0
+torch>=1.12.0
+pandas>=1.5.0
+numpy>=1.21.0

utils/__init__.py

@@ -0,0 +1 @@
+# Utils package

utils/translator.py

@@ -0,0 +1,202 @@
+from googletrans import Translator as GoogleTranslator
+import json
+from typing import Optional
+
+class Translator:
+    """Handle text translation for multiple languages"""
+    
+    def __init__(self):
+        self.translator = GoogleTranslator()
+        self.supported_languages = {
+            'en': 'English',
+            'hi': 'Hindi',
+            'te': 'Telugu',
+            'ta': 'Tamil',
+            'kn': 'Kannada',
+            'bn': 'Bengali'
+        }
+        
+        # Fallback translations for common terms
+        self.fallback_translations = {
+            'hi': {
+                'Question': 'प्रश्न',
+                'Answer': 'उत्तर',
+                'Score': 'स्कोर',
+                'Correct': 'सही',
+                'Incorrect': 'गलत',
+                'Next': 'अगला',
+                'Previous': 'पिछला',
+                'Submit': 'जमा करें',
+                'Skip': 'छोड़ें',
+                'Easy': 'आसान',
+                'Medium': 'मध्यम',
+                'Hard': 'कठिन'
+            },
+            'te': {
+                'Question': 'ప్రశ్న',
+                'Answer': 'సమాధానం',
+                'Score': 'స్కోర్',
+                'Correct': 'సరైనది',
+                'Incorrect': 'తప్పు',
+                'Next': 'తదుపరి',
+                'Previous': 'మునుపటి',
+                'Submit': 'సమర్పించు',
+                'Skip': 'దాటవేయి',
+                'Easy': 'సులువు',
+                'Medium': 'మధ్యమ',
+                'Hard': 'కష్టం'
+            },
+            'ta': {
+                'Question': 'கேள்வி',
+                'Answer': 'பதில்',
+                'Score': 'மதிப்பெண்',
+                'Correct': 'சரி',
+                'Incorrect': 'தவறு',
+                'Next': 'அடுத்து',
+                'Previous': 'முந்தைய',
+                'Submit': 'சமர்ப்பிக்கவும்',
+                'Skip': 'தவிர்க்கவும்',
+                'Easy': 'எளிதான',
+                'Medium': 'நடுத்தர',
+                'Hard': 'கடினமான'
+            },
+            'kn': {
+                'Question': 'ಪ್ರಶ್ನೆ',
+                'Answer': 'ಉತ್ತರ',
+                'Score': 'ಅಂಕ',
+                'Correct': 'ಸರಿ',
+                'Incorrect': 'ತಪ್ಪು',
+                'Next': 'ಮುಂದಿನ',
+                'Previous': 'ಹಿಂದಿನ',
+                'Submit': 'ಸಲ್ಲಿಸಿ',
+                'Skip': 'ಬಿಟ್ಟುಬಿಡಿ',
+                'Easy': 'ಸುಲಭ',
+                'Medium': 'ಮಧ್ಯಮ',
+                'Hard': 'ಕಠಿಣ'
+            },
+            'bn': {
+                'Question': 'প্রশ্ন',
+                'Answer': 'উত্তর',
+                'Score': 'স্কোর',
+                'Correct': 'সঠিক',
+                'Incorrect': 'ভুল',
+                'Next': 'পরবর্তী',
+                'Previous': 'পূর্ববর্তী',
+                'Submit': 'জমা দিন',
+                'Skip': 'এড়িয়ে যান',
+                'Easy': 'সহজ',
+                'Medium': 'মাধ্যম',
+                'Hard': 'কঠিন'
+            }
+        }
+    
+    def translate_text(self, text: str, target_language: str) -> str:
+        """Translate text to target language"""
+        
+        if not text or target_language == 'en':
+            return text
+        
+        try:
+            # Try Google Translate first
+            result = self.translator.translate(text, dest=target_language)
+            return result.text
+            
+        except Exception as e:
+            print(f"Translation error: {e}")
+            # Try fallback translation
+            return self._fallback_translate(text, target_language)
+    
+    def _fallback_translate(self, text: str, target_language: str) -> str:
+        """Fallback translation using predefined dictionary"""
+        
+        if target_language not in self.fallback_translations:
+            return text
+        
+        translations = self.fallback_translations[target_language]
+        
+        # Check if the text is a common term
+        if text in translations:
+            return translations[text]
+        
+        # Try to translate word by word for simple phrases
+        words = text.split()
+        translated_words = []
+        
+        for word in words:
+            if word in translations:
+                translated_words.append(translations[word])
+            else:
+                translated_words.append(word)
+        
+        return ' '.join(translated_words)
+    
+    def translate_quiz_content(self, quiz_data: dict, target_language: str) -> dict:
+        """Translate entire quiz content"""
+        
+        if target_language == 'en':
+            return quiz_data
+        
+        translated_quiz = quiz_data.copy()
+        
+        # Translate quiz title if present
+        if 'title' in translated_quiz:
+            translated_quiz['title'] = self.translate_text(translated_quiz['title'], target_language)
+        
+        # Translate questions
+        if 'questions' in translated_quiz:
+            for question in translated_quiz['questions']:
+                question['question'] = self.translate_text(question['question'], target_language)
+                
+                if 'options' in question:
+                    question['options'] = [
+                        self.translate_text(option, target_language) 
+                        for option in question['options']
+                    ]
+                
+                if 'explanation' in question:
+                    question['explanation'] = self.translate_text(question['explanation'], target_language)
+        
+        return translated_quiz
+    
+    def get_ui_text(self, key: str, language: str) -> str:
+        """Get UI text in specified language"""
+        
+        if language == 'en':
+            return key
+        
+        if language in self.fallback_translations:
+            return self.fallback_translations[language].get(key, key)
+        
+        return key
+    
+    def batch_translate(self, texts: list, target_language: str) -> list:
+        """Translate multiple texts at once"""
+        
+        if target_language == 'en':
+            return texts
+        
+        translated_texts = []
+        
+        for text in texts:
+            translated_text = self.translate_text(text, target_language)
+            translated_texts.append(translated_text)
+        
+        return translated_texts
+    
+    def detect_language(self, text: str) -> Optional[str]:
+        """Detect the language of given text"""
+        
+        try:
+            result = self.translator.detect(text)
+            return result.lang
+        except Exception as e:
+            print(f"Language detection error: {e}")
+            return 'en'  # Default to English
+    
+    def is_supported_language(self, language_code: str) -> bool:
+        """Check if language is supported"""
+        return language_code in self.supported_languages
+    
+    def get_language_name(self, language_code: str) -> str:
+        """Get full language name from code"""
+        return self.supported_languages.get(language_code, 'Unknown')

utils/wiki_api.py

@@ -0,0 +1,260 @@
+import requests
+import json
+from typing import Optional, Dict, Any
+import time
+
+class WikiAPI:
+    """Wikipedia and Wikidata API client"""
+    
+    def __init__(self):
+        self.wikipedia_base_url = "https://en.wikipedia.org/api/rest_v1"
+        self.wikidata_base_url = "https://www.wikidata.org/w/api.php"
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'TriviaVerse/1.0 (https://github.com/your-repo/triviaverse)'
+        })
+    
+    def fetch_content(self, topic: str, language: str = 'en') -> Optional[str]:
+        """Fetch content from Wikipedia"""
+        try:
+            # First, search for the article
+            search_results = self._search_wikipedia(topic, language)
+            if not search_results:
+                return None
+            
+            # Get the first result
+            page_title = search_results[0]['title']
+            
+            # Fetch the full content
+            content = self._get_wikipedia_content(page_title, language)
+            return content
+            
+        except Exception as e:
+            print(f"Error fetching content: {e}")
+            return None
+    
+    def _search_wikipedia(self, query: str, language: str = 'en') -> Optional[list]:
+        """Search Wikipedia for articles"""
+        
+        # Map language codes to Wikipedia domains
+        lang_domains = {
+            'en': 'en.wikipedia.org',
+            'hi': 'hi.wikipedia.org',
+            'te': 'te.wikipedia.org',
+            'ta': 'ta.wikipedia.org',
+            'kn': 'kn.wikipedia.org',
+            'bn': 'bn.wikipedia.org'
+        }
+        
+        domain = lang_domains.get(language, 'en.wikipedia.org')
+        
+        url = f"https://{domain}/api/rest_v1/page/search/{query}"
+        
+        try:
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            return data.get('pages', [])
+            
+        except Exception as e:
+            print(f"Search error: {e}")
+            return None
+    
+    def _get_wikipedia_content(self, page_title: str, language: str = 'en') -> Optional[str]:
+        """Get full content of a Wikipedia page"""
+        
+        # Map language codes to Wikipedia domains
+        lang_domains = {
+            'en': 'en.wikipedia.org',
+            'hi': 'hi.wikipedia.org',
+            'te': 'te.wikipedia.org',
+            'ta': 'ta.wikipedia.org',
+            'kn': 'kn.wikipedia.org',
+            'bn': 'bn.wikipedia.org'
+        }
+        
+        domain = lang_domains.get(language, 'en.wikipedia.org')
+        
+        # Get page summary first
+        summary_url = f"https://{domain}/api/rest_v1/page/summary/{page_title}"
+        
+        try:
+            response = self.session.get(summary_url, timeout=10)
+            response.raise_for_status()
+            
+            summary_data = response.json()
+            extract = summary_data.get('extract', '')
+            
+            # Try to get more detailed content
+            content_url = f"https://{domain}/w/api.php"
+            params = {
+                'action': 'query',
+                'format': 'json',
+                'titles': page_title,
+                'prop': 'extracts',
+                'exintro': True,
+                'explaintext': True,
+                'exsectionformat': 'plain'
+            }
+            
+            response = self.session.get(content_url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            pages = data.get('query', {}).get('pages', {})
+            
+            for page_id, page_data in pages.items():
+                if 'extract' in page_data:
+                    full_extract = page_data['extract']
+                    # Return the longer content
+                    return full_extract if len(full_extract) > len(extract) else extract
+            
+            return extract
+            
+        except Exception as e:
+            print(f"Content fetch error: {e}")
+            return None
+    
+    def get_wikidata_info(self, topic: str) -> Optional[Dict[str, Any]]:
+        """Get structured data from Wikidata"""
+        try:
+            # Search for Wikidata entity
+            search_url = f"{self.wikidata_base_url}"
+            params = {
+                'action': 'wbsearchentities',
+                'search': topic,
+                'language': 'en',
+                'format': 'json'
+            }
+            
+            response = self.session.get(search_url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            entities = data.get('search', [])
+            
+            if not entities:
+                return None
+            
+            entity_id = entities[0]['id']
+            
+            # Get entity data
+            entity_url = f"{self.wikidata_base_url}"
+            params = {
+                'action': 'wbgetentities',
+                'ids': entity_id,
+                'format': 'json',
+                'languages': 'en'
+            }
+            
+            response = self.session.get(entity_url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            entity_data = data.get('entities', {}).get(entity_id, {})
+            
+            return self._process_wikidata_entity(entity_data)
+            
+        except Exception as e:
+            print(f"Wikidata error: {e}")
+            return None
+    
+    def _process_wikidata_entity(self, entity_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Process Wikidata entity to extract useful information"""
+        
+        processed_data = {
+            'label': '',
+            'description': '',
+            'claims': {},
+            'aliases': []
+        }
+        
+        # Extract label
+        labels = entity_data.get('labels', {})
+        if 'en' in labels:
+            processed_data['label'] = labels['en']['value']
+        
+        # Extract description
+        descriptions = entity_data.get('descriptions', {})
+        if 'en' in descriptions:
+            processed_data['description'] = descriptions['en']['value']
+        
+        # Extract aliases
+        aliases = entity_data.get('aliases', {})
+        if 'en' in aliases:
+            processed_data['aliases'] = [alias['value'] for alias in aliases['en']]
+        
+        # Extract some important claims
+        claims = entity_data.get('claims', {})
+        important_properties = [
+            'P31',   # instance of
+            'P279',  # subclass of
+            'P17',   # country
+            'P569',  # date of birth
+            'P570',  # date of death
+            'P571',  # inception
+            'P576',  # dissolved
+        ]
+        
+        for prop in important_properties:
+            if prop in claims:
+                processed_data['claims'][prop] = claims[prop]
+        
+        return processed_data
+    
+    def get_related_topics(self, topic: str, limit: int = 5) -> list:
+        """Get related topics for additional content"""
+        try:
+            # This is a simplified implementation
+            # In a real app, you might use Wikipedia's "See also" sections
+            # or Wikidata relationships
+            
+            search_results = self._search_wikipedia(topic)
+            if not search_results:
+                return []
+            
+            # Return related pages from search results
+            related = []
+            for result in search_results[1:limit+1]:  # Skip first result (exact match)
+                related.append({
+                    'title': result['title'],
+                    'description': result.get('description', ''),
+                    'url': result.get('content_urls', {}).get('desktop', {}).get('page', '')
+                })
+            
+            return related
+            
+        except Exception as e:
+            print(f"Related topics error: {e}")
+            return []
+    
+    def get_random_article(self, language: str = 'en') -> Optional[Dict[str, str]]:
+        """Get a random Wikipedia article"""
+        
+        lang_domains = {
+            'en': 'en.wikipedia.org',
+            'hi': 'hi.wikipedia.org',
+            'te': 'te.wikipedia.org',
+            'ta': 'ta.wikipedia.org',
+            'kn': 'kn.wikipedia.org',
+            'bn': 'bn.wikipedia.org'
+        }
+        
+        domain = lang_domains.get(language, 'en.wikipedia.org')
+        
+        try:
+            url = f"https://{domain}/api/rest_v1/page/random/summary"
+            response = self.session.get(url, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            return {
+                'title': data.get('title', ''),
+                'extract': data.get('extract', ''),
+                'url': data.get('content_urls', {}).get('desktop', {}).get('page', '')
+            }
+            
+        except Exception as e:
+            print(f"Random article error: {e}")
+            return None