Upload 23 files

utils/challenge_manager.py

@@ -0,0 +1,78 @@
+# utils/challenge_manager.py
+import json
+import os
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional
+
+CHALLENGES_FILE = "data/challenges.json"
+
+def _load_challenges() -> Dict:
+    """Loads all challenges from the JSON file."""
+    if os.path.exists(CHALLENGES_FILE):
+        with open(CHALLENGES_FILE, "r") as f:
+            try:
+                return json.load(f)
+            except json.JSONDecodeError:
+                return {}
+    return {}
+
+def _save_challenges(challenges: Dict):
+    """Saves all challenges to the JSON file."""
+    os.makedirs(os.path.dirname(CHALLENGES_FILE), exist_ok=True)
+    with open(CHALLENGES_FILE, "w") as f:
+        json.dump(challenges, f, indent=2)
+
+class ChallengeManager:
+    def __init__(self):
+        self.challenges = _load_challenges()
+
+    def create_challenge(self, creator_id: str, topic: str, difficulty: str, num_questions: int) -> str:
+        """Creates a new challenge and returns its ID."""
+        challenge_id = str(uuid.uuid4())[:8] # Short UUID for easy sharing
+        challenge_data = {
+            "challenge_id": challenge_id,
+            "creator_id": creator_id,
+            "created_at": datetime.now().isoformat(),
+            "topic": topic,
+            "difficulty": difficulty,
+            "num_questions": num_questions,
+            "participants": {}, # {user_id: {score: int, quiz_results: List}}
+            "status": "active" # active, completed
+        }
+        self.challenges[challenge_id] = challenge_data
+        _save_challenges(self.challenges)
+        return challenge_id
+
+    def get_challenge(self, challenge_id: str) -> Optional[Dict]:
+        """Retrieves a challenge by its ID."""
+        return self.challenges.get(challenge_id)
+
+    def update_challenge_score(self, challenge_id: str, user_id: str, score: int, quiz_results: List[Dict]):
+        """Updates a participant's score and quiz results for a challenge."""
+        challenge = self.challenges.get(challenge_id)
+        if challenge:
+            challenge["participants"][user_id] = {
+                "score": score,
+                "quiz_results": quiz_results,
+                "completed_at": datetime.now().isoformat()
+            }
+            _save_challenges(self.challenges)
+        else:
+            raise ValueError(f"Challenge with ID {challenge_id} not found.")
+
+    def get_all_active_challenges(self) -> List[Dict]:
+        """Returns a list of all active challenges."""
+        return [c for c in self.challenges.values() if c.get("status") == "active"]
+
+    def get_challenges_by_creator(self, creator_id: str) -> List[Dict]:
+        """Returns a list of challenges created by a specific user."""
+        return [c for c in self.challenges.values() if c.get("creator_id") == creator_id]
+
+    def set_challenge_status(self, challenge_id: str, status: str):
+        """Sets the status of a challenge."""
+        if challenge_id in self.challenges:
+            self.challenges[challenge_id]["status"] = status
+            _save_challenges(self.challenges)
+        else:
+            raise ValueError(f"Challenge with ID {challenge_id} not found.")

utils/init.py

@@ -0,0 +1,21 @@
+# utils/__init__.py
+"""Utility modules for TriviaVerse application"""
+
+from .score_tracker import ScoreTracker
+from .user_auth import init_authentication, authenticate_user
+from .ui_components import *
+from .mobile_responsive import *
+
+__all__ = [
+    "ScoreTracker",
+    "init_authentication",
+    "authenticate_user",
+    "apply_custom_theme",
+    "display_user_stats",
+    "display_badges",
+    "create_progress_chart",
+    "animated_success",
+    "create_quiz_card",
+    "responsive_columns",
+    "responsive_css",
+]

utils/mobile_responsive.py

