fix additional models

app.py

@@ -1,107 +1,130 @@
 import gradio as gr
 import os
 
-def check_access(request: gr.Request):
+# --- Configuration ---
+# In your Hugging Face Space settings, add a Secret named `AUTHORIZED_USER_IDS`.
+# The value should be a comma-separated string of the Hugging Face User IDs
+# that you want to grant "full access" to (e.g., "user_id_123,user_id_456").
+# You can find your Hugging Face User ID in your profile URL or settings.
+
+# IMPORTANT: This secret should be set in the Hugging Face Space settings, NOT hardcoded here.
+# We retrieve it using os.environ.get() which accesses the Space's environment variables/secrets.
+# Provide a default empty string for local testing where the secret won't exist.
+authorized_users_str = os.environ.get("AUTHORIZED_USER_IDS", "")
+AUTHORIZED_USER_IDS = set(authorized_users_str.split(','))
+
+# --- Application Logic ---
+
+def get_user_access_level(request: gr.Request):
     """
-    Checks if the user is logged in via HF OAuth and if they are authorized
-    for full access.
+    Checks the request object to determine if a user is logged in via HF OAuth
+    and their access level based on the AUTHORIZED_USER_IDS list.
     """
-    user_info = request.auth # request.auth contains user info if hf_oauth is enabled
+    user_info = request.auth # This contains user info if hf_oauth is enabled and user is logged in
 
     if user_info is None:
         # User is not logged in
-        return (
-            gr.update(visible=True),  # Show login prompt
-            gr.update(visible=False), # Hide full content
-            gr.update(visible=True),  # Show limited content
-            "Please sign in to check your access.",
-            "Not Logged In"
-        )
+        print("User not logged in.")
+        return {
+            "status_message": "Please sign in to see your access level and potentially unlock full features.",
+            "user_identity": "Not Logged In",
+            "show_login_prompt": gr.update(visible=True),
+            "show_limited_content": gr.update(visible=True),
+            "show_full_content": gr.update(visible=False)
+        }
     else:
-        # User is logged in, get their HF user ID
-        user_id = user_info.get('sub') # 'sub' is the standard claim for user ID in OpenID Connect
-        username = user_info.get('preferred_username', 'N/A') # Or use other claims like 'name', 'email'
+        # User is logged in, get their HF user ID and username
+        user_id = user_info.get('sub') # 'sub' is the standard claim for user ID
+        username = user_info.get('preferred_username', user_id) # Use username or ID as fallback
 
         print(f"Logged in user: Username={username}, ID={user_id}") # Log for debugging
 
-        if user_id in AUTHORIZED_USER_IDS:
+        if user_id in AUTHORIZED_USER_IDS and user_id != "": # Also check if user_id is not empty string from split(",")
             # User is authorized for full access
-            return (
-                gr.update(visible=False), # Hide login prompt
-                gr.update(visible=True),  # Show full content
-                gr.update(visible=False), # Hide limited content
-                f"Welcome, {username}! You have Full Access.",
-                f"Logged in as: {username} (ID: {user_id})"
-            )
+            print(f"User {user_id} is authorized for full access.")
+            return {
+                "status_message": f"Welcome, {username}! You have Full Access.",
+                "user_identity": f"Logged in as: {username} (ID: {user_id})",
+                "show_login_prompt": gr.update(visible=False),
+                "show_limited_content": gr.update(visible=False), # Hide limited content for full users
+                "show_full_content": gr.update(visible=True)
+            }
         else:
             # User is logged in but not authorized for full access
-            return (
-                gr.update(visible=False), # Hide login prompt
-                gr.update(visible=False), # Hide full content
-                gr.update(visible=True),  # Show limited content
-                f"Welcome, {username}. You have Limited Access.",
-                f"Logged in as: {username} (ID: {user_id})"
-            )
+            print(f"User {user_id} is logged in but not authorized.")
+            return {
+                "status_message": f"Welcome, {username}. You have Limited Access.",
+                "user_identity": f"Logged in as: {username} (ID: {user_id})",
+                "show_login_prompt": gr.update(visible=False),
+                "show_limited_content": gr.update(visible=True),
+                "show_full_content": gr.update(visible=False)
+            }
 
 # --- Gradio Interface ---
 
 with gr.Blocks() as demo:
