Spaces:
Sleeping
Sleeping
| import streamlit as st | |
| import json | |
| import os | |
| import uuid | |
| from datetime import datetime | |
| from PIL import Image | |
| import base64 | |
| from io import BytesIO | |
| import streamlit.components.v1 as components | |
| from translations import get_translation, SUPPORTED_LANGUAGES | |
| from utils import load_users, save_users, load_labels, save_labels, validate_image, get_categories, calculate_statistics | |
| # Page configuration | |
| st.set_page_config( | |
| page_title="LabelIt! 🇮🇳", | |
| page_icon="🏷️", | |
| layout="wide", | |
| initial_sidebar_state="expanded" | |
| ) | |
| # Initialize session state | |
| if 'user' not in st.session_state: | |
| st.session_state.user = None | |
| if 'language' not in st.session_state: | |
| st.session_state.language = 'en' | |
| if 'location_fetched' not in st.session_state: | |
| st.session_state.location_fetched = False | |
| if 'user_location' not in st.session_state: | |
| st.session_state.user_location = {"lat": None, "lon": None, "accuracy": None, "method": None, "timestamp": None} | |
| if 'manual_location_mode' not in st.session_state: | |
| st.session_state.manual_location_mode = False | |
| # Check for existing data structure (for Hugging Face Spaces compatibility) | |
| DATA_DIR = 'data' | |
| IMAGES_DIR = os.path.join(DATA_DIR, 'images') | |
| USERS_FILE = os.path.join(DATA_DIR, 'users.json') | |
| LABELS_FILE = os.path.join(DATA_DIR, 'labels.json') | |
| # Only create directories if they don't exist and we have permissions | |
| if not os.path.exists(DATA_DIR): | |
| try: | |
| os.makedirs(DATA_DIR, exist_ok=True) | |
| except (OSError, PermissionError): | |
| st.error("Data directory not found. Please ensure 'data' folder exists in the workspace.") | |
| if not os.path.exists(IMAGES_DIR): | |
| try: | |
| os.makedirs(IMAGES_DIR, exist_ok=True) | |
| except (OSError, PermissionError): | |
| st.error("Images directory not found. Please ensure 'data/images' folder exists in the workspace.") | |
| # Initialize data files only if they don't exist | |
| if os.path.exists(DATA_DIR) and not os.path.exists(USERS_FILE): | |
| try: | |
| with open(USERS_FILE, 'w') as f: | |
| json.dump({}, f) | |
| except (OSError, PermissionError): | |
| pass | |
| if os.path.exists(DATA_DIR) and not os.path.exists(LABELS_FILE): | |
| try: | |
| with open(LABELS_FILE, 'w') as f: | |
| json.dump({}, f) | |
| except (OSError, PermissionError): | |
| pass | |
| def get_enhanced_location(): | |
| """Enhanced location capture with multiple fallback methods and accuracy indicators""" | |
| if not st.session_state.location_fetched and not st.session_state.manual_location_mode: | |
| st.markdown("### 📍 Location Capture for Image Upload") | |
| # Show importance message | |
| st.info("📍 **Location Required**: Each image upload needs GPS coordinates for better dataset quality and regional insights.") | |
| col1, col2 = st.columns([2, 1]) | |
| with col1: | |
| # Enhanced JavaScript location component with multiple fallback methods | |
| location_data = components.html( | |
| """ | |
| <script> | |
| let locationAttempts = 0; | |
| const maxAttempts = 3; | |
| function tryGetLocation() { | |
| locationAttempts++; | |
| document.getElementById("status").innerHTML = `🔄 Attempting high-accuracy GPS location (${locationAttempts}/${maxAttempts})...`; | |
| if (navigator.geolocation) { | |
| const options = { | |
| enableHighAccuracy: true, | |
| timeout: 20000, | |
| maximumAge: 30000 | |
| }; | |
| navigator.geolocation.getCurrentPosition( | |
| function(position) { | |
| const lat = position.coords.latitude; | |
| const lon = position.coords.longitude; | |
| const accuracy = position.coords.accuracy; | |
| const altitude = position.coords.altitude; | |
| const heading = position.coords.heading; | |
| const speed = position.coords.speed; | |
| const timestamp = new Date().toISOString(); | |
| let accuracyLevel = "Low"; | |
| let accuracyColor = "#e74c3c"; | |
| let accuracyEmoji = "🟡"; | |
| if (accuracy <= 10) { | |
| accuracyLevel = "High"; | |
| accuracyColor = "#27ae60"; | |
| accuracyEmoji = "🟢"; | |
| } else if (accuracy <= 50) { | |
| accuracyLevel = "Medium"; | |
| accuracyColor = "#f39c12"; | |
| accuracyEmoji = "🟠"; | |
| } else { | |
| accuracyEmoji = "🔴"; | |
| } | |
| document.getElementById("status").innerHTML = ` | |
| <div style="background: linear-gradient(45deg, #27ae60, #2ecc71); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; box-shadow: 0 4px 15px rgba(39, 174, 96, 0.3);"> | |
| <div style="font-weight: bold; margin-bottom: 8px;">✅ GPS Location Captured Successfully!</div> | |
| <div style="font-size: 0.95em; margin-bottom: 5px;">📍 <strong>${lat.toFixed(6)}, ${lon.toFixed(6)}</strong></div> | |
| <div style="font-size: 0.85em; margin-bottom: 5px;"> | |
| ${accuracyEmoji} Accuracy: <span style="color: ${accuracyColor}; font-weight: bold;">${accuracyLevel}</span> (±${accuracy.toFixed(0)}m) | |
| </div> | |
| <div style="font-size: 0.8em; opacity: 0.9;">⏰ ${new Date(timestamp).toLocaleString()}</div> | |
| ${altitude ? `<div style="font-size: 0.8em; opacity: 0.9;">⛰️ Altitude: ${altitude.toFixed(0)}m</div>` : ''} | |
| </div> | |
| `; | |
| window.parent.postMessage({ | |
| type: 'streamlit:setComponentValue', | |
| value: { | |
| lat: lat, | |
| lon: lon, | |
| accuracy: accuracy, | |
| altitude: altitude, | |
| heading: heading, | |
| speed: speed, | |
| method: "GPS", | |
| timestamp: timestamp, | |
| success: true | |
| } | |
| }, '*'); | |
| }, | |
| function(error) { | |
| let errorMsg = "📍 GPS location unavailable"; | |
| let errorDetail = ""; | |
| switch(error.code) { | |
| case error.PERMISSION_DENIED: | |
| errorMsg = "🚫 Location access denied"; | |
| errorDetail = "Please allow location access in your browser settings"; | |
| break; | |
| case error.POSITION_UNAVAILABLE: | |
| errorMsg = "📍 GPS position unavailable"; | |
| errorDetail = "Your device's GPS might be disabled"; | |
| break; | |
| case error.TIMEOUT: | |
| errorMsg = "⏱️ GPS request timed out"; | |
| errorDetail = "GPS is taking too long to respond"; | |
| break; | |
| } | |
| if (locationAttempts < maxAttempts) { | |
| document.getElementById("status").innerHTML = ` | |
| <div style="background: linear-gradient(45deg, #f39c12, #e67e22); color: white; padding: 15px; border-radius: 10px; margin: 10px 0;"> | |
| <div style="font-weight: bold; margin-bottom: 5px;">${errorMsg}</div> | |
| <div style="font-size: 0.9em; margin-bottom: 5px;">${errorDetail}</div> | |
| <div style="font-size: 0.8em;">🔄 Retrying in 2 seconds... (${locationAttempts}/${maxAttempts})</div> | |
| </div> | |
| `; | |
| setTimeout(tryGetLocation, 2000); | |
| } else { | |
| // Try IP-based location as fallback | |
| tryIPLocation(); | |
| } | |
| }, | |
| options | |
| ); | |
| } else { | |
| tryIPLocation(); | |
| } | |
| } | |
| function tryIPLocation() { | |
| document.getElementById("status").innerHTML = ` | |
| <div style="background: linear-gradient(45deg, #3498db, #2980b9); color: white; padding: 15px; border-radius: 10px; margin: 10px 0;"> | |
| <div style="font-weight: bold;">🌐 Trying IP-based location...</div> | |
| <div style="font-size: 0.9em; opacity: 0.9;">Falling back to approximate location</div> | |
| </div> | |
| `; | |
| // Multiple IP geolocation services for reliability | |
| const services = [ | |
| 'https://ipapi.co/json/', | |
| 'https://api.ipify.org?format=json', | |
| 'https://httpbin.org/ip' | |
| ]; | |
| fetch('https://ipapi.co/json/') | |
| .then(response => response.json()) | |
| .then(data => { | |
| if (data.latitude && data.longitude && !data.error) { | |
| document.getElementById("status").innerHTML = ` | |
| <div style="background: linear-gradient(45deg, #3498db, #2980b9); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; box-shadow: 0 4px 15px rgba(52, 152, 219, 0.3);"> | |
| <div style="font-weight: bold; margin-bottom: 8px;">🌐 IP-based Location Found</div> | |
| <div style="font-size: 0.95em; margin-bottom: 5px;">📍 <strong>${data.latitude.toFixed(6)}, ${data.longitude.toFixed(6)}</strong></div> | |
| <div style="font-size: 0.85em; margin-bottom: 5px;"> | |
| 🟠 Accuracy: <span style="color: #f39c12; font-weight: bold;">Approximate</span> (City-level) | |
| </div> | |
| <div style="font-size: 0.8em; opacity: 0.9;">🏙️ ${data.city || 'Unknown'}, ${data.country_name || data.country || 'Unknown'}</div> | |
| <div style="font-size: 0.8em; opacity: 0.9;">🌐 ISP: ${data.org || 'Unknown'}</div> | |
| </div> | |
| `; | |
| window.parent.postMessage({ | |
| type: 'streamlit:setComponentValue', | |
| value: { | |
| lat: data.latitude, | |
| lon: data.longitude, | |
| accuracy: 10000, | |
| method: "IP", | |
| timestamp: new Date().toISOString(), | |
| city: data.city, | |
| country: data.country_name || data.country, | |
| region: data.region, | |
| timezone: data.timezone, | |
| isp: data.org, | |
| success: true | |
| } | |
| }, '*'); | |
| } else { | |
| showLocationUnavailable(); | |
| } | |
| }) | |
| .catch(() => { | |
| showLocationUnavailable(); | |
| }); | |
| } | |
| function showLocationUnavailable() { | |
| document.getElementById("status").innerHTML = ` | |
| <div style="background: linear-gradient(45deg, #e74c3c, #c0392b); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; box-shadow: 0 4px 15px rgba(231, 76, 60, 0.3);"> | |
| <div style="font-weight: bold; margin-bottom: 8px;">⚠️ Location Not Available</div> | |
| <div style="font-size: 0.9em; margin-bottom: 5px;">Unable to detect your location automatically</div> | |
| <div style="font-size: 0.85em; opacity: 0.9;">• You can continue uploading without location data</div> | |
| <div style="font-size: 0.85em; opacity: 0.9;">• Or enter coordinates manually using the button</div> | |
| </div> | |
| `; | |
| window.parent.postMessage({ | |
| type: 'streamlit:setComponentValue', | |
| value: {lat: null, lon: null, success: false} | |
| }, '*'); | |
| } | |
| // Start location capture immediately | |
| tryGetLocation(); | |
| </script> | |
| <div id="status" style="padding: 15px; background: linear-gradient(45deg, #74b9ff, #0984e3); color: white; border-radius: 10px; text-align: center; font-weight: 500; box-shadow: 0 4px 15px rgba(116, 185, 255, 0.3);"> | |
| 🔄 Initializing advanced location services... | |
| </div> | |
| """, | |
| height=140 | |
| ) | |
| with col2: | |
| if st.button("📝 Enter Manually", help="Enter coordinates manually if automatic detection fails"): | |
| st.session_state.manual_location_mode = True | |
| st.rerun() | |
| # Process the location data | |
| if location_data and isinstance(location_data, dict): | |
| if location_data.get('success') and location_data.get('lat') and location_data.get('lon'): | |
| st.session_state.user_location = { | |
| "lat": float(location_data['lat']), | |
| "lon": float(location_data['lon']), | |
| "accuracy": location_data.get('accuracy'), | |
| "method": location_data.get('method', 'Unknown'), | |
| "timestamp": location_data.get('timestamp'), | |
| "city": location_data.get('city'), | |
| "country": location_data.get('country') | |
| } | |
| st.session_state.location_fetched = True | |
| st.rerun() | |
| elif location_data.get('success') == False: | |
| st.session_state.location_fetched = True | |
| elif st.session_state.manual_location_mode: | |
| st.markdown("### 📝 Manual Location Entry") | |
| col1, col2, col3 = st.columns([1, 1, 1]) | |
| with col1: | |
| manual_lat = st.number_input( | |
| "Latitude", | |
| value=0.0, | |
| format="%.6f", | |
| help="Enter latitude (-90 to 90)" | |
| ) | |
| with col2: | |
| manual_lon = st.number_input( | |
| "Longitude", | |
| value=0.0, | |
| format="%.6f", | |
| help="Enter longitude (-180 to 180)" | |
| ) | |
| with col3: | |
| st.write("") # Spacing | |
| if st.button("✅ Use These Coordinates"): | |
| if -90 <= manual_lat <= 90 and -180 <= manual_lon <= 180: | |
| st.session_state.user_location = { | |
| "lat": manual_lat, | |
| "lon": manual_lon, | |
| "accuracy": None, | |
| "method": "Manual", | |
| "timestamp": datetime.now().isoformat() | |
| } | |
| st.session_state.location_fetched = True | |
| st.session_state.manual_location_mode = False | |
| st.success("✅ Manual coordinates saved!") | |
| st.rerun() | |
| else: | |
| st.error("❌ Invalid coordinates. Latitude: -90 to 90, Longitude: -180 to 180") | |
| if st.button("🔙 Back to Auto-Detection"): | |
| st.session_state.manual_location_mode = False | |
| st.rerun() | |
| return st.session_state.user_location | |
| def display_analytics_sidebar(): | |
| """Display real-time analytics in the sidebar""" | |
| with st.sidebar: | |
| st.markdown("## 📊 Live Analytics") | |
| # Calculate statistics | |
| stats = calculate_statistics() | |
| # Display key metrics with enhanced styling | |
| st.markdown(f""" | |
| <div style="background: linear-gradient(45deg, #667eea, #764ba2); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; text-align: center;"> | |
| <h3 style="margin: 0; font-size: 2em;">👥 {stats['total_users']}</h3> | |
| <p style="margin: 5px 0 0 0;">Total Contributors</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| st.markdown(f""" | |
| <div style="background: linear-gradient(45deg, #f093fb, #f5576c); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; text-align: center;"> | |
| <h3 style="margin: 0; font-size: 2em;">🖼️ {stats['total_images']}</h3> | |
| <p style="margin: 5px 0 0 0;">Total Images</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| st.markdown(f""" | |
| <div style="background: linear-gradient(45deg, #4facfe, #00f2fe); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; text-align: center;"> | |
| <h3 style="margin: 0; font-size: 2em;">🏷️ {stats['total_labels']}</h3> | |
| <p style="margin: 5px 0 0 0;">Total Labels</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| st.markdown(f""" | |
| <div style="background: linear-gradient(45deg, #43e97b, #38f9d7); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; text-align: center;"> | |
| <h3 style="margin: 0; font-size: 2em;">🌍 {stats['languages_used']}</h3> | |
| <p style="margin: 5px 0 0 0;">Languages Used</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| # Location statistics | |
| st.markdown(f""" | |
| <div style="background: linear-gradient(45deg, #fd79a8, #e84393); color: white; padding: 15px; border-radius: 10px; margin: 10px 0; text-align: center;"> | |
| <h3 style="margin: 0; font-size: 2em;">🌍 {stats['images_with_location']}</h3> | |
| <p style="margin: 5px 0 0 0;">Images with GPS Data</p> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| # GPS accuracy breakdown | |
| if stats['gps_accuracy_breakdown']: | |
| st.markdown("### 🎯 GPS Accuracy Levels") | |
| for accuracy_level, count in sorted(stats['gps_accuracy_breakdown'].items(), key=lambda x: x[1], reverse=True): | |
| percentage = (count / stats['images_with_location'] * 100) if stats['images_with_location'] > 0 else 0 | |
| accuracy_emoji = {"High": "🟢", "Medium": "🟠", "Low": "🔴", "Unknown": "⚪"}.get(accuracy_level, "⚪") | |
| st.markdown(f"{accuracy_emoji} **{accuracy_level}**: {count} ({percentage:.1f}%)") | |
| # Location methods breakdown | |
| if stats['location_methods']: | |
| st.markdown("### 📍 Location Capture Methods") | |
| for method, count in sorted(stats['location_methods'].items(), key=lambda x: x[1], reverse=True): | |
| percentage = (count / stats['images_with_location'] * 100) if stats['images_with_location'] > 0 else 0 | |
| method_emoji = {"GPS": "🛰️", "IP": "🌐", "Manual": "📝"}.get(method, "❓") | |
| st.markdown(f"{method_emoji} **{method}**: {count} ({percentage:.1f}%)") | |
| # Language usage breakdown | |
| if stats['language_breakdown']: | |
| st.markdown("### 🗣️ Language Usage") | |
| for lang_code, count in sorted(stats['language_breakdown'].items(), key=lambda x: x[1], reverse=True): | |
| lang_name = SUPPORTED_LANGUAGES.get(lang_code, lang_code) | |
| percentage = (count / stats['total_labels'] * 100) if stats['total_labels'] > 0 else 0 | |
| st.markdown(f"**{lang_name}**: {count} labels ({percentage:.1f}%)") | |
| # Category breakdown | |
| if stats['category_breakdown']: | |
| st.markdown("### 📂 Category Breakdown") | |
| for category, count in sorted(stats['category_breakdown'].items(), key=lambda x: x[1], reverse=True): | |
| percentage = (count / stats['total_images'] * 100) if stats['total_images'] > 0 else 0 | |
| st.markdown(f"**{get_translation(st.session_state.language, category.lower())}**: {count} ({percentage:.1f}%)") | |
| # Country/Region statistics | |
| if stats['country_breakdown']: | |
| st.markdown("### 🌏 Top Countries") | |
| for country, count in sorted(stats['country_breakdown'].items(), key=lambda x: x[1], reverse=True)[:5]: | |
| percentage = (count / stats['images_with_location'] * 100) if stats['images_with_location'] > 0 else 0 | |
| st.markdown(f"🏴 **{country}**: {count} ({percentage:.1f}%)") | |
| def register_user(): | |
| """Enhanced user registration form""" | |
| st.subheader(get_translation(st.session_state.language, "register")) | |
| with st.form("register_form"): | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| username = st.text_input(get_translation(st.session_state.language, "username")) | |
| password = st.text_input(get_translation(st.session_state.language, "password"), type="password") | |
| confirm_password = st.text_input(get_translation(st.session_state.language, "confirm_password"), type="password") | |
| with col2: | |
| full_name = st.text_input(get_translation(st.session_state.language, "full_name")) | |
| email = st.text_input(get_translation(st.session_state.language, "email")) | |
| phone = st.text_input(get_translation(st.session_state.language, "phone")) | |
| age = st.number_input(get_translation(st.session_state.language, "age"), min_value=13, max_value=120, value=25) | |
| preferred_language = st.selectbox( | |
| get_translation(st.session_state.language, "preferred_language"), | |
| options=list(SUPPORTED_LANGUAGES.keys()), | |
| format_func=lambda x: SUPPORTED_LANGUAGES[x] | |
| ) | |
| submitted = st.form_submit_button(get_translation(st.session_state.language, "register")) | |
| if submitted: | |
| if not username or not password or not full_name or not email: | |
| st.error(get_translation(st.session_state.language, "fill_all_fields")) | |
| return | |
| if password != confirm_password: | |
| st.error(get_translation(st.session_state.language, "passwords_dont_match")) | |
| return | |
| users = load_users() | |
| if username in users: | |
| st.error(get_translation(st.session_state.language, "username_exists")) | |
| return | |
| users[username] = { | |
| 'password': password, | |
| 'preferred_language': preferred_language, | |
| 'created_at': datetime.now().isoformat(), | |
| 'user_details': { | |
| 'full_name': full_name, | |
| 'email': email, | |
| 'phone': phone, | |
| 'age': age | |
| } | |
| } | |
| save_users(users) | |
| st.success(get_translation(st.session_state.language, "registration_successful")) | |
| st.rerun() | |
| def login_user(): | |
| """User login form""" | |
| st.subheader(get_translation(st.session_state.language, "login")) | |
| with st.form("login_form"): | |
| username = st.text_input(get_translation(st.session_state.language, "username")) | |
| password = st.text_input(get_translation(st.session_state.language, "password"), type="password") | |
| submitted = st.form_submit_button(get_translation(st.session_state.language, "login")) | |
| if submitted: | |
| if not username or not password: | |
| st.error(get_translation(st.session_state.language, "fill_all_fields")) | |
| return | |
| users = load_users() | |
| if username not in users: | |
| st.error(get_translation(st.session_state.language, "invalid_credentials")) | |
| return | |
| if users[username]['password'] != password: | |
| st.error(get_translation(st.session_state.language, "invalid_credentials")) | |
| return | |
| st.session_state.user = username | |
| st.session_state.language = users[username]['preferred_language'] | |
| # Reset location fetch status for new login | |
| st.session_state.location_fetched = False | |
| st.session_state.manual_location_mode = False | |
| st.success(get_translation(st.session_state.language, "login_successful")) | |
| st.rerun() | |
| def upload_image(): | |
| """Enhanced image upload form with location display""" | |
| st.subheader(f"📤 {get_translation(st.session_state.language, 'upload_image')}") | |
| # Initialize upload counter for form reset | |
| if 'upload_counter' not in st.session_state: | |
| st.session_state.upload_counter = 0 | |
| # Show enhanced location status | |
| location = get_enhanced_location() | |
| if location and location.get('lat'): | |
| method_icon = "🛰️" if location.get('method') == "GPS" else "🌐" if location.get('method') == "IP" else "📝" | |
| accuracy_text = "" | |
| if location.get('accuracy'): | |
| if location['accuracy'] <= 10: | |
| accuracy_text = f" (±{location['accuracy']:.0f}m - High Accuracy)" | |
| elif location['accuracy'] <= 50: | |
| accuracy_text = f" (±{location['accuracy']:.0f}m - Medium Accuracy)" | |
| else: | |
| accuracy_text = f" (±{location['accuracy']:.0f}m - Low Accuracy)" | |
| st.markdown(f""" | |
| <div style="background: linear-gradient(45deg, #00b894, #00cec9); color: white; padding: 15px; border-radius: 10px; margin: 15px 0; text-align: center; font-weight: 500; box-shadow: 0 4px 15px rgba(0, 184, 148, 0.3);"> | |
| {method_icon} Location Ready: {location['lat']:.6f}, {location['lon']:.6f}{accuracy_text} | |
| <br><small>Method: {location.get('method', 'Unknown')} | Captured: {datetime.fromisoformat(location.get('timestamp', datetime.now().isoformat())).strftime('%H:%M:%S') if location.get('timestamp') else 'Unknown'}</small> | |
| </div> | |
| """, unsafe_allow_html=True) | |
| if st.button("🔄 Refresh Location"): | |
| st.session_state.location_fetched = False | |
| st.session_state.manual_location_mode = False | |
| st.rerun() | |
| # Use unique form key to ensure proper reset | |
| with st.form(f"upload_form_{st.session_state.upload_counter}", clear_on_submit=True): | |
| uploaded_file = st.file_uploader( | |
| get_translation(st.session_state.language, "choose_image"), | |
| type=['png', 'jpg', 'jpeg', 'gif'], | |
| help=get_translation(st.session_state.language, "image_help") | |
| ) | |
| col1, col2 = st.columns(2) | |
| with col1: | |
| title = st.text_input(get_translation(st.session_state.language, "image_title")) | |
| description = st.text_area(get_translation(st.session_state.language, "image_description")) | |
| with col2: | |
| label = st.text_input(get_translation(st.session_state.language, "native_language_label")) | |
| category = st.selectbox( | |
| get_translation(st.session_state.language, "category"), | |
| options=get_categories(), | |
| format_func=lambda x: get_translation(st.session_state.language, x.lower()) | |
| ) | |
| submitted = st.form_submit_button(get_translation(st.session_state.language, "upload")) | |
| if submitted: | |
| if not uploaded_file or not title or not description or not label: | |
| st.error(get_translation(st.session_state.language, "fill_all_fields")) | |
| return | |
| # Validate image | |
| validation_result = validate_image(uploaded_file) | |
| if not validation_result['valid']: | |
| st.error(get_translation(st.session_state.language, validation_result['error'])) | |
| return | |
| # Check if location is available (but allow upload without it) | |
| current_location = st.session_state.get('user_location', {}) | |
| location_status = "No location data" | |
| if current_location and current_location.get('lat'): | |
| location_status = f"📍 {current_location.get('method', 'Unknown')} location captured" | |
| else: | |
| st.warning("⚠️ **Location not captured** - Image will be uploaded without GPS coordinates. For better dataset quality, try refreshing location.") | |
| # Generate unique filename | |
| file_extension = uploaded_file.name.split('.')[-1] | |
| unique_filename = f"{uuid.uuid4()}.{file_extension}" | |
| # Save image to existing images directory | |
| image_path = os.path.join(IMAGES_DIR, unique_filename) | |
| if os.path.exists(IMAGES_DIR): | |
| try: | |
| image = Image.open(uploaded_file) | |
| image.save(image_path) | |
| except (OSError, PermissionError): | |
| st.error("Unable to save image. Please check if 'data/images' folder exists and has write permissions.") | |
| return | |
| else: | |
| st.error("Images directory not found. Please ensure 'data/images' folder exists in the workspace.") | |
| return | |
| # Prepare comprehensive location metadata | |
| location_metadata = None | |
| if current_location and current_location.get('lat'): | |
| location_metadata = { | |
| 'latitude': current_location['lat'], | |
| 'longitude': current_location['lon'], | |
| 'accuracy': current_location.get('accuracy'), | |
| 'altitude': current_location.get('altitude'), | |
| 'heading': current_location.get('heading'), | |
| 'speed': current_location.get('speed'), | |
| 'method': current_location.get('method', 'Unknown'), | |
| 'timestamp': current_location.get('timestamp', datetime.now().isoformat()), | |
| 'city': current_location.get('city'), | |
| 'country': current_location.get('country'), | |
| 'region': current_location.get('region'), | |
| 'timezone': current_location.get('timezone'), | |
| 'isp': current_location.get('isp') | |
| } | |
| # Save comprehensive label data | |
| labels = load_labels() | |
| entry_id = str(uuid.uuid4()) | |
| labels[entry_id] = { | |
| 'image_path': image_path, | |
| 'filename': unique_filename, | |
| 'title': title, | |
| 'description': description, | |
| 'category': category, | |
| 'uploaded_by': st.session_state.user, | |
| 'uploaded_at': datetime.now().isoformat(), | |
| 'location': location_metadata, # Comprehensive location data | |
| 'location_status': location_status, | |
| 'labels': [ | |
| { | |
| 'text': label, | |
| 'language': st.session_state.language, | |
| 'added_by': st.session_state.user, | |
| 'added_at': datetime.now().isoformat() | |
| } | |
| ] | |
| } | |
| # Save labels and verify the save operation | |
| try: | |
| save_labels(labels) | |
| st.success("Data saved successfully!") | |
| except Exception as e: | |
| st.error(f"Error saving data: {str(e)}") | |
| return | |
| # Show success message with location info | |
| if location_metadata: | |
| success_msg = f"✅ {get_translation(st.session_state.language, 'upload_successful')} with {location_metadata['method']} coordinates!" | |
| else: | |
| success_msg = f"✅ {get_translation(st.session_state.language, 'upload_successful')} (without location data)" | |
| st.success(success_msg) | |
| # Debug: Show what was saved | |
| st.info(f"Saved entry ID: {entry_id}") | |
| st.info(f"Image path: {image_path}") | |
| st.info(f"Data directory exists: {os.path.exists(DATA_DIR)}") | |
| st.info(f"Labels file exists: {os.path.exists(LABELS_FILE)}") | |
| # Initialize counter if it doesn't exist | |
| if 'upload_counter' not in st.session_state: | |
| st.session_state.upload_counter = 0 | |
| st.session_state.upload_counter += 1 | |
| # Reset location for next upload to get fresh coordinates | |
| st.session_state.location_fetched = False | |
| st.session_state.manual_location_mode = False | |
| st.rerun() | |
| def display_image_feed(): | |
| """Enhanced image feed with improved styling and functionality""" | |
| st.subheader(f"📱 {get_translation(st.session_state.language, 'image_feed')}") | |
| # Category filter | |
| categories = ['All'] + get_categories() | |
| selected_category = st.selectbox( | |
| get_translation(st.session_state.language, "filter_by_category"), | |
| options=categories, | |
| format_func=lambda x: get_translation(st.session_state.language, x.lower()) if x != 'All' else get_translation(st.session_state.language, 'all') | |
| ) | |
| labels = load_labels() | |
| if not labels: | |
| st.info(get_translation(st.session_state.language, "no_images_yet")) | |
| return | |
| # Filter by category | |
| filtered_labels = labels | |
| if selected_category != 'All': | |
| filtered_labels = {k: v for k, v in labels.items() if v.get('category') == selected_category} | |
| # Display images in a grid | |
| for entry_id, entry_data in sorted(filtered_labels.items(), key=lambda x: x[1]['uploaded_at'], reverse=True): | |
| with st.container(): | |
| col1, col2 = st.columns([1, 2]) | |
| with col1: | |
| # Display image | |
| image_path = entry_data['image_path'] | |
| if os.path.exists(image_path): | |
| image = Image.open(image_path) | |
| st.image(image, width=300, caption=entry_data['title']) | |
| else: | |
| st.error(get_translation(st.session_state.language, "image_not_found")) | |
| with col2: | |
| # Display metadata | |
| st.markdown(f"### {entry_data['title']}") | |
| st.markdown(f"**{get_translation(st.session_state.language, 'image_description')}:** {entry_data['description']}") | |
| st.markdown(f"**{get_translation(st.session_state.language, 'category')}:** {get_translation(st.session_state.language, entry_data['category'].lower())}") | |
| st.markdown(f"**📤 Uploaded by:** {entry_data['uploaded_by']}") | |
| st.markdown(f"**📅 Date:** {datetime.fromisoformat(entry_data['uploaded_at']).strftime('%Y-%m-%d %H:%M')}") | |
| # Enhanced location display - handle both old and new location formats | |
| location = entry_data.get('location') | |
| if location and (location.get('latitude') or location.get('lat')): | |
| # Handle both old format (lat/lon) and new format (latitude/longitude) | |
| lat = location.get('latitude') or location.get('lat', 0) | |
| lon = location.get('longitude') or location.get('lon', 0) | |
| method_icon = "🛰️" if location.get('method') == "GPS" else "🌐" if location.get('method') == "IP" else "📝" | |
| accuracy_info = "" | |
| if location.get('accuracy'): | |
| accuracy_info = f" (±{location['accuracy']:.0f}m accuracy)" | |
| location_text = f"{method_icon} {lat:.6f}, {lon:.6f}{accuracy_info}" | |
| if location.get('city') and location.get('country'): | |
| location_text += f" - {location['city']}, {location['country']}" | |
| st.markdown(f"**📍 Location:** {location_text}") | |
| # Display labels | |
| st.markdown(f"**{get_translation(st.session_state.language, 'labels')}:**") | |
| for label_data in entry_data['labels']: | |
| lang_name = SUPPORTED_LANGUAGES.get(label_data['language'], label_data['language']) | |
| st.markdown(f"- **{label_data['text']}** ({lang_name}) - by {label_data['added_by']}") | |
| # Add new label form | |
| with st.expander(get_translation(st.session_state.language, "add_label")): | |
| with st.form(f"label_form_{entry_id}"): | |
| new_label = st.text_input(get_translation(st.session_state.language, "new_label")) | |
| label_language = st.selectbox( | |
| get_translation(st.session_state.language, "label_language"), | |
| options=list(SUPPORTED_LANGUAGES.keys()), | |
| format_func=lambda x: SUPPORTED_LANGUAGES[x] | |
| ) | |
| if st.form_submit_button(get_translation(st.session_state.language, "add_label")): | |
| if not new_label: | |
| st.error(get_translation(st.session_state.language, "enter_label")) | |
| else: | |
| # Check if label already exists | |
| existing_labels = [l['text'].lower() for l in entry_data['labels']] | |
| if new_label.lower() in existing_labels: | |
| st.error(get_translation(st.session_state.language, "label_exists")) | |
| else: | |
| # Add new label | |
| labels[entry_id]['labels'].append({ | |
| 'text': new_label, | |
| 'language': label_language, | |
| 'added_by': st.session_state.user, | |
| 'added_at': datetime.now().isoformat() | |
| }) | |
| save_labels(labels) | |
| st.success(get_translation(st.session_state.language, "label_added")) | |
| st.rerun() | |
| st.markdown("---") | |
| def main(): | |
| """Main application function""" | |
| # Header with language selector | |
| col1, col2, col3 = st.columns([2, 1, 1]) | |
| with col1: | |
| st.title("🏷️ LabelIt! 🇮🇳") | |
| st.markdown(get_translation(st.session_state.language, "app_subtitle")) | |
| with col2: | |
| # Language selector | |
| selected_language = st.selectbox( | |
| "🌍 Language", | |
| options=list(SUPPORTED_LANGUAGES.keys()), | |
| format_func=lambda x: SUPPORTED_LANGUAGES[x], | |
| index=list(SUPPORTED_LANGUAGES.keys()).index(st.session_state.language) | |
| ) | |
| if selected_language != st.session_state.language: | |
| st.session_state.language = selected_language | |
| st.rerun() | |
| with col3: | |
| if st.session_state.user: | |
| if st.button(get_translation(st.session_state.language, "logout")): | |
| st.session_state.user = None | |
| st.session_state.location_fetched = False | |
| st.session_state.manual_location_mode = False | |
| st.rerun() | |
| # Display analytics sidebar | |
| display_analytics_sidebar() | |
| # Main content | |
| if not st.session_state.user: | |
| # Authentication tabs | |
| tab1, tab2 = st.tabs([ | |
| get_translation(st.session_state.language, "login"), | |
| get_translation(st.session_state.language, "register") | |
| ]) | |
| with tab1: | |
| login_user() | |
| with tab2: | |
| register_user() | |
| else: | |
| # User is logged in - show user details in sidebar | |
| with st.sidebar: | |
| st.markdown("---") | |
| st.markdown(f"### 👤 {get_translation(st.session_state.language, 'welcome')}, {st.session_state.user}!") | |
| users = load_users() | |
| user_details = users[st.session_state.user]['user_details'] | |
| st.markdown(f"**{get_translation(st.session_state.language, 'full_name')}:** {user_details['full_name']}") | |
| st.markdown(f"**{get_translation(st.session_state.language, 'email')}:** {user_details['email']}") | |
| st.markdown(f"**{get_translation(st.session_state.language, 'phone')}:** {user_details['phone']}") | |
| st.markdown(f"**{get_translation(st.session_state.language, 'age')}:** {user_details['age']}") | |
| # Main application tabs | |
| tab1, tab2 = st.tabs([ | |
| get_translation(st.session_state.language, "upload_image"), | |
| get_translation(st.session_state.language, "feed") | |
| ]) | |
| with tab1: | |
| upload_image() | |
| with tab2: | |
| display_image_feed() | |
| if __name__ == "__main__": | |
| main() | |