@@ -0,0 +1,67 @@
+# utils/mobile_responsive.py
+"""Utilities for mobile responsiveness."""
+
+import streamlit as st
+
+
+def responsive_columns(sizes: list, mobile_sizes: list = None):
+    """
+    Creates responsive columns for Streamlit.
+    On desktop, uses 'sizes'. On mobile, stacks columns or uses 'mobile_sizes'.
+    """
+    if mobile_sizes is None:
+        mobile_sizes = [1] * len(sizes)  # Default to stacking if not specified
+
+    # Check for mobile client (a bit hacky, but works for most cases)
+    # Streamlit doesn't provide a direct way to detect mobile, so we rely on screen width
+    # This might not be perfectly accurate but is generally effective.
+    # We'll use JavaScript to pass screen width to Streamlit later if needed for more robust detection.
+
+    # For now, let's assume if the app is run on a narrow screen, it's mobile.
+    # This is often handled by CSS, but for column layout, Python-side adjustment can be useful.
+    # A more robust solution would involve custom component for screen width detection.
+
+    # Placeholder for actual mobile detection logic if implemented via JS/custom component
+    # For now, we'll let CSS handle most of the responsiveness, and this function
+    # will primarily provide a way to define column ratios.
+
+    # For demonstration, we'll just return st.columns with the given sizes.
+    # The actual mobile stacking will be handled by CSS in style.css.
+    return st.columns(sizes)
+
+
+def responsive_css():
+    """Injects CSS for mobile responsiveness."""
+    # This CSS is also defined in assets/style.css, but including it here
+    # ensures it's applied, especially for column stacking.
+    # In a real app, you'd load this from the assets file.
+    css = """
+    <style>
+    /* Mobile-first responsive design */
+    @media (max-width: 768px) {
+        /* Stack columns on mobile */
+        .row-widget.stHorizontal {
+            flex-direction: column !important;
+        }
+
+        .row-widget.stHorizontal > div {
+            width: 100% !important;
+            margin-bottom: 1rem;
+        }
+
+        /* Full-width buttons on mobile */
+        .stButton > button {
+            width: 100% !important;
+            min-height: 50px;
+            font-size: 16px !important;
+        }
+
+        /* Responsive cards */
+        .card {
+            padding: 15px !important;
+            margin: 10px 0 !important;
+        }
+    }
+    </style>
+    """
+    return css

utils/score_tracker.py

@@ -0,0 +1,101 @@
+# utils/score_tracker.py
+import json
+import os
+from datetime import datetime
+from config.settings import BASE_POINTS, DIFFICULTY_LEVELS, BADGES, ACHIEVEMENTS
+
+
+class ScoreTracker:
+    def __init__(self, user_id: str):
+        self.user_id = user_id
+        self.scores_file = f"data/scores_{user_id}.json"
+        self.load_scores()
+
+    def load_scores(self):
+        """Load scores from a JSON file."""
+        if os.path.exists(self.scores_file):
+            with open(self.scores_file, "r") as f:
+                self.scores = json.load(f)
+        else:
+            self.scores = {
+                "total_score": 0,
+                "quizzes_completed": 0,
+                "quiz_history": [],
+                "badges": [],
+                "achievements": [],
+                "current_streak": 0,
+                "best_streak": 0,
+            }
+
+    def save_scores(self):
+        """Save scores to a JSON file."""
+        os.makedirs("data", exist_ok=True)
+        with open(self.scores_file, "w") as f:
+            json.dump(self.scores, f, indent=4)
+
+    def add_quiz_result(
+        self, mode: str, score: int, total: int, difficulty: str
+    ) -> int:
+        """Adds a quiz result and updates the total score."""
+        self.scores["quizzes_completed"] += 1
+
+        multiplier = DIFFICULTY_LEVELS.get(difficulty, {}).get("multiplier", 1)
+        points_earned = int(score * BASE_POINTS * multiplier)
+        self.scores["total_score"] += points_earned
+
+        self.scores["quiz_history"].append(
+            {
+                "timestamp": datetime.now().isoformat(),
+                "mode": mode,
+                "score": score,
+                "total": total,
+                "difficulty": difficulty,
+                "percentage": (score / total) * 100 if total > 0 else 0,
+                "points_earned": points_earned,
+            }
+        )
+
+        self.update_streak(score > 0)
+        self.check_for_badges()
+        self.check_for_achievements()
+        self.save_scores()
+        return points_earned
+
+    def update_streak(self, successful: bool):
+        """Updates the user's streak."""
+        if successful:
+            self.scores["current_streak"] += 1
+        else:
+            self.scores["current_streak"] = 0
+
+        if self.scores["current_streak"] > self.scores["best_streak"]:
+            self.scores["best_streak"] = self.scores["current_streak"]
+
+    def check_for_badges(self):
+        """Checks if the user has earned any new badges."""
+        for badge_id, badge_info in BADGES.items():
+            if (
+                self.scores["total_score"] >= badge_info["threshold"]
+                and badge_id not in self.scores["badges"]
+            ):
+                self.scores["badges"].append(badge_id)
+
+    def check_for_achievements(self):
+        """Checks for new achievements."""
+        # Example: First quiz achievement
+        if (
+            "first_quiz" not in self.scores["achievements"]
+            and self.scores["quizzes_completed"] > 0
+        ):
+            self.scores["achievements"].append("first_quiz")
+
+        # Example: Streak achievement
+        if (
+            "streak_5" not in self.scores["achievements"]
+            and self.scores["current_streak"] >= 5
+        ):
+            self.scores["achievements"].append("streak_5")
+
+    def get_stats(self) -> dict:
+        """Returns all user statistics."""
+        return self.scores