-    # We'll use state to manage visibility based on access
-    login_prompt = gr.Markdown("### Sign in with Hugging Face to check your access.")
-    login_status_text = gr.Textbox(label="Status", interactive=False)
-
-    # The gr.LoginButton component initiates the HF OAuth flow
-    # This button itself doesn't need a click handler in this pattern;
-    # the check_access function runs on page load or other events.
-    # However, we can add a dummy event or rely on the initial load.
-    # For demonstration, we'll have the check happen on page load
-    # and re-check maybe with a button click if needed, but the
-    # primary check should handle the redirect return.
-    # A common pattern is to just rely on the state after redirect.
-
-    with gr.Column(visible=False) as limited_content:
+    gr.Markdown("# Hugging Face Spaces Tiered Access Example")
+
+    # Components to display status and user identity
+    status_message = gr.Markdown("Checking access status...")
+    user_identity_text = gr.Textbox(label="Logged In User Info", interactive=False)
+
+    # Placeholder for the Login Prompt (hidden if user is logged in)
+    with gr.Column(visible=False) as login_prompt_column:
+        gr.Markdown("### Please Sign in with Hugging Face")
+        gr.Markdown("*(A 'Sign in with Hugging Face' button will appear automatically above this section when deployed on HF Spaces with OAuth enabled)*")
+        # The actual login button is added by Hugging Face Spaces when hf_oauth: true is set in README.md
+
+    # Content for users with Limited Access (visible by default or for non-authorized users)
+    with gr.Column(visible=True) as limited_content_column:
         gr.Markdown("## Limited Access Content")
-        gr.Textbox(value="This is content available to all users (or non-authorized logged-in users).", interactive=False)
+        gr.Textbox(value="This is content visible to everyone or users with limited access.", interactive=False)
+        gr.Image("https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/welcome/hugging-face-logo.png", width=200)
+        gr.Markdown("*(Sign in and/or get authorized for more features!)*")
         # Add other limited features here
 
-    with gr.Column(visible=False) as full_content:
+    # Content for users with Full Access (only visible to authorized users)
+    with gr.Column(visible=False) as full_content_column:
         gr.Markdown("## Full Access Content")
-        gr.Textbox(value="🥳 This is special content for authorized users! 🥳", interactive=False)
+        gr.Textbox(value="🥳 Congratulations! You have unlocked the full version! 🥳", interactive=False)
+        gr.Video("https://huggingface.co/spaces/gradio/space-tourism/resolve/main/space-tourism.mp4")
+        gr.Markdown("*(This content is only for authorized accounts)*")
         # Add other full features here
 
-    # Initial check on page load is tricky with Blocks and redirects.
-    # A more reliable way is often to have a button that triggers the check
-    # after the potential redirect or on first load, or use a mechanism
-    # that runs logic on startup. For a simple example, let's add a check button.
-    # In a real app, the check_access logic might be called by a function
-    # that runs on initial page load or tied to a state change after login redirect.
-
-    # Let's simulate the check happening after potential login on page load
-    # by linking it to a component that is present from the start, or by
-    # calling the check function and updating outputs.
-    # Gradio often re-runs parts of the app logic after OAuth redirect.
-    # The outputs of check_access will update the visibility of components.
-
-    # A more robust pattern in Gradio might involve using the `load` event
-    # or triggering `check_access` via a component interaction that happens
-    # after the page loads and the request object is populated.
-    # For simplicity in a runnable example, let's trigger check_access
-    # with a button after the page is loaded and the user *might* have just logged in.
-    # In a production app, you'd want this check to happen automatically.
-
-    check_access_button = gr.Button("Check My Access Level") # Button to manually trigger check
-
-    check_access_button.click(
-        fn=check_access,
-        inputs=None, # The request object is implicitly available
-        outputs=[login_prompt, full_content, limited_content, login_status_text, login_status_text], # Update multiple outputs
-        api_name="check_access" # Give it an API name if needed
+    # This button triggers the check_access_level function.
+    # In a real application, you might want this check to happen
+    # automatically on page load or after the OAuth redirect.
+    # For demonstration purposes, a button makes the flow clear.
+    check_button = gr.Button("Check My Access Level")
+
+    # Link the button click to the access check function
+    # The outputs will update the visibility and text components
+    check_button.click(
+        fn=get_user_access_level,
+        inputs=None, # Request object is implicitly passed by Gradio
+        outputs=[
+            status_message,
+            user_identity_text,
+            login_prompt_column,
+            limited_content_column,
+            full_content_column
+        ]
+    )
+
+    # Initial check when the page loads (might need a small delay or specific trigger depending on HF/Gradio loading)
+    # A common pattern is to call a load function or rely on the button click after redirect.
+    # Let's add a load event to trigger the check immediately on page load attempt.
+    demo.load(
+        fn=get_user_access_level,
+        inputs=None,
+        outputs=[
+            status_message,
+            user_identity_text,
+            login_prompt_column,
+            limited_content_column,
+            full_content_column
+        ]
     )
 
-    # A more seamless approach in a real space would involve using Gradio's state
-    # and potentially calling check_access when the space state indicates a user is present.
-    # The gr.LoginButton handles the *initiation* of the login.
-    # The *result* of the login populates the request.auth object on subsequent interactions
-    # or potentially on page reload after redirect.
 
 demo.launch()