add authentication

app.py

@@ -20,26 +20,11 @@ from library.utils_prompt import *
 authorized_users_str = os.environ.get("AUTHORIZED_USER_IDS", "")
 AUTHORIZED_USER_IDS = set(authorized_users_str.split(',') if authorized_users_str and authorized_users_str.strip() else [])
 
-# Check if current user is authorized
-def check_authorization(profile: gr.OAuthProfile | None):
-    if profile is None:
-        return False #"Not logged in. Please Login for full access."
-    
-    if profile.username in AUTHORIZED_USER_IDS:
-        return True
-    else:
-        return False
 
 #Api sdk
 OR = OpenRouterAPI()
 
-# Path for storing user preferences
-PREFERENCES_FILE = "data/user_preferences.csv"
-
-# Ensure directory exists
-os.makedirs(os.path.dirname(PREFERENCES_FILE), exist_ok=True)
-
-# Define model pricing information (approximate costs per 100 image API calls)
+# At the top of your script, modify MODEL_PRICING:
 MODEL_PRICING = {
     "google/gemini-2.0-flash-001": "$0.03",
     "gpt-4.1-mini": "$0.07",
@@ -50,9 +35,28 @@ MODEL_PRICING = {
     "gpt-4.1-nano": "$0.02",
     "openai/chatgpt-4o-latest": "$0.75",
     "meta-llama/llama-4-maverick": "$0.04",
-    "meta-llama/llama-4-maverick:free": "Free"
+    "meta-llama/llama-4-maverick:free": "$0.00"  # Added for the free tier
 }
 
+# Define choices and default for unauthenticated users
+UNAUTHENTICATED_MODEL_CHOICES = [("Llama 4 Maverick (Free Tier)", "meta-llama/llama-4-maverick:free")]
+UNAUTHENTICATED_DEFAULT_MODEL_ID = "meta-llama/llama-4-maverick:free"
+
+# Your existing default for authenticated users
+AUTHENTICATED_DEFAULT_MODEL_ID = "google/gemini-2.0-flash-001"
+
+# New function to check if current user is authorized
+def check_authorization(profile: gr.OAuthProfile | None):
+    if not AUTHORIZED_USER_IDS: # If the set is empty, no one is authorized by this list
+        return False
+    if profile is None:
+        return False #"Not logged in. Please Login for full access."
+    
+    if profile.username in AUTHORIZED_USER_IDS:
+        return True
+    else:
+        return False
+
 def get_sys_prompt(length="medium", photograph=False):
     extra_prompt = ""
 
@@ -97,6 +101,18 @@ def get_base_filename(filepath):
     filename = os.path.splitext(basename)[0]
     return filename
 
+# Helper function to generate model info markdown
+def get_model_info_markdown(model_id, is_authorized):
+    models_to_search = all_models_list if is_authorized else UNAUTHENTICATED_MODEL_CHOICES
+    model_name = "Unknown Model"
+    for name, value in models_to_search:
+        if value == model_id:
+            model_name = name
+            break
+    cost = MODEL_PRICING.get(model_id, "N/A")
+    return f"""**Current Model**: {model_name}  
+           **Estimated cost per 100 Images**: {cost}"""
+
 # Define the Gradio interface
 def create_demo():
     custom_css = """
@@ -131,23 +147,6 @@ def create_demo():
     """
     # --- Pass css to gr.Blocks ---
     with gr.Blocks(theme=gr.themes.Monochrome(), css=custom_css) as demo:
-        # Store authentication state
-        is_authenticated = gr.State(False)
-        
-        # Initialize authentication on app load
-        def app_load():
-            # Get the OAuth profile (will be None if not logged in)
-            profile = getattr(gr.context.get('user', None), 'profile', None)
-            # Use the check_authorization function
-            return check_authorization(profile)
-        
-        # Update authentication state on load
-        demo.load(
-            fn=app_load,
-            inputs=None,
-            outputs=[is_authenticated]
-        )
-        
         with gr.Row():
             with gr.Column(scale=3):
                 gr.Markdown("# MATCHA: Museum Alt-Text for Cultural Heritage with AI 🍵 🌿")
@@ -155,23 +154,16 @@ def create_demo():
                 gr.Markdown("Developed by the Natural History Museum in Partnership with National Museums Liverpool. Funded by the DCMS Pilot Scheme")
             with gr.Column(scale=1):
                 with gr.Row():
-                    gr.Image("images/nhm_logo.png", show_label=False, height=120,
+                    gr.Image("images/nhm_logo.png", show_label=False, height=100,
                              interactive=False, show_download_button=False,
                              show_share_button=False, show_fullscreen_button=False,
                              container=False, elem_id="nhm-logo")
-                    gr.Image("images/nml_logo.png", show_label=False, height=120,
+                    gr.Image("images/nml_logo.png", show_label=False, height=100,
                              interactive=False, show_download_button=False,
                              show_share_button=False, show_fullscreen_button=False,
                              container=False, elem_id="nml-logo")
 
-        # Store model choices and state
-        show_all_models_state = gr.State(False)
-
-        # Define model lists
-        free_model = [
-            ("Llama 4 Maverick (Free)", "meta-llama/llama-4-maverick:free")
-        ]
-        
+        # Define model lists (these will be used by the auth logic)
         preferred_models = [
             ("Gemini 2.0 Flash (cheap)", "google/gemini-2.0-flash-001"),
             ("GPT-4.1 Mini", "gpt-4.1-mini"),
@@ -180,107 +172,52 @@ def create_demo():
             ("Gemini 2.5 Pro", "google/gemini-2.5-pro-preview-03-25"),
             ("Gemini 2.5 Flash Thinking (Recommended)", "google/gemini-2.5-flash-preview:thinking")
         ]
-        
         additional_models = [
             ("GPT-4.1 Nano", "gpt-4.1-nano"),
             ("ChatGPT Latest", "openai/chatgpt-4o-latest"),
             ("Llama 4 Maverick", "meta-llama/llama-4-maverick")
         ]
-        
-        # Calculate all models
         all_models_list = preferred_models + additional_models
-        
-        # Function to update model dropdown based on auth status
-        def update_model_dropdown(is_auth):
-            if is_auth:
-                return gr.Dropdown(choices=preferred_models, value="google/gemini-2.0-flash-001")
-            else:
-                return gr.Dropdown(choices=free_model, value="meta-llama/llama-4-maverick:free")
-        
+
+        # State variables
+        auth_status_state = gr.State(False) # True if authorized
+        user_show_all_models_preference_state = gr.State(False) # User's preference for showing all models
+
         with gr.Row():
-            # Left column: Controls and uploads
             with gr.Column(scale=1):
-                upload_button = gr.UploadButton(
-                    "Click to Upload Images",
-                    file_types=["image"],
-                    file_count="multiple"
-                )
+                upload_button = gr.UploadButton("Click to Upload Images", file_types=["image"], file_count="multiple")
                 
-                # Model dropdown - initially empty, will be populated based on auth status
                 model_choice = gr.Dropdown(
-                    choices=[], 
+                    choices=UNAUTHENTICATED_MODEL_CHOICES, # Initial default for unauth
+                    value=UNAUTHENTICATED_DEFAULT_MODEL_ID,
                     label="Select Model",
-                    value=None
-                )
-                
-                # Update the model dropdown when authentication state changes
-                is_authenticated.change(
-                    fn=update_model_dropdown,
-                    inputs=[is_authenticated],
-                    outputs=[model_choice]
-                )
-                
-                # Also update model dropdown on initial load
-                demo.load(
-                    fn=update_model_dropdown,
-                    inputs=[is_authenticated],
-                    outputs=[model_choice]
+                    interactive=True 
                 )
                 
                 length_choice = gr.Radio(
                     choices=["short", "medium", "long"], 
-                    label="Response Length",
-                    value="medium", 
+                    label="Response Length", value="medium", 
                     info="Short: max 130 chars | Medium: 250-300 chars | Long: max 450 chars"
                 )
                 
-                # Advanced settings accordion
-                with gr.Accordion("Advanced Settings", open=False):
-                    show_all_models = gr.Checkbox(
+                # Accordion for advanced settings - visibility controlled by auth
+                with gr.Accordion("Advanced Settings", open=False, visible=False) as advanced_settings_accordion:
+                    show_all_models_checkbox = gr.Checkbox(
                         label="Show Additional Models", 
-                        value=False,
-                        info="Display additional model options in the dropdown above"
-                    )
-                    
-                    # Update checkbox interactivity based on auth status
-                    def update_checkbox_interactive(is_auth):
-                        return gr.Checkbox(
-                            label="Show Additional Models",
-                            value=False,
-                            info="Display additional model options in the dropdown above",
-                            interactive=is_auth
-                        )
-                    
-                    is_authenticated.change(
-                        fn=update_checkbox_interactive,
-                        inputs=[is_authenticated],
-                        outputs=[show_all_models]
-                    )
-                    
-                    # Also update checkbox interactivity on initial load
-                    demo.load(
-                        fn=update_checkbox_interactive,
-                        inputs=[is_authenticated],
-                        outputs=[show_all_models]
+                        value=False, # Will be updated by auth logic
+                        info="Display additional model options in the dropdown above",
+                        interactive=False # Will be updated by auth logic
                     )
-                    
                     content_type = gr.Radio(
                         choices=["Museum Object", "Photography"], 
-                        label="Content Type",
-                        value="Museum Object"
+                        label="Content Type", value="Museum Object"
                     )
                 
-                # Model info display
-                model_info = gr.Markdown(
-                    "**Select a model to see information**",
-                    elem_id="model-info-display"
-                )
+                initial_model_info = get_model_info_markdown(UNAUTHENTICATED_DEFAULT_MODEL_ID, False)
+                model_info = gr.Markdown(initial_model_info, elem_id="model-info-display")
                 
                 gr.Markdown("### Uploaded Images")
-                input_gallery = gr.Gallery(
-                    label="Uploaded Image Previews", columns=3, height=150,
-                    object_fit="contain", show_label=False
-                )
+                input_gallery = gr.Gallery(label="Uploaded Image Previews", columns=3, height=150, object_fit="contain", show_label=False)
                 analyze_button = gr.Button("Generate Alt-Text", variant="primary", size="lg")
                 image_state = gr.State([])
                 filename_state = gr.State([])
@@ -288,141 +225,95 @@ def create_demo():
 
             # Right column: Display area
             with gr.Column(scale=2):
+                # right column UI: current_image, navigation, analysis_text
                 current_image = gr.Image(
-                    label="Current Image",
-                    type="filepath",
-                    elem_id="current-image-display",
-                    show_fullscreen_button=True,
-                    show_download_button=False,
-                    show_share_button=False,
-                    show_label=False
+                    label="Current Image", type="filepath", elem_id="current-image-display",
+                    show_fullscreen_button=True, show_download_button=False,
+                    show_share_button=False, show_label=False
                  )
-
                 with gr.Row():
                     prev_button = gr.Button("← Previous", size="sm")
                     image_counter = gr.Markdown("0 of 0", elem_id="image-counter")
                     next_button = gr.Button("Next →", size="sm")
-
                 gr.Markdown("### Generated Alt-text")
                 analysis_text = gr.Textbox(
-                    label="Generated Text",
-                    value="Upload images and click 'Generate Alt-Text'.",
+                    label="Generated Text", value="Upload images and click 'Generate Alt-Text'.",
                     lines=6, max_lines=10, interactive=True, show_label=False
                 )
                 current_index = gr.State(0)
                 all_images = gr.State([])
                 all_results = gr.State([])
-        
-        # Handle checkbox change to update model dropdown
-        def toggle_models(show_all, current_model, is_auth):
-            if not is_auth:
-                # Non-authenticated users only get free model
-                return gr.Dropdown(choices=free_model, value="meta-llama/llama-4-maverick:free")
-            
-            # For authenticated users, existing logic
-            preferred_choices = list(preferred_models)
-            all_choices = list(all_models_list)
-            
-            if show_all:
-                return gr.Dropdown(choices=all_choices, value=current_model)
-            else:
-                preferred_values = [value for _, value in preferred_choices]
-                
-                if current_model in preferred_values:
-                    return gr.Dropdown(choices=preferred_choices, value=current_model)
-                else:
-                    return gr.Dropdown(choices=preferred_choices, value="google/gemini-2.0-flash-001")
 
-        # Update model info when model selection changes
-        def update_model_info(model_value):
-            # Combine all model lists for lookup
-            combined_models = preferred_models + additional_models + free_model
+        # Function to update UI based on authentication status (called on demo.load)
+        def handle_auth_change_and_ui_setup(profile: gr.OAuthProfile | None, current_user_pref_show_all: bool):
+            is_authorized = check_authorization(profile)
             
-            # Find display name
-            model_name = "Unknown Model"
-            for name, value in combined_models:
-                if value == model_value:
-                    model_name = name
-                    break
-            
-            # Get cost
-            cost = MODEL_PRICING.get(model_value, "Unknown")
+            if is_authorized:
+                # Authorized User
+                current_choices = list(all_models_list) if current_user_pref_show_all else list(preferred_models)
+                current_value = AUTHENTICATED_DEFAULT_MODEL_ID # Reset to default for authed user
+                # You could add logic here to try and preserve model_choice.value if it's valid in current_choices
+
+                model_dropdown_update = gr.Dropdown.update(choices=current_choices, value=current_value, label="Select Model", interactive=True)
+                accordion_update = gr.Accordion.update(visible=True)
+                model_info_text_update = get_model_info_markdown(current_value, True)
+                show_all_checkbox_update = gr.Checkbox.update(value=current_user_pref_show_all, interactive=True)
+            else:
+                # Unauthenticated User
+                model_dropdown_update = gr.Dropdown.update(choices=UNAUTHENTICATED_MODEL_CHOICES, value=UNAUTHENTICATED_DEFAULT_MODEL_ID, label="Select Model (Free Tier)", interactive=True)
+                accordion_update = gr.Accordion.update(visible=False)
+                model_info_text_update = get_model_info_markdown(UNAUTHENTICATED_DEFAULT_MODEL_ID, False)
+                show_all_checkbox_update = gr.Checkbox.update(value=False, interactive=False)
             
-            # Create markdown
-            return f"""**Current Model**: {model_name}  
-                   **Estimated cost per 100 Images**: {cost}"""
-                
-        # Connect checkbox to toggle model choices
-        show_all_models.change(
-            fn=toggle_models,
-            inputs=[show_all_models, model_choice, is_authenticated],
-            outputs=[model_choice]
-        )
-        
-        # Connect model selection to update info
-        model_choice.change(
-            fn=update_model_info,
-            inputs=[model_choice],
-            outputs=[model_info]
+            return is_authorized, model_dropdown_update, accordion_update, model_info_text_update, show_all_checkbox_update
+
+        demo.load(
+            fn=handle_auth_change_and_ui_setup,
+            inputs=[user_show_all_models_preference_state], # Pass the state that holds user's preference
+            outputs=[
+                auth_status_state,
+                model_choice,
+                advanced_settings_accordion,
+                model_info,
+                show_all_models_checkbox
+            ]
         )
         
-        # Handle file uploads
-        def handle_upload(files, current_paths, current_filenames):
-            file_paths = []
-            file_names = []
-            if files:
-                for file in files:
-                    file_paths.append(file.name)
-                    file_names.append(get_base_filename(file.name))
-            return file_paths, file_paths, file_names, 0, None, "0 of 0", "Upload images and click 'Generate Alt-Text'."
+        # Function to update UI based on authentication status (called on demo.load)
+        def handle_auth_change_and_ui_setup(profile: gr.OAuthProfile | None, current_user_pref_show_all: bool):
+            is_authorized = check_authorization(profile)
+            
+            if is_authorized:
+                # Authorized User
+                current_choices = list(all_models_list) if current_user_pref_show_all else list(preferred_models)
+                current_value = AUTHENTICATED_DEFAULT_MODEL_ID # Reset to default for authed user
+                # You could add logic here to try and preserve model_choice.value if it's valid in current_choices
+
+                model_dropdown_update = gr.Dropdown.update(choices=current_choices, value=current_value, label="Select Model", interactive=True)
+                accordion_update = gr.Accordion.update(visible=True)
+                model_info_text_update = get_model_info_markdown(current_value, True)
+                show_all_checkbox_update = gr.Checkbox.update(value=current_user_pref_show_all, interactive=True)
+            else:
+                # Unauthenticated User
+                model_dropdown_update = gr.Dropdown.update(choices=UNAUTHENTICATED_MODEL_CHOICES, value=UNAUTHENTICATED_DEFAULT_MODEL_ID, label="Select Model (Free Tier)", interactive=True)
+                accordion_update = gr.Accordion.update(visible=False)
+                model_info_text_update = get_model_info_markdown(UNAUTHENTICATED_DEFAULT_MODEL_ID, False)
+                show_all_checkbox_update = gr.Checkbox.update(value=False, interactive=False)
+            
+            return is_authorized, model_dropdown_update, accordion_update, model_info_text_update, show_all_checkbox_update
 
-        upload_button.upload(
-            fn=handle_upload,
-            inputs=[upload_button, image_state, filename_state],
-            outputs=[input_gallery, image_state, filename_state,
-                     current_index, current_image, image_counter, analysis_text]
+        demo.load(
+            fn=handle_auth_change_and_ui_setup,
+            inputs=[user_show_all_models_preference_state], # Pass the state that holds user's preference
+            outputs=[
+                auth_status_state,
+                model_choice,
+                advanced_settings_accordion,
+                model_info,
+                show_all_models_checkbox
+            ]
         )
 
-        # Analyze images
-        def analyze_images(image_paths, model_choice, length_choice, filenames, content_type_choice):
-            if not image_paths:
-                return [], [], 0, None, "0 of 0", "No images uploaded to analyze.", None
-
-            is_photography = content_type_choice == "Photography"
-            sys_prompt = get_sys_prompt(length_choice, photograph=is_photography)
-            image_results = []
-            analysis_progress = gr.Progress(track_tqdm=True)
-
-            for i, image_path in enumerate(analysis_progress.tqdm(image_paths, desc="Analyzing Images")):
-                image_id = filenames[i] if i < len(filenames) and filenames[i] else f"Image_{i+1}_{os.path.basename(image_path)}"
-                try:
-                    img = Image.open(image_path)
-                    prompt0 = prompt_new()
-                    model_name = model_choice
-                    client_to_use = OR # Default client
-
-                    result = client_to_use.generate_caption(
-                        img, model=model_name, max_image_size=512,
-                        prompt=prompt0, prompt_dev=sys_prompt, temperature=1
-                    )
-                    image_results.append({"image_id": image_id, "content": result.strip()})
-                except FileNotFoundError:
-                     error_message = f"Error: File not found at path '{image_path}'"
-                     print(error_message)
-                     image_results.append({"image_id": image_id, "content": error_message})
-                except Exception as e:
-                    error_message = f"Error processing {image_id}: {str(e)}"
-                    print(error_message)
-                    image_results.append({"image_id": image_id, "content": error_message})
-
-            csv_path = create_csv_file_simple(image_results)
-            initial_image = image_paths[0] if image_paths else None
-            initial_counter = f"1 of {len(image_paths)}" if image_paths else "0 of 0"
-            initial_text = image_results[0]["content"] if image_results else "Analysis complete, but no results generated."
-
-            return (image_paths, image_results, 0, initial_image, initial_counter,
-                    initial_text, csv_path)
-
         # Navigate previous
         def go_to_prev(current_idx, images, results):
             if not images or not results or len(images) == 0:
@@ -482,4 +373,5 @@ def create_demo():
 # Launch the app
 if __name__ == "__main__":
     app = create_demo()
-    app.launch()
+    auth_list_for_gradio = [(user, "password") for user in AUTHORIZED_USER_IDS]
+    app.launch(auth=auth_list_for_gradio)