utils/translator.py

@@ -0,0 +1,36 @@
+# utils/translator.py
+"""Translation utility for TriviaVerse"""
+
+import streamlit as st
+from googletrans import Translator
+from config.languages import SUPPORTED_LANGUAGES
+from config.localization import UI_TEXT
+
+@st.cache_data(ttl=3600)
+def get_translated_texts(dest_lang="en"):
+    """
+    Translates all UI texts to the destination language in a single batch
+    and caches the result.
+    """
+    if dest_lang == "en":
+        return UI_TEXT
+
+    try:
+        translator = Translator()
+        # Get all the values from the UI_TEXT dictionary
+        original_texts = list(UI_TEXT.values())
+        
+        # Translate them in a single batch
+        translated_texts = translator.translate(original_texts, dest=dest_lang)
+        
+        # Create a new dictionary with the same keys but translated values
+        translated_dict = dict(zip(UI_TEXT.keys(), [t.text for t in translated_texts]))
+        
+        return translated_dict
+    except Exception as e:
+        st.error(f"Translation service failed: {e}. Falling back to English.")
+        return UI_TEXT
+
+def get_supported_languages():
+    """Returns the list of supported languages."""
+    return SUPPORTED_LANGUAGES

utils/ui_components.py

@@ -0,0 +1,112 @@
+# utils/ui_components.py
+import streamlit as st
+import plotly.graph_objects as go
+from config.settings import BADGES
+from config.themes import THEMES
+
+def apply_custom_theme(theme_name: str):
+    """Applies a custom theme using CSS variables."""
+    theme = THEMES.get(theme_name, THEMES["default"])
+    
+    css_vars = {
+        "--primary-color": theme["primary_color"],
+        "--background-color": theme["background_color"],
+        "--secondary-background-color": theme["secondary_background_color"],
+        "--text-color": theme["text_color"],
+        "--font": theme["font"],
+        "--card-background": theme.get("card_background", "#FFFFFF"),
+        "--shadow-light": theme.get("shadow_light", "0 4px 15px rgba(0, 0, 0, 0.05)"),
+        "--shadow-medium": theme.get("shadow_medium", "0 8px 30px rgba(0, 0, 0, 0.1)"),
+        "--highlight-color": theme.get("highlight_color", theme["primary_color"]),
+    }
+    
+    css_vars_str = "\n".join([f"{key}: {value};" for key, value in css_vars.items()])
+
+    css = f"""
+    <style>
+        :root {{ {css_vars_str} }}
+        .stApp {{ background-color: var(--background-color); color: var(--text-color); }}
+        .stSidebar {{ background-color: var(--secondary-background-color); }}
+        .stButton>button {{ background-color: var(--primary-color); color: white; box-shadow: var(--shadow-light); }}
+        .stButton>button:hover {{ background-color: var(--secondary-color); box-shadow: var(--shadow-medium); }}
+        /* Add other theme styles here */
+    </style>
+    """
+    st.markdown(css, unsafe_allow_html=True)
+
+def display_user_stats(stats: dict, ui: dict):
+    """Displays user statistics in a dashboard format."""
+    cols = st.columns(4)
+    with cols[0]:
+        st.metric(ui.get("total_score", "Total Score"), f"{stats.get('total_score', 0):,}")
+    with cols[1]:
+        st.metric(ui.get("quizzes", "Quizzes Played"), stats.get("quizzes_completed", 0))
+    with cols[2]:
+        st.metric(ui.get("current_streak", "Current Streak"), f"🔥 {stats.get('current_streak', 0)}")
+    with cols[3]:
+        st.metric(ui.get("best_streak", "Best Streak"), f"⭐ {stats.get('best_streak', 0)}")
+
+def display_badges(earned_badges: list, ui: dict):
+    """Displays earned badges."""
+    if not earned_badges:
+        return
+
+    st.markdown(f"### 🏆 {ui.get('your_badges', 'Your Badges')}")
+    cols = st.columns(len(earned_badges))
+    for i, badge_id in enumerate(earned_badges):
+        badge = BADGES.get(badge_id)
+        if badge:
+            with cols[i]:
+                st.markdown(f"<div style='text-align: center;'><span style='font-size: 50px;'>{badge['icon']}</span><br><b>{ui.get(badge['name'].lower(), badge['name'])}</b></div>", unsafe_allow_html=True)
+
+def create_progress_chart(stats: dict, ui: dict) -> go.Figure:
+    """Creates a progress chart for the user."""
+    history = stats.get("quiz_history", [])
+    if not history:
+        return go.Figure()
+
+    dates = [item["timestamp"] for item in history]
+    scores = [item["percentage"] for item in history]
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=dates, y=scores, mode="lines+markers", name=ui.get("score", "Score") + " %"))
+    fig.update_layout(
+        title=ui.get("quiz_performance_over_time", "Quiz Performance Over Time"),
+        xaxis_title=ui.get("date", "Date"),
+        yaxis_title=f"{ui.get('score', 'Score')} (%)",
+        yaxis_range=[0, 100],
+    )
+    return fig
+
+def animated_success(message: str):
+    """Displays an animated success message."""
+    st.markdown(f"<div class='pop-in'>{st.success(message)}</div>", unsafe_allow_html=True)
+
+def create_quiz_card(question: str, options: list, key: str):
+    """Creates a card for a multiple-choice question."""
+    st.markdown(f"<div style='background-color: var(--card-background); padding: 20px; border-radius: 10px; box-shadow: var(--shadow-light);'>", unsafe_allow_html=True)
+    st.subheader(question)
+    st.session_state[key] = st.radio(
+        "Select your answer:",
+        options,
+        index=None,
+        key=f"{key}_radio",
+        label_visibility="collapsed",
+    )
+    st.markdown("</div>", unsafe_allow_html=True)
+
+def render_flashcard(front_content: str, back_content: str, is_flipped: bool):
+    """Renders a flippable flashcard."""
+    card_style = "width: 100%; height: 300px; perspective: 1000px;"
+    flipper_style = f'position: relative; width: 100%; height: 100%; transition: transform 0.6s; transform-style: preserve-3d; transform: {"rotateY(180deg)" if is_flipped else "none"};'
+    face_style = "position: absolute; width: 100%; height: 100%; -webkit-backface-visibility: hidden; backface-visibility: hidden; display: flex; justify-content: center; align-items: center; padding: 20px; border-radius: 10px; box-shadow: var(--shadow-light);"
+    front_style = f"{face_style} background-color: var(--primary-color); color: white;"
+    back_style = f"{face_style} background-color: var(--card-background); color: var(--text-color); transform: rotateY(180deg);"
+
+    st.markdown(
+        f"<div style='{card_style}'><div style='{flipper_style}'>"
+        f"<div style='{front_style}'><div>{front_content}</div></div>"
+        f"<div style='{back_style}'><div>{back_content}</div></div>"
+        f"</div></div>",
+        unsafe_allow_html=True,
+    )

