Update app.py

This is 1st version from Cursor

app.py

@@ -6,6 +6,14 @@ from PIL import Image
 import firebase_admin
 from firebase_admin import credentials, auth
 import pandas as pd
+import uuid
+from datetime import datetime
+from io import BytesIO
+import streamlit_tags as st_tags
+from dotenv import load_dotenv
+
+# Load environment variables from .env file if it exists
+load_dotenv()
 
 # Load AWS credentials using correct HF Secrets
 AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY")
@@ -19,23 +27,38 @@ FIREBASE_CONFIG = json.loads(os.getenv("FIREBASE_CONFIG", "{}"))
 
 # Initialize Firebase Admin SDK (Prevent multiple initialization)
 if not firebase_admin._apps:
-    cred = credentials.Certificate(FIREBASE_CONFIG)
-    firebase_admin.initialize_app(cred)
+    try:
+        cred = credentials.Certificate(FIREBASE_CONFIG)
+        firebase_admin.initialize_app(cred)
+    except Exception as e:
+        st.error(f"Firebase initialization error: {e}")
+        if st.button("Continue in Demo Mode"):
+            st.session_state["demo_mode"] = True
+        else:
+            st.stop()
 
 # Initialize AWS Services (S3 & DynamoDB)
-s3 = boto3.client(
-    "s3",
-    aws_access_key_id=AWS_ACCESS_KEY,
-    aws_secret_access_key=AWS_SECRET_KEY,
-)
-
-dynamodb = boto3.resource(
-    "dynamodb", 
-    region_name=AWS_REGION, 
-    aws_access_key_id=AWS_ACCESS_KEY, 
-    aws_secret_access_key=AWS_SECRET_KEY,
-)
-metadata_table = dynamodb.Table(DYNAMODB_TABLE)
+try:
+    s3 = boto3.client(
+        "s3",
+        aws_access_key_id=AWS_ACCESS_KEY,
+        aws_secret_access_key=AWS_SECRET_KEY,
+        region_name=AWS_REGION
+    )
+
+    dynamodb = boto3.resource(
+        "dynamodb", 
+        region_name=AWS_REGION, 
+        aws_access_key_id=AWS_ACCESS_KEY, 
+        aws_secret_access_key=AWS_SECRET_KEY,
+    )
+    metadata_table = dynamodb.Table(DYNAMODB_TABLE)
+except Exception as e:
+    st.error(f"AWS initialization error: {e}")
+    if st.button("Continue in Demo Mode"):
+        st.session_state["demo_mode"] = True
+    else:
+        st.stop()
 
 # Food Intellisense List
 FOOD_SUGGESTIONS = [
@@ -50,6 +73,140 @@ FOOD_SUGGESTIONS = [
 # Unit options for food weight/volume
 UNIT_OPTIONS = ["grams", "ounces", "teaspoons", "tablespoons", "cups", "slices", "pieces"]
 
+# Cooking methods
+COOKING_METHODS = [
+    "Baked", "Boiled", "Broiled", "Fried", "Grilled", "Microwaved", 
+    "Pan-seared", "Poached", "Raw", "Roasted", "Sautéed", "Steamed", 
+    "Stewed", "Stir-fried", "Takeout/Restaurant", "Unknown"
+]
+
+# Helper functions
+def resize_image(image, max_size=512, quality=85):
+    """
+    Resize image while preserving aspect ratio and reducing file size
+    
+    Args:
+        image: PIL Image object
+        max_size: Maximum dimension (width or height)
+        quality: JPEG quality (0-100)
+        
+    Returns:
+        Resized PIL Image
+    """
+    # Calculate new dimensions
+    width, height = image.width, image.height
+    
+    # Only resize if the image is larger than max_size
+    if width > max_size or height > max_size:
+        if width > height:
+            new_width = max_size
+            new_height = int(height * (max_size / width))
+        else:
+            new_height = max_size
+            new_width = int(width * (max_size / height))
+        
+        # Resize the image
+        resized_img = image.resize((new_width, new_height), Image.LANCZOS)
+    else:
+        # If image is already smaller than max_size, don't resize
+        return image
+    
+    # Convert to RGB if image has alpha channel (for JPEG conversion)
+    if resized_img.mode == 'RGBA':
+        resized_img = resized_img.convert('RGB')
+    
+    # Compress the image
+    buffer = BytesIO()
+    resized_img.save(buffer, format="JPEG", quality=quality, optimize=True)
+    buffer.seek(0)
+    
+    # Return the compressed image
+    return Image.open(buffer)
+
+def get_image_size_kb(image):
+    """Get image file size in KB"""
+    buffer = BytesIO()
+    image.save(buffer, format="JPEG")
+    size_bytes = buffer.tell()
+    return size_bytes / 1024  # Convert to KB
+
+def upload_to_s3(image, user_id):
+    """Upload image to S3 bucket and return the S3 path"""
+    if st.session_state.get("demo_mode", False):
+        return f"demo/{user_id}/demo_image.jpg"
+    
+    try:
+        # Generate a unique ID for the image
+        image_id = str(uuid.uuid4())
+        timestamp = datetime.now().strftime("%Y%m%d%H%M%S")
+        s3_path = f"{user_id}/{timestamp}_{image_id}.jpg"
+        
+        # Convert PIL image to bytes
+        buffer = BytesIO()
+        image.save(buffer, format="JPEG", quality=85, optimize=True)
+        buffer.seek(0)
+        
+        # Upload to S3
+        s3.upload_fileobj(buffer, S3_BUCKET_NAME, s3_path)
+        return s3_path
+    except Exception as e:
+        st.error(f"Failed to upload image: {e}")
+        return None
+
+def save_metadata(user_id, s3_path, food_name, portion_size, portion_unit, cooking_method, ingredients, tokens_awarded):
+    """Save metadata to DynamoDB"""
+    if st.session_state.get("demo_mode", False):
+        st.success("Demo mode: Metadata would be saved to DynamoDB")
+        return True
+    
+    try:
+        # Generate a unique ID for the database entry
+        image_id = str(uuid.uuid4())
+        timestamp = datetime.now().isoformat()
+        
+        # Create item for DynamoDB
+        item = {
+            'image_id': image_id,
+            'user_id': user_id,
+            'upload_timestamp': timestamp,
+            'food_name': food_name,
+            'portion_size': portion_size,
+            'portion_unit': portion_unit,
+            'cooking_method': cooking_method,
+            'ingredients': ingredients,
+            's3_path': s3_path,
+            'tokens_awarded': tokens_awarded
+        }
+        
+        # Save to DynamoDB
+        metadata_table.put_item(Item=item)
+        return True
+    except Exception as e:
+        st.error(f"Failed to save metadata: {e}")
+        return False
+
+def calculate_tokens(image_quality, has_metadata, is_unique_category):
+    """Calculate tokens based on various factors"""
+    tokens = 1  # Base token for upload
+    
+    if image_quality == "high":
+        tokens += 1
+    
+    if has_metadata:
+        tokens += 1
+    
+    if is_unique_category:
+        tokens += 1
+    
+    return tokens
+
+# Initialize session state for first-time users
+if "tokens" not in st.session_state:
+    st.session_state["tokens"] = 0
+
+if "uploads_count" not in st.session_state:
+    st.session_state["uploads_count"] = 0
+
 # Streamlit Layout - Authentication Section
 st.sidebar.title("🔑 User Authentication")
 auth_option = st.sidebar.radio("Select an option", ["Login", "Sign Up", "Logout"])
@@ -59,8 +216,11 @@ if auth_option == "Sign Up":
     password = st.sidebar.text_input("Password", type="password")
     if st.sidebar.button("Sign Up"):
         try:
-            user = auth.create_user(email=email, password=password)
-            st.sidebar.success("✅ User created successfully! Please log in.")
+            if st.session_state.get("demo_mode", False):
+                st.sidebar.success("✅ Demo mode: User created successfully! Please log in.")
+            else:
+                user = auth.create_user(email=email, password=password)
+                st.sidebar.success("✅ User created successfully! Please log in.")
         except Exception as e:
             st.sidebar.error(f"Error: {e}")
 
@@ -69,10 +229,15 @@ if auth_option == "Login":
     password = st.sidebar.text_input("Password", type="password")
     if st.sidebar.button("Login"):
         try:
-            user = auth.get_user_by_email(email)
-            st.session_state["user_id"] = user.uid
-            st.session_state["tokens"] = 0  # Initialize token count
-            st.sidebar.success("✅ Logged in successfully!")
+            if st.session_state.get("demo_mode", False):
+                st.session_state["user_id"] = "demo_user_123"
+                st.session_state["tokens"] = 0  # Initialize token count
+                st.sidebar.success("✅ Demo mode: Logged in successfully!")
+            else:
+                user = auth.get_user_by_email(email)
+                st.session_state["user_id"] = user.uid
+                st.session_state["tokens"] = 0  # Initialize token count
+                st.sidebar.success("✅ Logged in successfully!")
         except Exception as e:
             st.sidebar.error(f"Login failed: {e}")
 
@@ -81,56 +246,166 @@ if auth_option == "Logout" and "user_id" in st.session_state:
     st.sidebar.success("✅ Logged out successfully!")
 
 # Ensure user is logged in before uploading
-if "user_id" not in st.session_state:
+if "user_id" not in st.session_state and not st.session_state.get("demo_mode", False):
     st.warning("⚠️ Please log in to upload images.")
+    
+    # Add links to guidelines and terms
+    st.markdown("### 📚 While You're Here")
+    st.markdown("Take a moment to read our guidelines and token system:")
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        if st.button("Participation Guidelines"):
+            with open("PARTICIPATION_GUIDELINES.md", "r") as f:
+                guidelines = f.read()
+            st.markdown(guidelines)
+    with col2:
+        if st.button("Token Rewards"):
+            with open("TOKEN_REWARDS.md", "r") as f:
+                rewards = f.read()
+            st.markdown(rewards)
+    with col3:
+        if st.button("Terms of Service"):
+            with open("TERMS_OF_SERVICE.md", "r") as f:
+                terms = f.read()
+            st.markdown(terms)
+    
     st.stop()
 
-# Streamlit Layout - Three Panel Design
+# Streamlit Layout - Main App
 st.title("🍽️ Food Image Review & Annotation")
-col1, col2 = st.columns([1, 1])
 
 # Compliance & Disclaimer Section
-st.markdown("### **Terms & Conditions**")
-st.write(
-    "By uploading an image, you agree to transfer full copyright to the research team for AI training purposes."
-    " You are responsible for ensuring you own the image and it does not violate any copyright laws."
-    " We do not guarantee when tokens will be redeemable. Keep track of your user ID.")
-terms_accepted = st.checkbox("I agree to the terms and conditions", key="terms_accepted")
-if not terms_accepted:
-    st.warning("⚠️ You must agree to the terms before proceeding.")
-    st.stop()
+with st.expander("📜 Terms & Conditions", expanded=False):
+    st.markdown("### **Terms & Conditions**")
+    st.write(
+        "By uploading an image, you agree to transfer full copyright to the research team for AI training purposes."
+        " You are responsible for ensuring you own the image and it does not violate any copyright laws."
+        " We do not guarantee when tokens will be redeemable. Keep track of your user ID.")
+    terms_accepted = st.checkbox("I agree to the terms and conditions", key="terms_accepted")
+    if not terms_accepted:
+        st.warning("⚠️ You must agree to the terms before proceeding.")
+        st.stop()
 
 # Upload Image
 uploaded_file = st.file_uploader("Upload an image of your food", type=["jpg", "png", "jpeg"])
 if uploaded_file:
     original_img = Image.open(uploaded_file)
     st.session_state["original_image"] = original_img
-    st.session_state["tokens"] += 1  # Earn 1 token for upload
 
 # If an image has been uploaded, process and display it
 if "original_image" in st.session_state:
     original_img = st.session_state["original_image"]
     
-    def resize_image(image, max_size=512):
-        aspect_ratio = image.width / image.height
-        if image.width > image.height:
-            new_width = max_size
-            new_height = int(max_size / aspect_ratio)
-        else:
-            new_height = max_size
-            new_width = int(max_size * aspect_ratio)
-        return image.resize((new_width, new_height))
-
-    processed_img = resize_image(original_img)
+    # Process the image - resize and compress
+    processed_img = resize_image(original_img, max_size=512, quality=85)
+    st.session_state["processed_image"] = processed_img
+    
+    # Calculate file sizes
+    original_size = get_image_size_kb(original_img)
+    processed_size = get_image_size_kb(processed_img)
+    size_reduction = ((original_size - processed_size) / original_size) * 100 if original_size > 0 else 0
 
+    # Display images side by side
     col1, col2 = st.columns(2)
     with col1:
         st.subheader("📷 Original Image")
-        st.image(original_img, caption=f"Original ({original_img.width}x{original_img.height} pixels)", use_container_width=True)
+        st.image(original_img, caption=f"Original ({original_img.width}x{original_img.height} px, {original_size:.1f} KB)", use_container_width=True)
     with col2:
         st.subheader("🖼️ Processed Image")
-        st.image(processed_img, caption=f"Processed ({processed_img.width}x{processed_img.height} pixels)", use_container_width=True)
-    st.session_state["processed_image"] = processed_img
+        st.image(processed_img, caption=f"Processed ({processed_img.width}x{processed_img.height} px, {processed_size:.1f} KB)", use_container_width=True)
+    
+    # Show size reduction
+    if size_reduction > 5:  # Only show if there's a meaningful reduction
+        st.success(f"✅ Image size reduced by {size_reduction:.1f}% for faster uploads and processing")
+
+    # Food metadata form
+    st.subheader("🍲 Food Details")
+    
+    food_name = st.selectbox("Food Name", options=[""] + FOOD_SUGGESTIONS, index=0)
+    if food_name == "":
+        food_name = st.text_input("Or enter a custom food name")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        portion_size = st.number_input("Portion Size", min_value=0.1, step=0.1)
+    with col2:
+        portion_unit = st.selectbox("Unit", options=UNIT_OPTIONS)
+    
+    cooking_method = st.selectbox("Cooking Method", options=[""] + COOKING_METHODS)
+    
+    ingredients = st_tags.st_tags(
+        label="Main Ingredients (Add up to 5)",
+        text="Press enter to add",
+        value=[],
+        suggestions=["Salt", "Pepper", "Olive Oil", "Butter", "Garlic", "Onion", "Tomato"],
+        maxtags=5
+    )
+    
+    # Submit button
+    if st.button("📤 Submit Food Image"):
+        with st.spinner("Processing your submission..."):
+            # Determine image quality (simplified version)
+            image_quality = "high" if original_img.width >= 1000 and original_img.height >= 1000 else "standard"
+            
+            # Check if metadata is complete
+            has_metadata = bool(food_name and portion_size and portion_unit and cooking_method)
+            
+            # Check if the food is in a unique category (simplified)
+            is_unique_category = food_name not in ["Pizza", "Burger", "Pasta", "Salad"]
+            
+            # Calculate tokens
+            tokens_awarded = calculate_tokens(image_quality, has_metadata, is_unique_category)
+            
+            # Upload image to S3
+            s3_path = upload_to_s3(processed_img, st.session_state["user_id"])
+            
+            if s3_path:
+                # Save metadata to DynamoDB
+                success = save_metadata(
+                    st.session_state["user_id"],
+                    s3_path,
+                    food_name,
+                    float(portion_size),
+                    portion_unit,
+                    cooking_method,
+                    ingredients,
+                    tokens_awarded
+                )
+                
+                if success:
+                    st.session_state["tokens"] += tokens_awarded
+                    st.session_state["uploads_count"] += 1
+                    st.success(f"✅ Food image uploaded successfully! You earned {tokens_awarded} tokens.")
+                    
+                    # Clear the form and image for a new submission
+                    st.session_state.pop("original_image", None)
+                    st.session_state.pop("processed_image", None)
+                    st.experimental_rerun()
+                else:
+                    st.error("Failed to save metadata. Please try again.")
+            else:
+                st.error("Failed to upload image. Please try again.")
 
 # Display earned tokens
-st.success(f"🎉 Tokens Earned: {st.session_state['tokens']}")
+st.sidebar.markdown("---")
+st.sidebar.subheader("🏆 Your Statistics")
+st.sidebar.info(f"🪙 Total Tokens: {st.session_state['tokens']}")
+st.sidebar.info(f"📸 Total Uploads: {st.session_state.get('uploads_count', 0)}")
+
+# Help and Documentation Links
+st.sidebar.markdown("---")
+st.sidebar.subheader("📚 Resources")
+if st.sidebar.button("Participation Guidelines"):
+    with open("PARTICIPATION_GUIDELINES.md", "r") as f:
+        guidelines = f.read()
+    st.sidebar.markdown(guidelines)
+
+if st.sidebar.button("Token Rewards System"):
+    with open("TOKEN_REWARDS.md", "r") as f:
+        rewards = f.read()
+    st.sidebar.markdown(rewards)
+
+if st.sidebar.button("Terms of Service"):
+    with open("TERMS_OF_SERVICE.md", "r") as f:
+        terms = f.read()
+    st.sidebar.markdown(terms)