import streamlit as st
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import base64
import time
import sqlite3
import datetime
import sys
import re
import queue
from concurrent.futures import ThreadPoolExecutor
from PIL import Image
from io import BytesIO
from gamification import GamificationSystem
import random
from collections import defaultdict
import io
from vocam_ui import apply_custom_css
from streamlit.components.v1 import components
import hashlib
from functools import lru_cache
from example_sentences import ExampleSentenceGenerator
import tensorflow as tf
import tensorflow_hub as hub
import requests
from deep_translator import GoogleTranslator
from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
# First, display Python version for
st.set_page_config(
page_title="Vocam",
page_icon="๐",
layout="wide",
initial_sidebar_state="expanded"
)
# Import the UI enhancement module
from vocam_ui import (
apply_custom_css,
success_message,
info_message,
warning_message,
error_message,
show_loading_spinner,
vocam_card,
word_card,
add_result_separator,
add_scroll_indicator,
style_title,
style_section_title,
add_footer
)
apply_custom_css()
try:
from pronunciation_practice import create_pronunciation_practice
has_pronunciation_practice = True
print("โ Enhanced pronunciation practice with AI feedback loaded")
except ImportError as e:
has_pronunciation_practice = False
print(f"โ Pronunciation practice not available: {e}")
# Try importing OCR with fallback
try:
import pytesseract
has_tesseract = True
except ImportError as e:
has_tesseract = False
# Dummy implementation
class DummyTesseract:
def image_to_string(self, *args, **kwargs):
return "OCR requires pytesseract. Install with: pip install pytesseract"
pytesseract = DummyTesseract()
# Try importing OpenCV with robust fallback mechanism
try:
import cv2
except ImportError as e:
# Create dummy CV2 class to prevent crashes
class DummyCV2:
def __init__(self):
pass
def __getattr__(self, name):
def dummy_method(*args, **kwargs):
return None
return dummy_method
def cvtColor(self, *args, **kwargs):
return args[0] # Return the input image unchanged
@staticmethod
def imread(path):
try:
from PIL import Image
import numpy as np
img = Image.open(path)
return np.array(img)
except Exception:
return None
@staticmethod
def imwrite(path, img):
try:
from PIL import Image
import numpy as np
Image.fromarray(img).save(path)
return True
except False:
return False
# Replace cv2 with our dummy implementation
cv2 = DummyCV2()
# Import other dependencies with careful error handling
try:
import torch
except ImportError as e:
# Dummy torch for fallback
class DummyTorch:
def __init__(self):
self.hub = type('obj', (object,), {
'load': lambda *args, **kwargs: DummyModel()
})
class DummyModel:
def __call__(self, *args, **kwargs):
return type('obj', (object,), {
'xyxy': [[]],
'render': lambda: [[np.zeros((300, 300, 3), dtype=np.uint8)]],
'names': {0: 'unknown'}
})
def eval(self):
return self
torch = DummyTorch()
# Try importing gTTS
try:
from gtts import gTTS
except ImportError as e:
# Create a dummy gTTS class
class DummyGTTS:
def __init__(self, text="", lang="en", slow=False):
self.text = text
self.lang = lang
def write_to_fp(self, fp):
fp.write(b'dummy audio data')
gTTS = DummyGTTS
# Import database module with error handling
try:
from database import LanguageLearningDB
except ImportError as e:
# Define a basic LanguageLearningDB class for fallback
class LanguageLearningDB:
def __init__(self, db_path):
self.db_path = db_path
def start_session(self):
return None
def end_session(self, session_id, words_studied, words_learned):
return True
# Import custom audio recorder
try:
from custom_audio_recorder import audio_recorder
has_custom_recorder = True
print("Custom audio recorder imported successfully")
except ImportError as e:
has_custom_recorder = False
print(f"Custom audio recorder not available: {e}")
def check_pronunciation_dependencies():
"""Check and report pronunciation practice dependencies"""
dependencies = {
'streamlit_webrtc': False,
'speech_recognition': False,
'librosa': False,
'Levenshtein': False,
'av': False
}
try:
import streamlit_webrtc
dependencies['streamlit_webrtc'] = True
except ImportError:
pass
try:
import speech_recognition
dependencies['speech_recognition'] = True
except ImportError:
pass
try:
import librosa
dependencies['librosa'] = True
except ImportError:
pass
try:
import Levenshtein
dependencies['Levenshtein'] = True
except ImportError:
pass
try:
import av
dependencies['av'] = True
except ImportError:
pass
return dependencies
def draw_detections(image_np, detections):
"""Draw bounding boxes and labels on the image."""
result_image = image_np.copy()
for detection in detections:
bbox = detection['bbox']
left, top, right, bottom = [int(x) for x in bbox]
label = detection['label']
confidence = detection['confidence']
# Use different colors for different object types
color = get_detection_color(label)
# Draw bounding box
cv2.rectangle(result_image, (left, top), (right, bottom), color, 3)
# Prepare label text
label_text = f"{label} {confidence:.2f}"
label_size, _ = cv2.getTextSize(label_text, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)
# Draw background for text
cv2.rectangle(result_image,
(left, top - label_size[1] - 10),
(left + label_size[0], top),
color, -1)
# Draw text (white or black depending on background)
text_color = (255, 255, 255) if sum(color) < 400 else (0, 0, 0)
cv2.putText(result_image, label_text,
(left, top - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.7, text_color, 2)
return result_image
def apply_nms(boxes, classes, scores, image_shape, iou_threshold=0.45):
"""Apply Non-Maximum Suppression to remove duplicate detections."""
final_detections = []
unique_classes = np.unique(classes)
height, width = image_shape[:2]
for class_id in unique_classes:
# Get all detections for this class
class_mask = classes == class_id
class_boxes = boxes[class_mask]
class_scores = scores[class_mask]
if len(class_boxes) == 0:
continue
# Convert normalized coordinates to pixel coordinates
pixel_boxes = []
for box in class_boxes:
ymin, xmin, ymax, xmax = box
pixel_boxes.append([
int(xmin * width), # left
int(ymin * height), # top
int(xmax * width), # right
int(ymax * height) # bottom
])
pixel_boxes = np.array(pixel_boxes)
# Apply simple NMS (since OpenCV might cause issues)
keep_indices = simple_nms(pixel_boxes, class_scores, iou_threshold)
# Add kept detections to final list
for idx in keep_indices:
class_name = COCO_CLASS_NAMES.get(class_id, f"unknown_{class_id}")
bbox = pixel_boxes[idx]
final_detections.append({
'label': class_name.lower(),
'confidence': float(class_scores[idx]),
'bbox': [float(bbox[0]), float(bbox[1]), float(bbox[2]), float(bbox[3])],
'class_id': int(class_id)
})
# Sort detections by confidence (highest first)
final_detections.sort(key=lambda x: x['confidence'], reverse=True)
return final_detections
# Alternative simplified NMS function if OpenCV NMS doesn't work
def simple_nms(boxes, scores, iou_threshold=0.5):
"""Simple Non-Maximum Suppression implementation."""
if len(boxes) == 0:
return []
# Sort by confidence score (highest first)
sorted_indices = np.argsort(scores)[::-1]
keep = []
while len(sorted_indices) > 0:
# Take the detection with highest confidence
current = sorted_indices[0]
keep.append(current)
if len(sorted_indices) == 1:
break
# Calculate IoU with all other boxes
current_box = boxes[current]
remaining_indices = sorted_indices[1:]
# Calculate IoU with remaining boxes
ious = []
for idx in remaining_indices:
iou = calculate_iou(current_box, boxes[idx])
ious.append(iou)
# Keep only boxes with IoU below threshold
ious = np.array(ious)
keep_mask = ious < iou_threshold
sorted_indices = remaining_indices[keep_mask]
return keep
def calculate_iou(box1, box2):
"""Calculate Intersection over Union (IoU) of two bounding boxes."""
# box format: [left, top, right, bottom]
x1 = max(box1[0], box2[0])
y1 = max(box1[1], box2[1])
x2 = min(box1[2], box2[2])
y2 = min(box1[3], box2[3])
if x2 <= x1 or y2 <= y1:
return 0.0
intersection = (x2 - x1) * (y2 - y1)
area1 = (box1[2] - box1[0]) * (box1[3] - box1[1])
area2 = (box2[2] - box2[0]) * (box2[3] - box2[1])
union = area1 + area2 - intersection
return intersection / union if union > 0 else 0.0
def get_detection_color(label):
"""Get a consistent color for each object type."""
# Color mapping for different object categories
color_map = {
# Electronics - Blue shades
'cell phone': (255, 100, 100),
'laptop': (255, 150, 100),
'tv': (255, 200, 100),
'mouse': (200, 255, 100),
'keyboard': (150, 255, 100),
'remote': (100, 255, 100),
# People - Green shades
'person': (100, 255, 150),
# Furniture - Purple shades
'chair': (150, 100, 255),
'couch': (200, 100, 255),
'bed': (255, 100, 255),
# Food - Orange/Red shades
'bottle': (100, 150, 255),
'cup': (100, 200, 255),
'bowl': (100, 255, 255),
# Default color
'default': (0, 255, 0)
}
return color_map.get(label, color_map['default'])
def show_detection_settings():
"""Show detection settings in the sidebar."""
with st.sidebar.expander("๐๏ธ Detection Settings"):
st.markdown("**Non-Maximum Suppression (NMS)**")
st.markdown("โ Enabled - Removes duplicate detections")
# Allow user to adjust IOU threshold
iou_threshold = st.slider(
"Overlap Threshold",
min_value=0.1,
max_value=0.9,
value=0.45,
step=0.05,
help="Lower values = fewer duplicates, Higher values = more detections"
)
st.markdown(f"**Current Settings:**")
st.markdown(f"- Overlap: {iou_threshold:.2f}")
st.markdown("- Confidence: Set below โฌ๏ธ")
return iou_threshold
# Helper function to convert AttrDict to a regular dict recursively
def convert_to_dict(obj):
if isinstance(obj, dict):
return {key: convert_to_dict(value) for key, value in obj.items()}
elif isinstance(obj, list):
return [convert_to_dict(item) for item in obj]
else:
return obj
# Define object categories for better organization
OBJECT_CATEGORIES = {
"food": ["banana", "apple", "sandwich", "orange", "broccoli", "carrot",
"hot dog", "pizza", "donut", "cake", "bottle", "wine glass",
"cup", "fork", "knife", "spoon", "bowl"],
"animals": ["bird", "cat", "dog", "horse", "sheep", "cow", "elephant",
"bear", "zebra", "giraffe"],
"vehicles": ["bicycle", "car", "motorcycle", "airplane", "bus", "train",
"truck", "boat"],
"electronics": ["tv", "laptop", "mouse", "remote", "keyboard", "cell phone",
"microwave", "oven", "toaster", "refrigerator"],
"furniture": ["chair", "couch", "potted plant", "bed", "dining table",
"toilet", "bench"],
"personal": ["backpack", "umbrella", "handbag", "tie", "suitcase"],
"sports": ["frisbee", "skis", "snowboard", "sports ball", "kite",
"baseball bat", "baseball glove", "skateboard", "surfboard",
"tennis racket"],
"household": ["bottle", "wine glass", "cup", "fork", "knife", "spoon",
"bowl", "book", "clock", "vase", "scissors", "teddy bear",
"hair drier", "toothbrush", "sink"]
}
COCO_CLASS_NAMES = {
1: 'person', 2: 'bicycle', 3: 'car', 4: 'motorcycle', 5: 'airplane',
6: 'bus', 7: 'train', 8: 'truck', 9: 'boat', 10: 'traffic light',
11: 'fire hydrant', 13: 'stop sign', 14: 'parking meter', 15: 'bench',
16: 'bird', 17: 'cat', 18: 'dog', 19: 'horse', 20: 'sheep',
21: 'cow', 22: 'elephant', 23: 'bear', 24: 'zebra', 25: 'giraffe',
27: 'backpack', 28: 'umbrella', 31: 'handbag', 32: 'tie', 33: 'suitcase',
34: 'frisbee', 35: 'skis', 36: 'snowboard', 37: 'sports ball',
38: 'kite', 39: 'baseball bat', 40: 'baseball glove', 41: 'skateboard',
42: 'surfboard', 43: 'tennis racket', 44: 'bottle', 46: 'wine glass',
47: 'cup', 48: 'fork', 49: 'knife', 50: 'spoon', 51: 'bowl',
52: 'banana', 53: 'apple', 54: 'sandwich', 55: 'orange', 56: 'broccoli',
57: 'carrot', 58: 'hot dog', 59: 'pizza', 60: 'donut', 61: 'cake',
62: 'chair', 63: 'couch', 64: 'potted plant', 65: 'bed', 67: 'dining table',
70: 'toilet', 72: 'tv', 73: 'laptop', 74: 'mouse', 75: 'remote',
76: 'keyboard', 77: 'cell phone', 78: 'microwave', 79: 'oven',
80: 'toaster', 81: 'sink', 82: 'refrigerator', 84: 'book', 85: 'clock',
86: 'vase', 87: 'scissors', 88: 'teddy bear', 89: 'hair drier', 90: 'toothbrush'
}
# Define question types
QUESTION_TYPES = [
"translation_to_target", # English โ Target language
"translation_to_english", # Target language โ English
"image_recognition", # Show image, select correct word
"category_match", # Match word to correct category
"sentence_completion", # Fill in blank in a sentence
"multiple_choice_category", # Choose words from same category
"audio_recognition" # Hear word, select correct option
]
def get_object_category(label):
"""Get the category for a detected object label."""
label = label.lower()
for category, items in OBJECT_CATEGORIES.items():
if label in items:
return category
return "other"
# Add this to optimize API usage and reduce costs
@lru_cache(maxsize=100)
def cached_vision_detection(image_hash, confidence_threshold):
"""Cache detection results based on image hash to avoid redundant API calls."""
# This is a placeholder - the actual implementation would be tied to your caching mechanism
# Return None to indicate cache miss
return None
def get_image_hash(image):
"""Create a hash of an image for caching purposes."""
img_byte_arr = io.BytesIO()
image.save(img_byte_arr, format='JPEG', quality=70) # Lower quality for hash stability
return hashlib.md5(img_byte_arr.getvalue()).hexdigest()
# Add rate limiting to avoid excessive API calls
last_api_call = 0
MIN_API_CALL_INTERVAL = 0.5 # seconds
def rate_limited_detection(image, confidence_threshold=0.5, iou_threshold=0.45):
"""Rate-limited version of detect_objects to avoid excessive API calls."""
global last_api_call
# Check cache first
image_hash = get_image_hash(image)
cached_result = cached_vision_detection(image_hash, confidence_threshold)
if cached_result:
return cached_result
# Rate limiting
current_time = time.time()
time_since_last_call = current_time - last_api_call
if time_since_last_call < MIN_API_CALL_INTERVAL:
time.sleep(MIN_API_CALL_INTERVAL - time_since_last_call)
# Make the API call
result = detect_objects(image, confidence_threshold, iou_threshold)
last_api_call = time.time()
return result
# Function to detect objects in image
def detect_objects(image, confidence_threshold=0.5, iou_threshold=0.45):
"""Detect objects using Faster R-CNN with Non-Maximum Suppression to remove duplicates."""
try:
# Load the Faster R-CNN model
detector = load_faster_rcnn_model()
if detector is None:
error_message("Failed to load Faster R-CNN model")
return [], np.array(image)
# Convert PIL image to numpy array if needed
if hasattr(image, 'convert'):
image_np = np.array(image.convert('RGB'))
else:
image_np = np.array(image)
# Convert to tensor
image_tensor = tf.convert_to_tensor(image_np)
image_tensor = image_tensor[tf.newaxis, ...]
# Run object detection
results = detector(image_tensor)
# Extract results
boxes = results['detection_boxes'][0].numpy()
classes = results['detection_classes'][0].numpy().astype(int)
scores = results['detection_scores'][0].numpy()
# Filter by confidence threshold first
valid_indices = scores >= confidence_threshold
filtered_boxes = boxes[valid_indices]
filtered_classes = classes[valid_indices]
filtered_scores = scores[valid_indices]
if len(filtered_boxes) == 0:
return [], image_np
# Apply Non-Maximum Suppression to remove duplicate detections
final_detections = apply_nms(filtered_boxes, filtered_classes, filtered_scores, image_np.shape, iou_threshold)
# Draw bounding boxes on result image
result_image = draw_detections(image_np, final_detections)
print(f"โ Faster R-CNN detected {len(final_detections)} unique objects (after NMS)")
return final_detections, result_image
except Exception as e:
error_message(f"Faster R-CNN detection error: {str(e)}")
# Return empty result on error
dummy_image = np.array(image) if hasattr(image, 'convert') else image
return [], dummy_image
# Function to enhance image quality
def enhance_image(image, enhance_type="auto"):
"""Enhance the image to improve object detection."""
try:
# Convert PIL image to numpy array
img_array = np.array(image)
if enhance_type == "auto" or enhance_type == "brightness":
# Auto-adjust brightness
gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
mean_brightness = np.mean(gray)
if mean_brightness < 100: # Image is too dark
# Increase brightness
hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
h, s, v = cv2.split(hsv)
# Calculate how much to increase brightness (more for darker images)
brightness_factor = max(1.0, (130 - mean_brightness) / 80)
v = cv2.add(v, np.array([brightness_factor * 30.0], dtype=np.uint8))
final_hsv = cv2.merge((h, s, v))
img_array = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2RGB)
elif mean_brightness > 200: # Image is too bright
# Decrease brightness
hsv = cv2.cvtColor(img_array, cv2.COLOR_RGB2HSV)
h, s, v = cv2.split(hsv)
# Reduce brightness
v = cv2.subtract(v, np.array([30], dtype=np.uint8))
final_hsv = cv2.merge((h, s, v))
img_array = cv2.cvtColor(final_hsv, cv2.COLOR_HSV2RGB)
if enhance_type == "auto" or enhance_type == "contrast":
# Enhance contrast
lab = cv2.cvtColor(img_array, cv2.COLOR_RGB2LAB)
l, a, b = cv2.split(lab)
# Apply CLAHE (Contrast Limited Adaptive Histogram Equalization)
clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))
cl = clahe.apply(l)
# Merge the CLAHE enhanced L-channel with the a and b channels
enhanced_lab = cv2.merge((cl, a, b))
img_array = cv2.cvtColor(enhanced_lab, cv2.COLOR_LAB2RGB)
# Convert back to PIL image
enhanced_image = Image.fromarray(img_array)
return enhanced_image
except Exception as e:
error_message(f"Image enhancement error: {e}")
return image # Return original image on error
# Function to detect text in image (OCR)
def detect_text_in_image(image):
"""Detect text in image using OCR."""
try:
if not has_tesseract:
return "OCR functionality requires installing pytesseract."
# Convert PIL image to numpy array
img_array = np.array(image)
# Convert to grayscale
gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
# Apply threshold to get image with only black and white
_, binary = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY_INV)
# Apply dilation and erosion to remove noise
kernel = np.ones((1, 1), np.uint8)
processed = cv2.dilate(binary, kernel, iterations=1)
processed = cv2.erode(processed, kernel, iterations=1)
# Invert back
processed = cv2.bitwise_not(processed)
# Detect text
detected_text = pytesseract.image_to_string(processed)
# Clean and process the text
detected_text = detected_text.strip()
return detected_text
except Exception as e:
return f"Text detection error: {e}"
# Function to get example sentence
def get_example_sentence(word, target_language):
"""Generate an example sentence using the word via the example generator."""
# Try to determine category from OBJECT_CATEGORIES
category = None
for cat_name, items in OBJECT_CATEGORIES.items():
if word.lower() in [item.lower() for item in items]:
category = cat_name
break
# Call the generator with the category hint
return example_generator.get_example_sentence(word, target_language, category)
# Function to get pronunciation guide
def get_pronunciation_guide(word, language_code):
"""Generate a simple pronunciation guide for the word."""
try:
# Map of common sounds in different languages
pronunciation_maps = {
"es": { # Spanish
'j': 'h', 'll': 'y', 'รฑ': 'ny', 'rr': 'rolled r'
},
"fr": { # French
'eau': 'oh', 'au': 'oh', 'ai': 'eh', 'ou': 'oo', 'u': 'รผ', 'r': 'guttural r'
},
"de": { # German
'sch': 'sh', 'ch': 'kh/sh', 'ei': 'eye', 'ie': 'ee', 'รค': 'eh', 'รถ': 'er', 'รผ': 'รผ'
},
"it": { # Italian
'gn': 'ny', 'gli': 'ly', 'ch': 'k', 'c+e/i': 'ch', 'c+a/o/u': 'k'
}
}
# Get pronunciation map for this language
sound_map = pronunciation_maps.get(language_code, {})
# Build pronunciation guide
notes = []
for sound, pronunciation in sound_map.items():
if sound in word.lower():
notes.append(f"'{sound}' sounds like '{pronunciation}'")
return notes
except Exception as e:
return [f"Pronunciation guide unavailable: {str(e)}"]
# Function to create a database session
def create_session_direct():
"""Create a session directly using SQLite."""
try:
# Connect to the database
conn = sqlite3.connect("language_learning.db")
cursor = conn.cursor()
# Insert a new session with the current time
current_time = datetime.datetime.now()
cursor.execute(
"INSERT INTO sessions (start_time, words_studied, words_learned) VALUES (?, 0, 0)",
(current_time,)
)
conn.commit()
# Get the last inserted ID
session_id = cursor.lastrowid
conn.close()
return session_id
except Exception as e:
error_message(f"Direct session creation error: {str(e)}")
return None
# Function to add vocabulary to the database
def add_vocabulary_direct(word_original, word_translated, language_translated, category=None, image_path=None):
"""Add vocabulary directly using SQLite with improved error handling for duplicates and locks."""
try:
# Original function code here...
# Connect to the database with timeout to handle locks
conn = sqlite3.connect("language_learning.db", timeout=10.0)
cursor = conn.cursor()
# Check if this word already exists in this language
cursor.execute(
"SELECT id FROM vocabulary WHERE word_original = ? AND language_translated = ?",
(word_original, language_translated)
)
existing_word = cursor.fetchone()
# If word exists, update it rather than inserting a new one
if existing_word:
vocab_id = existing_word[0]
# Update the existing word with new translation and image if provided
cursor.execute(
"UPDATE vocabulary SET word_translated = ?, category = ?, image_path = ? WHERE id = ?",
(word_translated, category, image_path, vocab_id)
)
# Let the user know we're updating
info_message(f"Word '{word_original}' already exists in {language_translated}. Updating with new information.")
else:
# Current time for timestamps
current_time = datetime.datetime.now()
# Insert a new word
try:
# Try with source column
cursor.execute('''
INSERT INTO vocabulary
(word_original, word_translated, language_translated, category, image_path, date_added, source)
VALUES (?, ?, ?, ?, ?, ?, 'manual')
''', (word_original, word_translated, language_translated, category, image_path, current_time))
except sqlite3.OperationalError as e:
if 'no column named source' in str(e):
# Try without source column
cursor.execute('''
INSERT INTO vocabulary
(word_original, word_translated, language_translated, category, image_path, date_added)
VALUES (?, ?, ?, ?, ?, ?)
''', (word_original, word_translated, language_translated, category, image_path, current_time))
else:
raise e
# Get the last inserted ID
vocab_id = cursor.lastrowid
# Check if we need to add user progress
cursor.execute("SELECT id FROM user_progress WHERE vocabulary_id = ?", (vocab_id,))
if not cursor.fetchone():
# Initialize user progress for this vocabulary
cursor.execute('''
INSERT INTO user_progress (vocabulary_id, last_reviewed, proficiency_level)
VALUES (?, ?, 0)
''', (vocab_id, current_time))
# Commit changes and close
conn.commit()
conn.close()
# NEW CODE: Integration with gamification system - with error handling
if vocab_id:
try:
# Check for gamification achievements
gamification.check_achievements(
"word_learned",
word=word_original,
category=category,
language=language_translated
)
# Check for daily challenges
gamification.check_challenge_progress(
word_original=word_original,
word_translated=word_translated,
language=language_translated
)
except Exception as e:
print(f"Gamification error in add_vocabulary_direct: {e}")
return vocab_id
except sqlite3.OperationalError as e:
# Handle database locks with specific advice
if 'database is locked' in str(e):
error_message("Database is currently locked. Please wait a moment and try again.")
# Add a small delay to allow the database to unlock
time.sleep(1.5)
else:
error_message(f"Database error: {str(e)}")
return None
except Exception as e:
error_message(f"Direct vocabulary save error: {str(e)}")
return None
# Function to get all vocabulary items from the database
def get_all_vocabulary_direct():
"""Get all vocabulary items directly from SQLite."""
try:
# Connect to the database
conn = sqlite3.connect("language_learning.db")
# Use dictionary cursor for easier access
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
# Get all vocabulary with user progress info
cursor.execute('''
SELECT v.id, v.word_original, v.word_translated, v.language_translated,
v.category, v.image_path, v.date_added,
up.proficiency_level, up.review_count, up.correct_count, up.last_reviewed
FROM vocabulary v
LEFT JOIN user_progress up ON v.id = up.vocabulary_id
ORDER BY v.date_added DESC
''')
# Fetch all results
results = cursor.fetchall()
# Convert to list of dictionaries
vocabulary = []
for row in results:
# Convert row to dictionary
word = dict(row)
vocabulary.append(word)
conn.close()
return vocabulary
except Exception as e:
error_message(f"Error retrieving vocabulary: {str(e)}")
return []
# Function to get session statistics
def get_session_stats_direct(days=30):
"""Get session statistics directly from SQLite."""
try:
# Connect to the database
conn = sqlite3.connect("language_learning.db")
cursor = conn.cursor()
# Calculate date for filtering
current_time = datetime.datetime.now()
start_date = current_time - datetime.timedelta(days=days)
# Convert to string format
start_date_str = start_date.strftime("%Y-%m-%d")
# Get total sessions
cursor.execute(
"SELECT COUNT(*) FROM sessions WHERE start_time >= ?",
(start_date_str,)
)
total_sessions = cursor.fetchone()[0]
# Get words studied and learned
cursor.execute(
"SELECT SUM(words_studied), SUM(words_learned) FROM sessions WHERE start_time >= ?",
(start_date_str,)
)
result = cursor.fetchone()
total_words_studied = result[0] if result[0] else 0
total_words_learned = result[1] if result[1] else 0
# Calculate averages
avg_words_per_session = total_words_studied / total_sessions if total_sessions > 0 else 0
# Get session durations
cursor.execute(
"""
SELECT start_time, end_time
FROM sessions
WHERE start_time >= ? AND end_time IS NOT NULL
""",
(start_date_str,)
)
# Calculate average session length
total_minutes = 0
session_count = 0
for start_time_str, end_time_str in cursor.fetchall():
try:
# Parse the datetime strings
start_time = datetime.datetime.fromisoformat(start_time_str.replace(' ', 'T'))
end_time = datetime.datetime.fromisoformat(end_time_str.replace(' ', 'T'))
# Calculate duration in minutes
duration = (end_time - start_time).total_seconds() / 60
total_minutes += duration
session_count += 1
except:
pass
avg_session_minutes = total_minutes / session_count if session_count > 0 else 0
conn.close()
# Return stats dictionary
return {
'total_sessions': total_sessions,
'total_words_studied': total_words_studied,
'total_words_learned': total_words_learned,
'avg_words_per_session': avg_words_per_session,
'avg_session_minutes': avg_session_minutes
}
except Exception as e:
error_message(f"Error retrieving session stats: {str(e)}")
return {}
# Function to check if database is properly set up
def check_database_setup():
"""Check if the database is properly set up and try to fix if needed."""
try:
conn = sqlite3.connect("language_learning.db")
cursor = conn.cursor()
# Check if tables exist
cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
tables = [table[0] for table in cursor.fetchall()]
required_tables = ['vocabulary', 'user_progress', 'sessions', 'camera_translations']
missing_tables = [table for table in required_tables if table not in tables]
if missing_tables:
# Create missing tables
if 'vocabulary' in missing_tables:
cursor.execute('''
CREATE TABLE IF NOT EXISTS vocabulary (
id INTEGER PRIMARY KEY,
word_original TEXT NOT NULL,
word_translated TEXT NOT NULL,
language_translated TEXT NOT NULL,
category TEXT,
image_path TEXT,
date_added TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
source TEXT DEFAULT 'manual'
);
''')
if 'user_progress' in missing_tables:
cursor.execute('''
CREATE TABLE IF NOT EXISTS user_progress (
id INTEGER PRIMARY KEY,
vocabulary_id INTEGER,
review_count INTEGER DEFAULT 0,
correct_count INTEGER DEFAULT 0,
last_reviewed TIMESTAMP,
proficiency_level INTEGER DEFAULT 0,
FOREIGN KEY (vocabulary_id) REFERENCES vocabulary (id)
);
''')
if 'sessions' in missing_tables:
cursor.execute('''
CREATE TABLE IF NOT EXISTS sessions (
id INTEGER PRIMARY KEY,
start_time TIMESTAMP,
end_time TIMESTAMP,
words_studied INTEGER DEFAULT 0,
words_learned INTEGER DEFAULT 0
);
''')
if 'camera_translations' in missing_tables:
cursor.execute('''
CREATE TABLE IF NOT EXISTS camera_translations (
id INTEGER PRIMARY KEY,
image_path TEXT,
detected_text TEXT,
translated_text TEXT,
source_language TEXT,
target_language TEXT,
date_captured TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
is_saved_to_vocabulary BOOLEAN DEFAULT 0
);
''')
conn.commit()
conn.close()
return True
except Exception as e:
error_message(f"Database error: {e}")
return False
def prepare_vocabulary_for_diverse_questions(vocabulary, languages):
"""Enhance vocabulary data to support diverse question types."""
total_words = len(vocabulary)
words_with_categories = 0
words_with_images = 0
words_with_examples = 0
# Count and prepare vocabulary for diverse questions
for word in vocabulary:
# Check/count category
if word.get('category') and word['category'] not in ['other', 'manual', '']:
words_with_categories += 1
# Check/count image
if word.get('image_path') and os.path.exists(word.get('image_path', '')):
words_with_images += 1
# Test for example sentence
try:
example = get_example_sentence(word.get('word_original', ''), word.get('language_translated', 'en'))
if example and example.get('translated'):
words_with_examples += 1
except:
pass
if st.session_state.debug_quiz:
st.sidebar.markdown("### Vocabulary Stats")
st.sidebar.markdown(f"Total words: {total_words}")
st.sidebar.markdown(f"With categories: {words_with_categories}")
st.sidebar.markdown(f"With images: {words_with_images}")
st.sidebar.markdown(f"With examples: {words_with_examples}")
return vocabulary
if 'db_checked' not in st.session_state:
st.session_state.db_checked = check_database_setup()
def debug_button(label, **kwargs):
"""Debug wrapper that shows what parameters are being passed to a button and ensures uniqueness"""
import inspect
import time
# Get the caller info
caller = inspect.getframeinfo(inspect.currentframe().f_back)
# Create a unique key based on the calling file, line number, and timestamp
if 'key' not in kwargs:
caller_id = f"{caller.filename.split('/')[-1]}_{caller.lineno}"
timestamp = int(time.time() * 1000) % 10000 # Use last 4 digits of timestamp for readability
unique_key = f"{label.replace(' ', '_')}_{caller_id}_{timestamp}"
kwargs['key'] = unique_key
# For debugging, uncomment this line to see what keys are being generated
# print(f"Button: {label}, Key: {kwargs['key']}")
# Remove any problematic parameters if present
if 'use_column_width' in kwargs:
del kwargs['use_column_width']
if 'type' in kwargs and kwargs['type'] == 'primary':
del kwargs['type']
# Use the cleaned kwargs
return st.button(label, **kwargs)
def safe_button(label, **kwargs):
"""Safe wrapper for st.button that ensures uniqueness and removes problematic parameters"""
import time
# Generate a unique key if none provided
if 'key' not in kwargs:
# Create unique key based on label and timestamp
timestamp = int(time.time() * 1000) % 10000 # Use last 4 digits of timestamp for readability
unique_key = f"{label.replace(' ', '_')}_{timestamp}"
kwargs['key'] = unique_key
# Remove problematic parameters if present
if 'use_column_width' in kwargs:
del kwargs['use_column_width']
if 'type' in kwargs and kwargs['type'] == 'primary':
del kwargs['type']
# Use the cleaned kwargs
return st.button(label, **kwargs)
# Initialize database
@st.cache_resource
def get_database():
return LanguageLearningDB("language_learning.db")
db = get_database()
# Initialize processing queue in session state for background tasks
if 'processing_queue' not in st.session_state:
st.session_state.processing_queue = queue.Queue()
if 'processing_results' not in st.session_state:
st.session_state.processing_results = {}
if 'processing_complete' not in st.session_state:
st.session_state.processing_complete = False
# Initialize session state for manual mode
if 'manual_mode' not in st.session_state:
st.session_state.manual_mode = False
if 'manual_label' not in st.session_state:
st.session_state.manual_label = ""
# Initialize session state variables
if 'target_language' not in st.session_state:
st.session_state.target_language = "es" # Default to Spanish
if 'session_id' not in st.session_state:
st.session_state.session_id = None
if 'words_studied' not in st.session_state:
st.session_state.words_studied = 0
if 'words_learned' not in st.session_state:
st.session_state.words_learned = 0
if 'quiz_score' not in st.session_state:
st.session_state.quiz_score = 0
if 'quiz_total' not in st.session_state:
st.session_state.quiz_total = 0
if 'current_quiz_word' not in st.session_state:
st.session_state.current_quiz_word = None
if 'quiz_options' not in st.session_state:
st.session_state.quiz_options = []
if 'answered' not in st.session_state:
st.session_state.answered = False
if 'detection_checkboxes' not in st.session_state:
st.session_state.detection_checkboxes = {}
# Ensure session state variables are initialized first
if 'level' not in st.session_state:
st.session_state.level = 1
if 'points' not in st.session_state:
st.session_state.points = 0
if 'streak_days' not in st.session_state:
st.session_state.streak_days = 0
if 'daily_challenges' not in st.session_state:
st.session_state.daily_challenges = []
if 'word_of_the_day' not in st.session_state:
st.session_state.word_of_the_day = None
# For debugging question type selection
if 'debug_quiz' not in st.session_state:
st.session_state.debug_quiz = False
# Add these initializations with your other session state initializations
# Add these initializations with your other session state initializations
if 'audio_data' not in st.session_state:
st.session_state.audio_data = None
if 'audio_data_received' not in st.session_state:
st.session_state.audio_data_received = False
if 'current_recording_word' not in st.session_state:
st.session_state.current_recording_word = None
if 'use_vision_api' not in st.session_state:
st.session_state.use_vision_api = True
# Always force it to be True
st.session_state.use_vision_api = True
if 'app_mode' not in st.session_state:
st.session_state.app_mode = "Camera Mode"
# Add flag to track save button state
if 'save_button_clicked' not in st.session_state:
st.session_state.save_button_clicked = False
if 'words_just_saved' not in st.session_state:
st.session_state.words_just_saved = False
if 'saved_count' not in st.session_state:
st.session_state.saved_count = 0
if 'saved_items' not in st.session_state:
st.session_state.saved_items = []
if 'faster_rcnn_model_loaded' not in st.session_state:
st.session_state.faster_rcnn_model_loaded = False
def get_gamification():
# Initialize GamificationSystem without the translate function for now
return GamificationSystem()
# Initialize gamification
gamification = get_gamification()
# Make sure state is explicitly initialized
gamification.initialize_state()
# Function to translate text
class FreeTranslationService:
def __init__(self):
self.translation_cache = {}
self.last_request_time = 0
self.rate_limit_delay = 1.0 # seconds between requests
def translate_text(self, text, target_language, source_language='en'):
"""
Translate text using multiple free services with fallbacks
"""
# Check cache first
cache_key = f"{text}_{source_language}_{target_language}"
if cache_key in self.translation_cache:
return self.translation_cache[cache_key]
# Rate limiting
current_time = time.time()
if current_time - self.last_request_time < self.rate_limit_delay:
time.sleep(self.rate_limit_delay - (current_time - self.last_request_time))
translation = None
# Method 1: Deep Translator (Free Google Translate web interface)
try:
translator = GoogleTranslator(source=source_language, target=target_language)
translation = translator.translate(text)
if translation and translation != text:
self.translation_cache[cache_key] = translation
self.last_request_time = time.time()
return translation
except Exception as e:
print(f"Deep Translator failed: {e}")
# Method 2: MyMemory Translation API (Free tier: 10,000 chars/day)
try:
translation = self._translate_with_mymemory(text, source_language, target_language)
if translation:
self.translation_cache[cache_key] = translation
self.last_request_time = time.time()
return translation
except Exception as e:
print(f"MyMemory failed: {e}")
# Method 3: LibreTranslate (if you have a server)
try:
translation = self._translate_with_libretranslate(text, source_language, target_language)
if translation:
self.translation_cache[cache_key] = translation
self.last_request_time = time.time()
return translation
except Exception as e:
print(f"LibreTranslate failed: {e}")
# Method 4: Hugging Face models (for specific language pairs)
try:
translation = self._translate_with_huggingface(text, source_language, target_language)
if translation:
self.translation_cache[cache_key] = translation
self.last_request_time = time.time()
return translation
except Exception as e:
print(f"Hugging Face translation failed: {e}")
# Fallback: Return formatted message
return f"[Translation to {target_language} unavailable]"
def _translate_with_mymemory(self, text, source_lang, target_lang):
"""MyMemory Translation API - Free tier"""
url = "https://api.mymemory.translated.net/get"
params = {
'q': text,
'langpair': f"{source_lang}|{target_lang}"
}
response = requests.get(url, params=params, timeout=10)
if response.status_code == 200:
data = response.json()
if data.get('responseStatus') == 200:
return data['responseData']['translatedText']
return None
def _translate_with_libretranslate(self, text, source_lang, target_lang):
"""LibreTranslate - Free self-hosted option"""
# You can use the free public instance (limited) or host your own
url = "https://libretranslate.de/translate" # Public instance
data = {
'q': text,
'source': source_lang,
'target': target_lang,
'format': 'text'
}
response = requests.post(url, data=data, timeout=10)
if response.status_code == 200:
result = response.json()
return result.get('translatedText')
return None
def _translate_with_huggingface(self, text, source_lang, target_lang):
"""Hugging Face translation models - Completely free"""
try:
# Map language codes to model names (add more as needed)
model_map = {
('en', 'es'): 'Helsinki-NLP/opus-mt-en-es',
('en', 'fr'): 'Helsinki-NLP/opus-mt-en-fr',
('en', 'de'): 'Helsinki-NLP/opus-mt-en-de',
('en', 'it'): 'Helsinki-NLP/opus-mt-en-it',
('en', 'pt'): 'Helsinki-NLP/opus-mt-en-pt',
('en', 'ru'): 'Helsinki-NLP/opus-mt-en-ru',
# Add reverse translations
('es', 'en'): 'Helsinki-NLP/opus-mt-es-en',
('fr', 'en'): 'Helsinki-NLP/opus-mt-fr-en',
('de', 'en'): 'Helsinki-NLP/opus-mt-de-en',
}
model_name = model_map.get((source_lang, target_lang))
if not model_name:
return None
# Load model and tokenizer
translator = pipeline(
"translation",
model=model_name,
return_all_scores=False,
max_length=512
)
result = translator(text)
return result[0]['translation_text']
except Exception as e:
print(f"Hugging Face model error: {e}")
return None
# Initialize the service
free_translator = FreeTranslationService()
# Replace your translate_text function with this:
def translate_text(text, target_language, source_language='en'):
return free_translator.translate_text(text, target_language, source_language)
# Connect the translation function to gamification system after both are initialized
gamification.set_translate_func(translate_text)
@st.cache_resource
def get_example_generator():
"""Initialize and cache the example sentence generator."""
return ExampleSentenceGenerator(translate_func=translate_text, debug=True)
example_generator = get_example_generator()
# Function for text-to-speech
def text_to_speech(text, lang):
try:
tts = gTTS(text=text, lang=lang, slow=False)
mp3_fp = BytesIO()
tts.write_to_fp(mp3_fp)
mp3_fp.seek(0)
audio_bytes = mp3_fp.read()
return audio_bytes
except Exception as e:
error_message(f"Text-to-speech error: {e}")
return None
# Function to generate HTML for audio playback
def get_audio_html(audio_bytes):
"""Generate HTML for audio playback without autoplay."""
audio_base64 = base64.b64encode(audio_bytes).decode()
# Remove the autoplay attribute - only keep controls
audio_tag = f''
return audio_tag
# Function to load RCNN Model
@st.cache_resource
def load_faster_rcnn_model():
"""Load and cache the Faster R-CNN model from TensorFlow Hub."""
try:
print("Loading Faster R-CNN model...")
model_url = "https://tfhub.dev/tensorflow/faster_rcnn/resnet50_v1_640x640/1"
detector = hub.load(model_url)
print("โ Faster R-CNN model loaded successfully!")
return detector
except Exception as e:
print(f"โ Error loading Faster R-CNN model: {e}")
return None
# Background worker function for object detection
def detect_objects_worker(image, confidence_threshold, iou_threshold, task_id):
"""Worker function to run detection in background."""
try:
# Run detection
detections, rendered_image = detect_objects(image, confidence_threshold, iou_threshold)
# Store results
st.session_state.processing_results[task_id] = {
'detections': detections,
'result_image': rendered_image
}
# Mark task as complete
st.session_state.processing_complete = True
except Exception as e:
# Store error
st.session_state.processing_results[task_id] = {
'error': str(e)
}
st.session_state.processing_complete = True
# Function to start or end a learning session
def manage_session(action):
"""Start or end learning session with improved error handling."""
if action == "start":
try:
# Try to use the direct method instead of the database object
session_id = create_session_direct()
if session_id:
st.session_state.session_id = session_id
st.session_state.words_studied = 0
st.session_state.words_learned = 0
success_message(f"Started new learning session!")
return True
else:
error_message("Failed to create a session directly. Check database permissions.")
return False
except Exception as e:
error_message(f"Error starting session: {str(e)}")
return False
elif action == "end" and st.session_state.session_id:
try:
# Connect directly to the database
conn = sqlite3.connect("language_learning.db")
cursor = conn.cursor()
# Update the session with end time and stats
current_time = datetime.datetime.now()
cursor.execute(
"UPDATE sessions SET end_time = ?, words_studied = ?, words_learned = ? WHERE id = ?",
(current_time, st.session_state.words_studied, st.session_state.words_learned, st.session_state.session_id)
)
conn.commit()
conn.close()
success_message(f"Session completed! Words studied: {st.session_state.words_studied}, Words learned: {st.session_state.words_learned}")
# Clear session state
st.session_state.session_id = None
st.session_state.words_studied = 0
st.session_state.words_learned = 0
return True
except Exception as e:
error_message(f"Error ending session: {str(e)}")
return False
return False
# Function to save image
def save_image(image, label):
try:
# Convert PIL Image to OpenCV format
img_array = np.array(image)
img_cv = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
# Create directory if it doesn't exist
os.makedirs("object_images", exist_ok=True)
# Save image
filename = f"object_images/{label}_{int(time.time())}.jpg"
cv2.imwrite(filename, img_cv)
return filename
except Exception as e:
error_message(f"Error saving image: {e}")
return None
# Function to start a new quiz
def start_new_quiz(vocabulary, num_questions=5):
# Reset quiz state
st.session_state.quiz_score = 0
st.session_state.quiz_total = 0
st.session_state.answered = False
if not vocabulary or len(vocabulary) < 4:
warning_message("Not enough vocabulary words for a quiz (need at least 4).")
return False
# Start a new session if needed
if not st.session_state.session_id:
st.session_state.session_id = create_session_direct()
st.session_state.words_studied = 0
st.session_state.words_learned = 0
# Set up first question
setup_new_question(vocabulary)
return True
# Function to set up a new quiz question
def setup_new_question(vocabulary):
if not vocabulary:
return False
# Select a random word as the question
st.session_state.current_quiz_word = np.random.choice(vocabulary)
# Create options (3 wrong + 1 correct)
options = [st.session_state.current_quiz_word]
while len(options) < 4:
wrong_option = np.random.choice(vocabulary)
if wrong_option['id'] != st.session_state.current_quiz_word['id'] and not any(o['id'] == wrong_option['id'] for o in options):
options.append(wrong_option)
# Shuffle options
np.random.shuffle(options)
st.session_state.quiz_options = options
st.session_state.answered = False
return True
# Function to update word progress in the database
def update_word_progress_direct(vocab_id, is_correct):
"""Update word progress directly using SQLite."""
try:
# Connect to the database
conn = sqlite3.connect("language_learning.db")
cursor = conn.cursor()
# Current time for timestamp
current_time = datetime.datetime.now()
# Get current progress
cursor.execute(
"""
SELECT review_count, correct_count, proficiency_level
FROM user_progress
WHERE vocabulary_id = ?
""",
(vocab_id,)
)
result = cursor.fetchone()
if result:
review_count, correct_count, proficiency_level = result
# Increment counts
review_count = review_count + 1 if review_count else 1
correct_count = correct_count + 1 if correct_count and is_correct else (1 if is_correct else 0)
# Calculate proficiency (0-5 scale)
if review_count > 0:
accuracy = correct_count / review_count
if accuracy >= 0.9 and review_count >= 5:
proficiency_level = 5
elif accuracy >= 0.8 and review_count >= 4:
proficiency_level = 4
elif accuracy >= 0.6 and review_count >= 3:
proficiency_level = 3
elif accuracy >= 0.4 and review_count >= 2:
proficiency_level = 2
elif accuracy >= 0.2:
proficiency_level = 1
else:
proficiency_level = 0
# Update progress
cursor.execute(
"""
UPDATE user_progress
SET review_count = ?, correct_count = ?, proficiency_level = ?, last_reviewed = ?
WHERE vocabulary_id = ?
""",
(review_count, correct_count, proficiency_level, current_time, vocab_id)
)
else:
# Create new progress entry
cursor.execute(
"""
INSERT INTO user_progress
(vocabulary_id, review_count, correct_count, proficiency_level, last_reviewed)
VALUES (?, ?, ?, ?, ?)
""",
(vocab_id, 1, 1 if is_correct else 0, 1 if is_correct else 0, current_time)
)
conn.commit()
conn.close()
return True
except Exception as e:
error_message(f"Error updating word progress: {str(e)}")
return False
# Function to check quiz answer
def check_answer(selected_index):
"""Check if selected quiz answer is correct and update progress."""
if st.session_state.answered:
return
selected_word = st.session_state.quiz_options[selected_index]
is_correct = selected_word['id'] == st.session_state.current_quiz_word['id']
# Update database using direct method instead of db class
update_word_progress_direct(st.session_state.current_quiz_word['id'], is_correct)
# Update session stats
st.session_state.words_studied += 1
if is_correct:
st.session_state.words_learned += 1
st.session_state.quiz_score += 1
st.session_state.quiz_total += 1
st.session_state.answered = True
# Check if any challenges are completed - with error handling
try:
gamification.check_challenge_progress(
quiz_score=st.session_state.quiz_score,
quiz_total=st.session_state.quiz_total
)
# Check for quiz-related achievements
if st.session_state.quiz_total >= 5: # Only check if quiz is substantial
gamification.check_achievements(
"quiz_completed",
score=st.session_state.quiz_score,
total=st.session_state.quiz_total
)
except Exception as e:
print(f"Gamification error in check_answer: {e}")
return is_correct
# Global counter for truly unique widget IDs
if 'widget_counter' not in st.session_state:
st.session_state.widget_counter = 0
def truly_safe_button(label, **kwargs):
"""Button helper that guarantees unique keys even with rapid clicks"""
# Increment the global counter
st.session_state.widget_counter += 1
# Generate a unique key if none provided
if 'key' not in kwargs:
# Create unique key based on counter + millisecond timestamp
import time
timestamp = int(time.time() * 1000000) % 1000000 # Microsecond part only
counter = st.session_state.widget_counter
unique_key = f"{label.replace(' ', '_').lower()}_{counter}_{timestamp}"
kwargs['key'] = unique_key
# Remove problematic parameters if present
if 'use_column_width' in kwargs:
del kwargs['use_column_width']
if 'type' in kwargs and kwargs['type'] == 'primary':
kwargs['type'] = None # Set to None instead of deleting
# Use the cleaned kwargs
return st.button(label, **kwargs)
def safe_button(label, **kwargs):
"""Alias for truly_safe_button for backward compatibility"""
return truly_safe_button(label, **kwargs)
# Main sidebar for navigation
st.sidebar.title("๐ Vocam")
app_mode_options = ["Camera Mode", "My Vocabulary", "Quiz Mode", "Statistics", "My Progress", "Pronunciation Practice"]
if 'app_mode' in st.session_state:
# Use the session state value as the default index for the selectbox
default_index = app_mode_options.index(st.session_state.app_mode) if st.session_state.app_mode in app_mode_options else 0
else:
default_index = 0
app_mode = st.sidebar.selectbox(
"Choose a mode",
app_mode_options,
index=default_index
)
# Update session state with the current selection (might be from selectbox or previous setting)
st.session_state.app_mode = app_mode
# Add gamification info to the sidebar
try:
gamification.update_sidebar()
except Exception as e:
st.sidebar.markdown('
'
'
๐ Gamification
'
'
System initializing...
'
'
', unsafe_allow_html=True)
print(f"Sidebar update error: {e}")
# Language selection
languages = {
"Spanish": "es",
"French": "fr",
"German": "de",
"Italian": "it",
"Portuguese": "pt",
"Russian": "ru",
"Japanese": "ja",
"Chinese (Simplified)": "zh-CN"
}
selected_language = st.sidebar.selectbox(
"Select target language",
list(languages.keys()),
index=list(languages.values()).index(st.session_state.target_language) if st.session_state.target_language in languages.values() else 0
)
# Get the language code from the dropdown selection
st.session_state.target_language = languages[selected_language]
# Force update word of the day translation immediately (UPDATED APPROACH)
if 'word_of_the_day' in st.session_state and st.session_state.word_of_the_day:
wotd = st.session_state.word_of_the_day
original_word = wotd.get('original', '')
# Hard-coded translations for "book" in different languages
book_translations = {
"es": "libro",
"fr": "livre",
"de": "Buch",
"it": "libro",
"pt": "livro",
"ru": "ะบะฝะธะณะฐ",
"ja": "ๆฌ",
"zh-CN": "ไนฆ"
}
# Check if the word is "book" and update translation
if original_word.lower() == "book" and st.session_state.target_language in book_translations:
wotd['translated'] = book_translations[st.session_state.target_language]
st.session_state.word_of_the_day = wotd
# Add this right after your language selection code
# Force update word of the day when language changes
if 'previous_language' not in st.session_state:
st.session_state.previous_language = st.session_state.target_language
# Check if language has changed
if st.session_state.previous_language != st.session_state.target_language:
# Language changed - force update word of the day
if 'word_of_the_day' in st.session_state and st.session_state.word_of_the_day:
wotd = st.session_state.word_of_the_day
original = wotd.get('original', '')
# Translation dictionary for common words
translations = {
"book": {
"es": "libro", "fr": "livre", "de": "Buch", "it": "libro",
"pt": "livro", "ru": "ะบะฝะธะณะฐ", "ja": "ๆฌ", "zh-CN": "ไนฆ"
},
"hello": {
"es": "hola", "fr": "bonjour", "de": "hallo", "it": "ciao",
"pt": "olรก", "ru": "ะฟัะธะฒะตั", "ja": "ใใใซใกใฏ", "zh-CN": "ไฝ ๅฅฝ"
},
# Include all other translations from the previous solution
}
# Get updated translation for current language
new_lang = st.session_state.target_language
if original.lower() in translations and new_lang in translations[original.lower()]:
wotd['translated'] = translations[original.lower()][new_lang]
wotd['language'] = new_lang
st.session_state.word_of_the_day = wotd
# Update previous language to current
st.session_state.previous_language = st.session_state.target_language
# Force rerun to update UI
st.rerun()
# Add help section to the sidebar
with st.sidebar.expander("โน๏ธ Need Help?"):
st.markdown("""
**Quick Tips:**
- ๐ธ Use **Camera Mode** to capture objects and learn new words
- ๐ Review your words in **My Vocabulary**
- ๐ฎ Test yourself in **Quiz Mode**
- ๐ Track your progress in **Statistics**
**On Mobile:**
- After taking a picture, scroll down to see results
- Tap buttons to navigate between sections
""")
# Display appropriate content based on selected mode
if app_mode == "Camera Mode":
style_title("๐ธ Camera Mode")
# Use the enhanced info message
info_message("Take a photo or upload an image to identify objects and learn new vocabulary.")
# Session management
session_container = st.container()
with session_container:
col1, col2 = st.columns(2)
with col1:
# Always create a placeholder for the start button
start_button_placeholder = st.empty()
# Conditionally show the button or message
if st.session_state.session_id is None:
if start_button_placeholder.button("Start Learning Session", key="start_session_btn"):
if manage_session("start"):
st.rerun()
else:
# Show session info in the same place
start_button_placeholder.markdown(
f'
'
f'Session in progress - Words: {st.session_state.words_learned}'
f'
',
unsafe_allow_html=True
)
with col2:
# Always create a placeholder for the end button
end_button_placeholder = st.empty()
# Only show the end button when a session is active
if st.session_state.session_id is not None:
if end_button_placeholder.button("End Session", key="end_session_btn"):
if manage_session("end"):
st.rerun()
else:
# Empty space with same height to maintain layout
end_button_placeholder.markdown(
'',
unsafe_allow_html=True
)
# Image input options
image_tab1, image_tab2 = st.tabs(["๐ท Take a Photo", "๐ Upload Image"])
image = None
# First tab: Camera
with image_tab1:
picture = st.camera_input("Take a picture", key="camera_input")
if picture is not None:
image = Image.open(picture)
# Second tab: Upload
with image_tab2:
uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"], key="file_uploader")
if uploaded_file is not None:
image = Image.open(uploaded_file)
# Detection options
detection_type = st.radio(
"What would you like to detect?",
["Objects", "Text (OCR)"],
index=0
)
# Detection settings for objects
if detection_type == "Objects":
col1, col2 = st.columns(2)
with col1:
confidence_threshold = st.slider(
"Detection Confidence",
min_value=0.3,
max_value=0.9,
value=0.5,
step=0.05
)
with col2:
iou_threshold = st.slider(
"Duplicate Removal",
min_value=0.1,
max_value=0.9,
value=0.45,
step=0.05,
help="Lower = fewer duplicates"
)
# Set iou_threshold for optimal detection (balance between precision and maximum detection)
iou_threshold = 0.45 # Using a lower threshold to detect more objects while maintaining precision
# Auto-enhancement is always applied
enhancement_type = "auto"
# Process image if available
if image is not None:
# Always apply enhancement for object detection
if detection_type == "Objects":
with st.spinner("Enhancing image for better detection..."):
enhanced_image = enhance_image(image, enhancement_type)
# Use the enhanced image for detection
image_for_detection = enhanced_image
else:
image_for_detection = image
# Process based on detection type
if detection_type == "Objects":
# Use a placeholder for the spinner that we can clear later
spinner_placeholder = st.empty()
with spinner_placeholder.container():
show_loading_spinner("Detecting objects... This may take a few seconds.")
# Add visual separator for mobile
separator_placeholder = st.empty()
separator_placeholder.markdown('', unsafe_allow_html=True)
# Perform the detection while showing a native spinner
with st.spinner("Processing..."):
detections, result_image = detect_objects(image_for_detection, confidence_threshold, iou_threshold)
# Clear the spinner and separator completely
spinner_placeholder.empty()
separator_placeholder.empty()
# Display results
if detections:
style_section_title("โจ Detected Objects")
# Display image with detection boxes
st.image(result_image, caption="Detected Objects")
# Display selection prompt
st.write("Select objects to save to your vocabulary:")
# Group detections by category
# Group detections by label to avoid duplicates
unique_detections = {}
for i, detection in enumerate(detections):
label = detection['label']
confidence = detection['confidence']
# If label already exists and new confidence is lower, skip
if label in unique_detections and unique_detections[label][1]['confidence'] >= confidence:
continue
# Otherwise add/update this label with highest confidence detection
unique_detections[label] = (i, detection)
# Now group the unique detections by category
categorized_detections = {}
for i, detection in unique_detections.values():
label = detection['label']
category = get_object_category(label)
if category not in categorized_detections:
categorized_detections[category] = []
categorized_detections[category].append((i, detection))
# Clear detection checkboxes for new image
if 'last_image_hash' not in st.session_state or st.session_state.last_image_hash != get_image_hash(image):
st.session_state.detection_checkboxes = {}
st.session_state.last_image_hash = get_image_hash(image)
# Display objects by category in expandable sections
for category, category_detections in categorized_detections.items():
with st.expander(f"{category.title()} ({len(category_detections)} items)", expanded=True):
# Process each detection in this category
for i, detection in category_detections:
label = detection['label']
confidence = detection['confidence']
checkbox_key = f"detect_{i}"
# Translate the label
translated_label = translate_text(label, st.session_state.target_language)
# Create a container for this object
with st.container():
# Display the object info
st.markdown(f"**{label}** ({confidence:.2f})")
st.markdown(f"โ **{translated_label}**")
# Create columns for audio, example, checkbox
col1, col2, col3 = st.columns([2, 2, 1])
with col1:
# Generate audio for the translated word
audio_bytes = text_to_speech(translated_label, st.session_state.target_language)
if audio_bytes:
st.markdown(get_audio_html(audio_bytes), unsafe_allow_html=True)
# Add pronunciation helpers
pronunciation_tips = get_pronunciation_guide(translated_label, st.session_state.target_language)
if pronunciation_tips:
st.markdown("**Pronunciation Tips:**")
for tip in pronunciation_tips:
st.markdown(f"- {tip}")
with col2:
# Add example sentence directly (no nested expander)
example = get_example_sentence(label, st.session_state.target_language)
st.markdown("**Example:**")
st.markdown(f"EN: {example['english']}")
# Only display translated example if available
if example['translated']:
source = example.get('source', 'unknown')
source_name = source.replace('_', ' ').replace('api', 'API').title()
st.markdown(f"{selected_language}: {example['translated']}")
st.markdown(f"Source: {source_name}", unsafe_allow_html=True)
# Only generate audio if there's text to speak
example_audio = text_to_speech(example['translated'], st.session_state.target_language)
if example_audio:
st.markdown(get_audio_html(example_audio), unsafe_allow_html=True)
else:
st.markdown("*Translation not available. Please install deep-translator package.*")
with col3:
# Default to checked
if checkbox_key not in st.session_state.detection_checkboxes:
st.session_state.detection_checkboxes[checkbox_key] = True
# Add checkbox for this object
st.session_state.detection_checkboxes[checkbox_key] = st.checkbox(
"Save",
value=st.session_state.detection_checkboxes[checkbox_key],
key=checkbox_key
)
st.markdown("---") # Add separator
# Create a stable persistent key for our save button
save_button_id = "save_objects_button_fixed"
# Display save button if objects haven't been saved yet
if not st.session_state.words_just_saved:
# Create a button with a fixed, consistent key
if st.button("๐พ Save Selected Objects to Vocabulary", key=save_button_id):
# Auto-start session if needed
if st.session_state.session_id is None:
if manage_session("start"):
success_message("Created a new learning session!")
else:
error_message("Failed to create a session. Please check database connection.")
st.stop()
# Count selected objects
selected_objects = []
for i in range(len(detections)):
if st.session_state.detection_checkboxes.get(f"detect_{i}", False):
selected_objects.append(i)
if not selected_objects:
warning_message("No objects were selected to save. Please check at least one 'Save' box.")
else:
# Save the selected objects
saved_count = 0
saved_items = []
for i in selected_objects:
try:
detection = detections[i]
label = detection['label']
translated_label = translate_text(label, st.session_state.target_language)
# Save the image
image_path = save_image(image, label)
# Get object category
category = get_object_category(label)
# Add to database using direct method
vocab_id = add_vocabulary_direct(
word_original=label,
word_translated=translated_label,
language_translated=st.session_state.target_language,
category=category,
image_path=image_path
)
if vocab_id:
saved_count += 1
saved_items.append(f"{label} โ {translated_label}")
# Update session stats
st.session_state.words_studied += 1
st.session_state.words_learned += 1
else:
error_message(f"Failed to save {label} to vocabulary.")
except Exception as e:
error_message(f"Error saving {label}: {str(e)}")
if saved_count > 0:
# Store the saved state and items in session state
st.session_state.words_just_saved = True
st.session_state.saved_count = saved_count
st.session_state.saved_items = saved_items
st.rerun() # Rerun once to update the UI
else:
error_message("Failed to save any words. Please check database connection.")
# Show success message and navigation AFTER saving (persists across reruns)
if st.session_state.words_just_saved:
# Create a container for the success message
success_container = st.container()
with success_container:
success_message(f"Successfully added {st.session_state.saved_count} new words to your vocabulary!")
# Show saved words in a visually appealing list
st.markdown('
Words saved:
', unsafe_allow_html=True)
for item in st.session_state.saved_items:
st.markdown(f"โ {item}")
# Show navigation options
st.markdown("### What would you like to do next?")
next_col1, next_col2, next_col3 = st.columns(3)
# Define navigation callback functions
def go_to_quiz_mode():
st.session_state.words_just_saved = False # Reset the saved state
st.session_state.app_mode = "Quiz Mode"
st.session_state.detection_checkboxes = {} # Clear checkboxes
st.rerun()
def go_to_vocabulary():
st.session_state.words_just_saved = False # Reset the saved state
st.session_state.app_mode = "My Vocabulary"
st.session_state.detection_checkboxes = {} # Clear checkboxes
st.rerun()
def continue_capturing():
st.session_state.words_just_saved = False
st.session_state.detection_checkboxes = {} # Clear checkboxes
st.rerun()
# Each button with fixed keys
with next_col1:
if st.button("๐ฎ Go to Quiz Mode", key="quiz_nav_button"):
go_to_quiz_mode()
with next_col2:
if st.button("๐ View My Vocabulary", key="vocab_nav_button"):
go_to_vocabulary()
with next_col3:
if st.button("๐ธ Continue Capturing", key="continue_button"):
continue_capturing()
# Add manual selection UI if enabled
if st.session_state.manual_mode:
st.subheader("Manual Object Selection")
st.write("Enter a label for the object you want to learn.")
# Object label input
st.session_state.manual_label = st.text_input("Object Label:",
value=st.session_state.manual_label,
placeholder="e.g., cup, book, chair")
# Translate the label
if st.session_state.manual_label:
translated_label = translate_text(st.session_state.manual_label,
st.session_state.target_language)
st.write(f"Original: **{st.session_state.manual_label}**")
st.write(f"Translation: **{translated_label}**")
# Generate audio for the translated word
audio_bytes = text_to_speech(translated_label, st.session_state.target_language)
if audio_bytes:
st.markdown(get_audio_html(audio_bytes), unsafe_allow_html=True)
# Save button for manual selection
if st.button("Save to Vocabulary"):
# Auto-start session if needed
if st.session_state.session_id is None:
if manage_session("start"):
success_message("Created a new learning session!")
else:
error_message("Failed to create a session.")
st.stop()
# Save the image
image_path = save_image(image, st.session_state.manual_label)
# Add to database
vocab_id = add_vocabulary_direct(
word_original=st.session_state.manual_label,
word_translated=translated_label,
language_translated=st.session_state.target_language,
category="manual",
image_path=image_path
)
if vocab_id:
success_message(f"Successfully added '{st.session_state.manual_label}' to your vocabulary!")
st.session_state.words_studied += 1
st.session_state.words_learned += 1
# Reset manual mode
st.session_state.manual_mode = False
st.session_state.manual_label = ""
time.sleep(1.5)
st.rerun()
else:
error_message("Failed to save word to vocabulary.")
# Button to exit manual mode
if st.button("Cancel Manual Selection"):
st.session_state.manual_mode = False
st.session_state.manual_label = ""
st.rerun()
# Text OCR mode
# Text OCR mode
else: # Text OCR mode
# Create container for loading spinner
spinner_container = st.container()
with spinner_container:
show_loading_spinner("Detecting text... This may take a few seconds.")
# Add visual separator for mobile
add_result_separator()
with st.spinner("Detecting text..."):
detected_text = detect_text_in_image(image)
# Clear the spinner
spinner_container.empty()
# Add scroll indicator for mobile
add_scroll_indicator()
if detected_text:
style_section_title("๐ Detected Text")
st.write(detected_text)
# Split into words for learning
words = [word.strip() for word in re.split(r'[^\w]', detected_text) if word.strip()]
if words:
st.subheader("Words to Learn")
# Create containers for each word
for i, word in enumerate(words):
if len(word) <= 2: # Skip very short words
continue
# Translate the word
translated_word = translate_text(word, st.session_state.target_language)
# Display in a container
with st.container():
cols = st.columns([3, 1])
with cols[0]:
st.write(f"**{word}** โ {translated_word}")
# Add audio
audio_bytes = text_to_speech(translated_word, st.session_state.target_language)
if audio_bytes:
st.markdown(get_audio_html(audio_bytes), unsafe_allow_html=True)
with cols[1]:
# Add save button for each word
if st.button(f"Save", key=f"save_text_{i}"):
# Auto-start session if needed
if st.session_state.session_id is None:
manage_session("start")
# Save to vocabulary
vocab_id = add_vocabulary_direct(
word_original=word,
word_translated=translated_word,
language_translated=st.session_state.target_language,
category="text",
image_path=None
)
if vocab_id:
success_message(f"Added '{word}' to vocabulary!")
st.session_state.words_studied += 1
st.session_state.words_learned += 1
else:
error_message(f"Failed to save '{word}'")
st.markdown("---")
else:
info_message("No clear words detected in the image.")
else:
info_message("No text detected. Try another image or adjust image clarity.")
elif app_mode == "My Vocabulary":
style_title("๐ My Vocabulary")
st.markdown("Review all the words you've learned so far.")
# Get vocabulary from database
vocabulary = get_all_vocabulary_direct()
# Filter options
col1, col2 = st.columns(2)
with col1:
filter_language = st.selectbox(
"Filter by language:",
["All"] + list(languages.keys()),
index=0
)
with col2:
sort_by = st.selectbox(
"Sort by:",
["Date added (newest first)", "Date added (oldest first)", "Proficiency (low to high)", "Proficiency (high to low)"]
)
# Apply filters
filtered_vocab = []
for word in vocabulary:
# Skip any None entries or entries without required fields
if word is None or 'language_translated' not in word:
continue
if filter_language == "All" or languages.get(filter_language) == word['language_translated']:
# Make sure proficiency_level exists
if 'proficiency_level' not in word or word['proficiency_level'] is None:
word['proficiency_level'] = 0
filtered_vocab.append(word)
# Sort vocabulary
if filtered_vocab:
if sort_by == "Date added (newest first)":
filtered_vocab.sort(key=lambda x: x.get('date_added', ''), reverse=True)
elif sort_by == "Date added (oldest first)":
filtered_vocab.sort(key=lambda x: x.get('date_added', ''))
elif sort_by == "Proficiency (low to high)":
filtered_vocab.sort(key=lambda x: x.get('proficiency_level', 0))
elif sort_by == "Proficiency (high to low)":
filtered_vocab.sort(key=lambda x: x.get('proficiency_level', 0), reverse=True)
# Display vocabulary
if filtered_vocab:
st.markdown(f"**Found {len(filtered_vocab)} words in your vocabulary collection.**")
# Create data for table view
table_data = []
for word in filtered_vocab:
# Skip entries without required fields
if not all(k in word for k in ['word_original', 'word_translated', 'language_translated']):
continue
# Get language name from code
lang_code = word.get('language_translated', '')
lang_name = next((k for k, v in languages.items() if v == lang_code), lang_code)
# Format proficiency level
proficiency = word.get('proficiency_level', 0) or 0
proficiency_display = "โญ" * proficiency
# Format date
date_added = word.get('date_added', '')
if date_added and isinstance(date_added, str):
date_display = date_added.split()[0] if ' ' in date_added else date_added
else:
date_display = "Unknown"
table_data.append({
"Original": word.get('word_original', ''),
"Translation": word.get('word_translated', ''),
"Language": lang_name,
"Proficiency": proficiency_display,
"Date Added": date_display
})
# Display as a dataframe
if table_data:
st.dataframe(pd.DataFrame(table_data))
# Detailed view
st.subheader("Word Details")
selected_word_index = st.selectbox(
"Select a word to review:",
range(len(filtered_vocab)),
format_func=lambda i: f"{filtered_vocab[i].get('word_original', '')} โ {filtered_vocab[i].get('word_translated', '')}"
)
word = filtered_vocab[selected_word_index]
# Display word details
col1, col2 = st.columns([2, 3])
with col1:
st.markdown(f"**Original:** {word.get('word_original', '')}")
st.markdown(f"**Translation:** {word.get('word_translated', '')}")
# Language name from code
lang_code = word.get('language_translated', '')
lang_name = next((k for k, v in languages.items() if v == lang_code), lang_code)
st.markdown(f"**Language:** {lang_name}")
if word.get('category'):
st.markdown(f"**Category:** {word.get('category', '')}")
# Generate pronunciation audio
st.markdown("**Listen to pronunciation:**")
audio_bytes = text_to_speech(word.get('word_translated', ''), word.get('language_translated', ''))
if audio_bytes:
st.markdown(get_audio_html(audio_bytes), unsafe_allow_html=True)
# Show proficiency if available
proficiency = word.get('proficiency_level', 0) or 0
st.markdown("**Learning progress:**")
st.progress(proficiency / 5)
review_count = word.get('review_count', 0) or 0
st.markdown(f"Proficiency: {proficiency}/5 (based on {review_count} reviews)")
# Add pronunciation helpers
pronunciation_tips = get_pronunciation_guide(word.get('word_translated', ''), word.get('language_translated', ''))
if pronunciation_tips:
st.markdown("**Pronunciation tips:**")
for tip in pronunciation_tips:
st.markdown(f"- {tip}")
with col2:
# Display image if available
image_path = word.get('image_path', '')
if image_path and os.path.exists(image_path):
try:
image = Image.open(image_path)
st.image(image, caption=f"Image for {word.get('word_original', '')}")
except Exception as e:
error_message(f"Error loading image: {e}")
else:
st.markdown("*No image available for this word*")
# Add pronunciation practice if available
if has_pronunciation_practice:
try:
# Only initialize if not already initialized
if 'pronunciation_practice' not in st.session_state:
# Initialize the enhanced pronunciation practice module
st.session_state.pronunciation_practice = create_pronunciation_practice(
text_to_speech_func=text_to_speech,
get_audio_html_func=get_audio_html,
translate_text_func=translate_text,
get_example_sentence_func=get_example_sentence
)
print("โ Enhanced pronunciation practice initialized with AI feedback")
# Add pronunciation practice capabilities to session state
st.session_state.pronunciation_capabilities = {
'realtime_feedback': True,
'ai_analysis': True,
'visual_feedback': True,
'progress_tracking': True
}
# Check for custom recorder availability
try:
from custom_audio_recorder import audio_recorder
st.session_state.pronunciation_practice.has_custom_recorder = True
print("โ Custom audio recorder available")
except ImportError:
st.session_state.pronunciation_practice.has_custom_recorder = False
print("โน๏ธ Using fallback recording methods")
# Handle saving pronunciation words to vocabulary
if 'save_pronunciation_word' in st.session_state:
word_data = st.session_state.save_pronunciation_word
# Auto-start session if needed
if st.session_state.session_id is None:
if manage_session("start"):
success_message("Created a new learning session!")
# Add to vocabulary
vocab_id = add_vocabulary_direct(
word_original=word_data['original'],
word_translated=word_data['translated'],
language_translated=word_data['language'],
category="pronunciation_practice",
image_path=None
)
if vocab_id:
# Update session stats IMMEDIATELY
st.session_state.words_studied += 1
if word_data.get('score', 0) >= 70: # Consider "learned" if good score
st.session_state.words_learned += 1
# Show success message
success_message(f"โ '{word_data['original']}' saved to vocabulary! Score: {word_data.get('score', 0):.0f}%")
# Update database session stats immediately
if st.session_state.session_id:
try:
conn = sqlite3.connect("language_learning.db")
cursor = conn.cursor()
cursor.execute(
"UPDATE sessions SET words_studied = ?, words_learned = ? WHERE id = ?",
(st.session_state.words_studied, st.session_state.words_learned, st.session_state.session_id)
)
conn.commit()
conn.close()
except Exception as e:
print(f"Error updating session: {e}")
# Check achievements
try:
gamification.check_achievements(
"pronunciation_practice",
word=word_data['original'],
score=word_data['score']
)
except Exception as e:
print(f"Gamification error: {e}")
# Clear the save request
del st.session_state.save_pronunciation_word
# Force UI update
st.rerun()
# Debug information (you can remove this later)
if st.checkbox("๐ง Show Debug Info", key="debug_pronunciation"):
st.write("**Session State Debug:**")
st.write(f"Session ID: {st.session_state.session_id}")
st.write(f"Words Studied: {st.session_state.words_studied}")
st.write(f"Words Learned: {st.session_state.words_learned}")
st.write(f"Has audio_data: {'audio_data' in st.session_state and st.session_state.audio_data is not None}")
st.write(f"Audio received: {st.session_state.get('audio_data_received', False)}")
if 'last_pronunciation_results' in st.session_state:
st.write("**Last Results:**")
st.write(st.session_state.last_pronunciation_results)
except Exception as e:
print(f"โ Error initializing pronunciation practice: {str(e)}")
has_pronunciation_practice = False
# Add example sentence directly (no expander)
example = get_example_sentence(word.get('word_original', ''), word.get('language_translated', ''))
st.markdown(f"**Example in context:**")
st.markdown(f"**English:** {example['english']}")
if example['translated']:
source = example.get('source', 'unknown')
source_name = source.replace('_', ' ').replace('api', 'API').title()
st.markdown(f"**{lang_name}:** {example['translated']}")
st.markdown(f"Source: {source_name}", unsafe_allow_html=True)
# Only generate audio if there's text to speak
example_audio = text_to_speech(example['translated'], word.get('language_translated', ''))
if example_audio:
st.markdown(get_audio_html(example_audio), unsafe_allow_html=True)
else:
warning_message("There was an issue with the vocabulary data format.")
else:
info_message("No vocabulary words found with current filter. Go to Camera Mode to start learning new words!")
elif app_mode == "Quiz Mode":
style_title("๐ฎ Quiz Mode")
st.markdown("Test your vocabulary knowledge with interactive quizzes.")
# Import the quiz system if not already imported
if 'quiz_system' not in st.session_state:
try:
# Import quiz system
from quiz_system import QuizSystem
# Create a dictionary of database functions
db_functions = {
'get_all_vocabulary_direct': get_all_vocabulary_direct,
'update_word_progress_direct': update_word_progress_direct
}
# Initialize the quiz system
quiz_system = QuizSystem(
db_functions=db_functions,
text_to_speech=text_to_speech,
get_audio_html=get_audio_html,
get_example_sentence=get_example_sentence,
get_pronunciation_guide=get_pronunciation_guide
)
# Store in session state
st.session_state.quiz_system = quiz_system
# Add gamification to session state for access by quiz system
st.session_state.gamification = gamification
except ImportError as e:
error_message(f"Error loading quiz system: {e}")
info_message("Please make sure quiz_system.py is in the same directory as main.py")
st.stop()
# Get the quiz system from session state
quiz_system = st.session_state.quiz_system
# Get vocabulary from database
vocabulary = get_all_vocabulary_direct()
# Quiz settings tab and quiz display tab
if 'quiz_completed' not in st.session_state:
st.session_state.quiz_completed = False
if st.session_state.current_quiz_word and st.session_state.quiz_options:
# Quiz is already in progress, display it
quiz_system.display_quiz_question(languages, manage_session)
# Display current score in sidebar
st.sidebar.markdown(f"### Current Score: {st.session_state.quiz_score}/{st.session_state.quiz_total}")
if st.session_state.quiz_total > 0:
accuracy = (st.session_state.quiz_score / st.session_state.quiz_total) * 100
st.sidebar.markdown(f"**Accuracy:** {accuracy:.1f}%")
# Display quiz results if quiz is completed
elif st.session_state.quiz_completed and st.session_state.quiz_total > 0:
quiz_system.display_quiz_results()
# Display quiz setup
else:
# Introduction
st.markdown("""
Choose your quiz settings below to test your vocabulary knowledge.
The quiz will randomly include different types of questions:
- ๐ Translation (both directions)
- ๐ผ๏ธ Image recognition
- ๐ Sentence completion
- ๐ฏ Category matching
- ๐ Related words identification
- ๐ Audio recognition
Start with a small number of questions and work your way up!
""")
# Quiz settings in columns
col1, col2, col3 = st.columns(3)
with col1:
quiz_language = st.selectbox(
"Quiz language:",
list(languages.keys()),
index=list(languages.values()).index(st.session_state.target_language) if st.session_state.target_language in languages.values() else 0
)
quiz_lang_code = languages[quiz_language]
with col2:
num_questions = st.number_input("Number of questions:", min_value=1, max_value=20, value=5)
with col3:
# Get all categories from vocabulary
categories = set()
for word in vocabulary:
if word and 'category' in word and word['category'] and word['category'] not in ['other', 'manual']:
categories.add(word['category'])
if categories:
category_filter = st.selectbox(
"Category filter (optional):",
["All Categories"] + sorted(list(categories))
)
else:
category_filter = "All Categories"
# Filter vocabulary by selected language
filtered_vocab = [word for word in vocabulary if word['language_translated'] == quiz_lang_code]
# Further filter by category if selected
if category_filter != "All Categories":
filtered_vocab = [word for word in filtered_vocab if word.get('category') == category_filter]
filtered_vocab = prepare_vocabulary_for_diverse_questions(filtered_vocab, languages)
# Display information about available words
if filtered_vocab:
st.markdown(f"**{len(filtered_vocab)} words available** for your quiz in {quiz_language}" +
(f" ({category_filter} category)" if category_filter != "All Categories" else ""))
# Count words with images
words_with_images = sum(1 for word in filtered_vocab
if word.get('image_path') and os.path.exists(word.get('image_path', '')))
# Show details on available question types
st.markdown(f"*{words_with_images} words have images for image recognition questions*")
# Start quiz button with dynamic label
start_label = "Start Quiz" if len(filtered_vocab) >= 4 else f"Need {4-len(filtered_vocab)} More Word(s)"
if st.button(start_label, disabled=len(filtered_vocab) < 4):
if quiz_system.start_new_quiz(filtered_vocab, languages, num_questions, manage_session):
st.rerun()
# Show word preview
if st.checkbox("Preview Available Words"):
# Create a simple table of words
preview_data = []
for word in filtered_vocab[:20]: # Limit preview to 20 words
preview_data.append({
"Original": word.get('word_original', ''),
"Translation": word.get('word_translated', ''),
"Category": word.get('category', '')
})
st.dataframe(pd.DataFrame(preview_data))
if len(filtered_vocab) > 20:
st.markdown(f"*...and {len(filtered_vocab) - 20} more words*")
else:
warning_message(f"No vocabulary words found with current filter. Go to Camera Mode to add words in {quiz_language}" +
(f" for the {category_filter} category" if category_filter != "All Categories" else "") + ".")
# Show a specific message for empty vocabulary
if not vocabulary:
info_message("Start by learning some words in Camera Mode to build your vocabulary!")
elif not any(word['language_translated'] == quiz_lang_code for word in vocabulary):
info_message(f"You don't have any words in {quiz_language} yet. Try selecting a different language or add some new words.")
else:
info_message(f"No words found in the {category_filter} category. Try selecting 'All Categories' or add words in this category.")
elif app_mode == "Statistics":
style_title("๐ Learning Statistics")
st.markdown("Track your progress and learning habits.")
# Get session stats for the last 30 days
stats = get_session_stats_direct(30)
# Debug display for stats
if st.checkbox("Show raw stats data"):
st.write("Raw stats data from database:")
st.write(stats)
# Check if stats exist and have total_sessions
if stats and stats.get('total_sessions'):
# Display overall statistics
st.subheader("Overall Statistics (Last 30 Days)")
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Total Sessions", stats.get('total_sessions', 0) or 0)
with col2:
st.metric("Words Studied", stats.get('total_words_studied', 0) or 0)
with col3:
st.metric("Words Learned", stats.get('total_words_learned', 0) or 0)
# Learning efficiency
st.subheader("Learning Efficiency")
col1, col2 = st.columns(2)
with col1:
avg_words = stats.get('avg_words_per_session', 0) or 0
st.metric("Avg Words per Session", f"{avg_words:.1f}")
with col2:
avg_time = stats.get('avg_session_minutes', 0) or 0
st.metric("Avg Session Length", f"{avg_time:.1f} min")
# Vocabulary distribution by language
st.subheader("Vocabulary by Language")
# Get all vocabulary items
vocabulary = get_all_vocabulary_direct()
# Count words per language
language_counts = {}
for word in vocabulary:
if word is None or 'language_translated' not in word:
continue
lang = word['language_translated']
if lang in language_counts:
language_counts[lang] += 1
else:
language_counts[lang] = 1
# Convert language codes to names
language_names = {}
for name, code in languages.items():
if code in language_counts:
language_names[name] = language_counts[code]
# Create chart data
if language_names:
chart_data = pd.DataFrame({
'Language': list(language_names.keys()),
'Word Count': list(language_names.values())
})
# Plot bar chart
fig, ax = plt.subplots(figsize=(10, 6))
bars = ax.bar(chart_data['Language'], chart_data['Word Count'], color='skyblue')
# Add count labels on top of bars
for bar in bars:
height = bar.get_height()
ax.text(bar.get_x() + bar.get_width()/2., height + 0.1,
f'{int(height)}', ha='center', va='bottom')
ax.set_xlabel('Language')
ax.set_ylabel('Number of Words')
ax.set_title('Vocabulary Distribution by Language')
plt.xticks(rotation=45)
plt.tight_layout()
st.pyplot(fig)
# Get proficiency distribution
st.subheader("Proficiency Level Distribution")
proficiency_counts = {0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0}
for word in vocabulary:
if word is None:
continue
level = word.get('proficiency_level', 0) or 0
proficiency_counts[level] += 1
# Create proficiency chart
prof_data = pd.DataFrame({
'Level': [f"Level {lvl}" for lvl in proficiency_counts.keys()],
'Words': list(proficiency_counts.values())
})
if sum(proficiency_counts.values()) > 0:
fig, ax = plt.subplots(figsize=(10, 6))
colors = ['#FFCCCC', '#FFE5CC', '#FFFFCC', '#E5FFCC', '#CCFFCC', '#CCFFEF']
bars = ax.bar(prof_data['Level'], prof_data['Words'], color=colors)
# Add count labels
for bar in bars:
height = bar.get_height()
if height > 0:
ax.text(bar.get_x() + bar.get_width()/2., height + 0.1,
f'{int(height)}', ha='center', va='bottom')
ax.set_xlabel('Proficiency Level')
ax.set_ylabel('Number of Words')
ax.set_title('Word Distribution by Proficiency Level')
plt.tight_layout()
st.pyplot(fig)
# Add explanation of proficiency levels
st.markdown("""
**Proficiency Level Guide:**
- **Level 0**: New words or words answered incorrectly multiple times
- **Level 1**: Basic recognition (20% correct answers)
- **Level 2**: Beginning to remember (40% correct answers)
- **Level 3**: Moderate proficiency (60% correct answers)
- **Level 4**: Good proficiency (80% correct answers)
- **Level 5**: Mastered (90-100% correct answers)
""")
# Learning suggestions section
st.subheader("Learning Suggestions")
st.markdown("""
Based on your learning patterns, here are some suggestions:
1. **Words to Review**: Focus on lower proficiency words
2. **Optimal Session Length**: Aim for 10-15 minute learning sessions
3. **Learning Frequency**: Try to complete at least one session per day
""")
else:
info_message("No learning statistics available yet. Complete some learning sessions to see your progress!")
if st.button("Generate Sample Statistics (Demo)"):
# Create sample data for demonstration
st.subheader("Sample Statistics (Demo)")
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Total Sessions", 5)
with col2:
st.metric("Words Studied", 42)
with col3:
st.metric("Words Learned", 38)
# Sample chart
sample_data = pd.DataFrame({
'Language': ['Spanish', 'French', 'German', 'Italian'],
'Word Count': [15, 12, 8, 7]
})
fig, ax = plt.subplots(figsize=(10, 6))
ax.bar(sample_data['Language'], sample_data['Word Count'], color='lightgray')
ax.set_xlabel('Language')
ax.set_ylabel('Number of Words (Sample Data)')
ax.set_title('Example: Vocabulary Distribution by Language')
plt.tight_layout()
st.pyplot(fig)
st.markdown("*This is sample data. Start learning with Camera Mode to begin tracking your real progress!*")
elif app_mode == "My Progress":
try:
gamification.render_dashboard()
except Exception as e:
error_message("There was an error displaying the Progress. The system might be initializing.")
info_message("Please try again in a moment or add some vocabulary first to initialize the system.")
print(f"Dashboard error: {e}")
elif app_mode == "Pronunciation Practice":
style_title("๐ค AI-Powered Pronunciation Practice")
st.markdown("Practice your pronunciation with real-time AI feedback and comprehensive analysis.")
# Session management
col1, col2 = st.columns(2)
with col1:
if st.session_state.session_id is None:
if st.button("Start Learning Session", key="start_pron_session"):
if manage_session("start"):
st.rerun()
else:
info_message(f"Session in progress - Words studied: {st.session_state.words_studied}")
with col2:
if st.session_state.session_id is not None:
if st.button("End Session", key="end_pron_session"):
if manage_session("end"):
st.rerun()
if has_pronunciation_practice:
try:
# Initialize pronunciation practice if not already initialized
if 'pronunciation_practice' not in st.session_state:
# Initialize the enhanced pronunciation practice module
st.session_state.pronunciation_practice = create_pronunciation_practice(
text_to_speech_func=text_to_speech,
get_audio_html_func=get_audio_html,
translate_text_func=translate_text,
get_example_sentence_func=get_example_sentence
)
print("โ Enhanced pronunciation practice initialized with AI feedback")
# Add pronunciation practice capabilities to session state
st.session_state.pronunciation_capabilities = {
'realtime_feedback': True,
'ai_analysis': True,
'visual_feedback': True,
'progress_tracking': True
}
# Check for custom recorder availability
try:
from custom_audio_recorder import audio_recorder
st.session_state.pronunciation_practice.has_custom_recorder = True
print("โ Custom audio recorder available")
except ImportError:
st.session_state.pronunciation_practice.has_custom_recorder = False
print("โน๏ธ Using fallback recording methods")
# Enhanced pronunciation practice interface
st.markdown("""
### ๐ฏ Features Available:
- **Real-time feedback** during recording
- **AI-powered analysis** of your pronunciation
- **Visual spectrograms** showing sound patterns
- **Progress tracking** across practice sessions
- **Language-specific tips** for difficult sounds
""")
# Get vocabulary from database
vocabulary = get_all_vocabulary_direct()
# Language selection
practice_language = st.selectbox(
"Select practice language:",
list(languages.keys()),
index=list(languages.values()).index(st.session_state.target_language)
if st.session_state.target_language in languages.values() else 0,
key="pron_lang_select"
)
practice_language_code = languages[practice_language]
# Filter vocabulary for the selected language
filtered_vocab = [word for word in vocabulary if word['language_translated'] == practice_language_code]
if filtered_vocab:
# Practice mode selection
practice_mode = st.radio(
"Choose practice mode:",
[
"๐ Individual Word Practice",
"๐ฏ Focused Practice Session",
"๐ Challenge Mode"
],
key="practice_mode_select"
)
if practice_mode == "๐ Individual Word Practice":
# Individual word practice
word_index = st.selectbox(
"Select a word to practice:",
range(len(filtered_vocab)),
format_func=lambda i: f"{filtered_vocab[i].get('word_translated', '')} ({filtered_vocab[i].get('word_original', '')})",
key="word_select"
)
selected_word = filtered_vocab[word_index]
st.session_state.pronunciation_practice.render_practice_ui(selected_word)
elif practice_mode == "๐ฏ Focused Practice Session":
# Focused session mode
if 'practice_session_words' not in st.session_state:
session_size = st.slider("Number of words to practice:", 3, 10, 5)
if st.button("๐ Start Focused Session", type="primary"):
import random
st.session_state.practice_session_words = random.sample(
filtered_vocab, min(session_size, len(filtered_vocab))
)
st.session_state.current_session_index = 0
st.session_state.session_scores = []
st.rerun()
else:
# Session in progress
current_index = st.session_state.current_session_index
total_words = len(st.session_state.practice_session_words)
# Progress display
progress = current_index / total_words
st.progress(progress)
st.markdown(f"**Word {current_index + 1} of {total_words}**")
if current_index < total_words:
current_word = st.session_state.practice_session_words[current_index]
st.session_state.pronunciation_practice.render_practice_ui(current_word)
# Session navigation
col1, col2, col3 = st.columns(3)
with col1:
if current_index > 0:
if st.button("โฌ ๏ธ Previous Word"):
st.session_state.current_session_index -= 1
st.rerun()
with col2:
if st.button("โญ๏ธ Skip Word"):
st.session_state.current_session_index += 1
st.rerun()
with col3:
if current_index < total_words - 1:
if st.button("โก๏ธ Next Word"):
st.session_state.current_session_index += 1
st.rerun()
else:
# Session completed
st.success("๐ Practice session completed!")
# Show session results
if 'session_scores' in st.session_state and st.session_state.session_scores:
avg_score = sum(st.session_state.session_scores) / len(st.session_state.session_scores)
st.metric("Average Score", f"{avg_score:.0f}%")
# Progress chart
fig, ax = plt.subplots(figsize=(8, 4))
ax.plot(range(1, len(st.session_state.session_scores) + 1),
st.session_state.session_scores,
marker='o', linestyle='-')
ax.set_xlabel('Word Number')
ax.set_ylabel('Score (%)')
ax.set_title('Session Progress')
ax.grid(True, alpha=0.3)
st.pyplot(fig)
# Reset session
if st.button("๐ Start New Session"):
for key in ['practice_session_words', 'current_session_index', 'session_scores']:
if key in st.session_state:
del st.session_state[key]
st.rerun()
elif practice_mode == "๐ Challenge Mode":
# Challenge mode - rapid pronunciation assessment
st.markdown("### ๐ Pronunciation Challenge")
st.markdown("Quick-fire pronunciation assessment - get scored on speed and accuracy!")
if 'challenge_mode' not in st.session_state:
difficulty = st.selectbox(
"Select difficulty:",
["๐ข Easy (3 words)", "๐ก Medium (5 words)", "๐ด Hard (8 words)"]
)
word_count = {"๐ข Easy (3 words)": 3, "๐ก Medium (5 words)": 5, "๐ด Hard (8 words)": 8}[difficulty]
if st.button("๐ Start Challenge!", type="primary"):
import random
st.session_state.challenge_words = random.sample(
filtered_vocab, min(word_count, len(filtered_vocab))
)
st.session_state.challenge_index = 0
st.session_state.challenge_scores = []
st.session_state.challenge_start_time = time.time()
st.session_state.challenge_mode = True
st.rerun()
else:
# Challenge in progress
current_index = st.session_state.challenge_index
total_words = len(st.session_state.challenge_words)
if current_index < total_words:
# Timer display
elapsed_time = time.time() - st.session_state.challenge_start_time
col1, col2 = st.columns(2)
with col1:
st.metric("Time Elapsed", f"{elapsed_time:.1f}s")
with col2:
st.metric("Words Remaining", total_words - current_index)
# Current word practice
current_word = st.session_state.challenge_words[current_index]
st.markdown(f"### Challenge Word: {current_word.get('word_translated', '')}")
# Quick practice interface
st.session_state.pronunciation_practice.render_practice_ui(current_word)
else:
# Challenge completed
total_time = time.time() - st.session_state.challenge_start_time
st.success(f"๐ Challenge completed in {total_time:.1f} seconds!")
# Challenge results
if st.session_state.challenge_scores:
avg_score = sum(st.session_state.challenge_scores) / len(st.session_state.challenge_scores)
speed_bonus = max(0, 100 - total_time) # Bonus for speed
final_score = (avg_score * 0.8) + (speed_bonus * 0.2)
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Average Accuracy", f"{avg_score:.0f}%")
with col2:
st.metric("Speed Bonus", f"{speed_bonus:.0f}")
with col3:
st.metric("Final Score", f"{final_score:.0f}%")
# Achievement badges
if final_score >= 90:
st.markdown("๐ **PRONUNCIATION MASTER!**")
elif final_score >= 80:
st.markdown("๐ฅ **EXCELLENT PERFORMANCE!**")
elif final_score >= 70:
st.markdown("๐ฅ **GREAT JOB!**")
else:
st.markdown("๐ฅ **KEEP PRACTICING!**")
# Reset challenge
if st.button("๐ New Challenge"):
for key in ['challenge_words', 'challenge_index', 'challenge_scores',
'challenge_start_time', 'challenge_mode']:
if key in st.session_state:
del st.session_state[key]
st.rerun()
else:
warning_message(f"No vocabulary words found for {practice_language}. Go to Camera Mode to add words first.")
except Exception as e:
error_message(f"Error in pronunciation practice: {str(e)}")
st.info("Try refreshing the page or check the pronunciation practice module.")
else:
# Show what's available vs what's missing
st.warning("๐ค Some pronunciation features require additional packages.")
# Basic pronunciation practice without advanced features
st.markdown("### ๐ฏ Basic Pronunciation Practice")
st.markdown("You can still practice pronunciation with the available features:")
# Get vocabulary
vocabulary = get_all_vocabulary_direct()
practice_language = st.selectbox(
"Select practice language:",
list(languages.keys()),
index=list(languages.values()).index(st.session_state.target_language)
if st.session_state.target_language in languages.values() else 0,
key="basic_pron_lang_select"
)
practice_language_code = languages[practice_language]
# Filter vocabulary
filtered_vocab = [word for word in vocabulary if word['language_translated'] == practice_language_code]
if filtered_vocab:
word_index = st.selectbox(
"Select a word to practice:",
range(len(filtered_vocab)),
format_func=lambda i: f"{filtered_vocab[i].get('word_translated', '')} ({filtered_vocab[i].get('word_original', '')})",
key="basic_word_select"
)
selected_word = filtered_vocab[word_index]
word_translated = selected_word.get('word_translated', '')
st.markdown(f"### Practice: {word_translated}")
# Play pronunciation
st.markdown("**๐ Listen and repeat:**")
audio_bytes = text_to_speech(word_translated, practice_language_code)
if audio_bytes:
st.markdown(get_audio_html(audio_bytes), unsafe_allow_html=True)
# Show pronunciation tips
pronunciation_tips = get_pronunciation_guide(word_translated, practice_language_code)
if pronunciation_tips:
st.markdown("**๐ก Pronunciation Tips:**")
for tip in pronunciation_tips:
st.markdown(f"- {tip}")
# File upload for basic feedback
st.markdown("**๐ Upload your recording for basic analysis:**")
uploaded_audio = st.file_uploader(
"Record yourself saying the word and upload the audio file",
type=["wav", "mp3", "ogg", "m4a"],
key="basic_audio_upload"
)
if uploaded_audio:
# Basic analysis without advanced features
st.audio(uploaded_audio)
# Simple feedback
st.markdown("### ๐ Basic Feedback")
st.success("โ Audio received! Keep practicing by:")
st.markdown("- ๐ Comparing your pronunciation with the correct audio")
st.markdown("- ๐ Focusing on the pronunciation tips above")
st.markdown("- ๐ฏ Recording multiple attempts to improve")
# Save to vocabulary option
if st.button("๐พ Save to Vocabulary", key="basic_save_vocab"):
if st.session_state.session_id is None:
manage_session("start")
vocab_id = add_vocabulary_direct(
word_original=selected_word.get('word_original', ''),
word_translated=word_translated,
language_translated=practice_language_code,
category="pronunciation_practice",
image_path=None
)
if vocab_id:
st.success("โ Word saved to vocabulary!")
st.session_state.words_studied += 1
st.session_state.words_learned += 1
else:
warning_message(f"No vocabulary words found for {practice_language}. Go to Camera Mode to add words first.")
# Installation guide
st.markdown("### ๐ ๏ธ For Advanced AI Feedback")
st.markdown("Install these packages for real-time AI pronunciation analysis:")
st.code("pip install streamlit-webrtc speech-recognition librosa python-Levenshtein av")
st.sidebar.markdown("---")
st.sidebar.markdown("### Session Info")
if st.session_state.session_id:
st.sidebar.success(f"Session active")
st.sidebar.info(f"Words studied: {st.session_state.words_studied}")
st.sidebar.info(f"Words learned: {st.session_state.words_learned}")
else:
st.sidebar.warning("No active session")
st.sidebar.markdown("*Start a session in Camera Mode to track progress*")
add_footer()