utils/user_auth.py

@@ -0,0 +1,128 @@
+# utils/user_auth.py
+"""User authentication module"""
+
+import streamlit as st
+import hashlib
+import json
+import os
+from datetime import datetime
+
+# Simple authentication system for demo
+# In production, use proper authentication libraries
+
+
+def hash_password(password: str) -> str:
+    """Hash password using SHA256"""
+    return hashlib.sha256(password.encode()).hexdigest()
+
+
+def load_users():
+    """Load users from file"""
+    users_file = "data/users.json"
+    if os.path.exists(users_file):
+        with open(users_file, "r") as f:
+            return json.load(f)
+    return {}
+
+
+def save_users(users):
+    """Save users to file"""
+    os.makedirs("data", exist_ok=True)
+    with open("data/users.json", "w") as f:
+        json.dump(users, f, indent=2)
+
+
+def init_authentication():
+    """Initialize authentication in session state"""
+    if "authenticated" not in st.session_state:
+        st.session_state.authenticated = False
+    if "username" not in st.session_state:
+        st.session_state.username = None
+
+
+def authenticate_user():
+    """Show authentication UI and handle login/signup"""
+    if st.session_state.authenticated:
+        return True
+
+    st.title("🎯 Welcome to TriviaVerse")
+    st.markdown("### Please login or create an account to continue")
+
+    tab1, tab2 = st.tabs(["Login", "Sign Up"])
+
+    with tab1:
+        with st.form("login_form"):
+            username = st.text_input("Username")
+            password = st.text_input("Password", type="password")
+            submitted = st.form_submit_button("Login", type="primary")
+
+            if submitted:
+                users = load_users()
+
+                if username in users:
+                    if users[username]["password"] == hash_password(password):
+                        st.session_state.authenticated = True
+                        st.session_state.username = username
+                        st.session_state.user_id = username
+
+                        # Update last login
+                        users[username]["last_login"] = datetime.now().isoformat()
+                        save_users(users)
+
+                        st.success("Login successful!")
+                        st.rerun()
+                    else:
+                        st.error("Invalid password")
+                else:
+                    st.error("Username not found")
+
+    with tab2:
+        with st.form("signup_form"):
+            new_username = st.text_input("Choose a username")
+            new_password = st.text_input("Choose a password", type="password")
+            confirm_password = st.text_input("Confirm password", type="password")
+            email = st.text_input("Email (optional)")
+
+            terms = st.checkbox("I agree to the terms and conditions")
+            submitted = st.form_submit_button("Sign Up", type="primary")
+
+            if submitted:
+                if not new_username or not new_password:
+                    st.error("Username and password are required")
+                elif new_password != confirm_password:
+                    st.error("Passwords do not match")
+                elif not terms:
+                    st.error("Please agree to the terms and conditions")
+                else:
+                    users = load_users()
+
+                    if new_username in users:
+                        st.error("Username already exists")
+                    else:
+                        # Create new user
+                        users[new_username] = {
+                            "password": hash_password(new_password),
+                            "email": email,
+                            "created": datetime.now().isoformat(),
+                            "last_login": datetime.now().isoformat(),
+                        }
+                        save_users(users)
+
+                        # Auto login
+                        st.session_state.authenticated = True
+                        st.session_state.username = new_username
+                        st.session_state.user_id = new_username
+
+                        st.success("Account created successfully!")
+                        st.balloons()
+                        st.rerun()
+
+    # Guest mode option
+    st.divider()
+    if st.button("Continue as Guest", type="secondary"):
+        st.session_state.authenticated = True
+        st.session_state.username = "Guest"
+        st.session_state.user_id = f"guest_{int(datetime.now().timestamp())}"
+        st.rerun()
+
+    return False