Update app.py

app.py

@@ -25,7 +25,12 @@ def get_json_data(url: str) -> Optional[Dict[str, Any]]:
         if url.isdigit():
             model_id = url
         else:
-            return None
+            # Check if it's a slugified URL without /models/ part
+            match = re.search(r'(\d+)(?:/[^/]+)?$', url)
+            if match:
+                model_id = match.group(1)
+            else:
+                return None
     else:
         model_id = url_split[4]
         
@@ -83,16 +88,18 @@ def extract_info(json_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
         "SD 2.1 768": "stabilityai/stable-diffusion-2-1", "SD 2.0 768": "stabilityai/stable-diffusion-2",
         "SD 3": "stabilityai/stable-diffusion-3-medium-diffusers",
         "SD 3.5": "stabilityai/stable-diffusion-3-medium",
-        "SD 3.5 Large": "stabilityai/stable-diffusion-3-medium", # Adjusted to medium as large might not be public LoRA base
+        "SD 3.5 Large": "stabilityai/stable-diffusion-3-medium",
         "SD 3.5 Medium": "stabilityai/stable-diffusion-3-medium",
-        "SD 3.5 Large Turbo": "stabilityai/stable-diffusion-3-medium-turbo", # Placeholder
+        "SD 3.5 Large Turbo": "stabilityai/stable-diffusion-3-medium-turbo",
         "Flux.1 D": "black-forest-labs/FLUX.1-dev", "Flux.1 S": "black-forest-labs/FLUX.1-schnell",
         "LTXV": "Lightricks/LTX-Video-0.9.7-dev",
-        "Hunyuan Video": "hunyuanvideo-community/HunyuanVideo", # Default T2V
+        "Hunyuan Video": "hunyuanvideo-community/HunyuanVideo",
         "Wan Video 1.3B t2v": "Wan-AI/Wan2.1-T2V-1.3B-Diffusers",
         "Wan Video 14B t2v": "Wan-AI/Wan2.1-T2V-14B-Diffusers",
         "Wan Video 14B i2v 480p": "Wan-AI/Wan2.1-I2V-14B-480P-Diffusers",
         "Wan Video 14B i2v 720p": "Wan-AI/Wan2.1-I2V-14B-720P-Diffusers",
+        "Pony": "SG161222/RealVisXL_V4.0",
+        "Illustrious": "artificialguybr/LogoRedmond", # Example, could be "stabilityai/stable-diffusion-xl-base-1.0"
     }
 
     for model_version in json_data.get("modelVersions", []):
@@ -114,18 +121,17 @@ def extract_info(json_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
             
             if not primary_file_found: continue
 
-            for media_data in model_version.get("images", []): # CivitAI uses 'images' for both images and videos
+            for media_data in model_version.get("images", []):
                 if media_data.get("nsfwLevel", 0) > 5: continue
                 
-                media_url_parts = media_data["url"].split("/")
-                if not media_url_parts: continue
+                media_url_parts = media_data.get("url","").split("/") # Add default "" for url
+                if not media_url_parts or not media_url_parts[-1]: continue # Ensure URL and filename part exist
                 
                 filename_part = media_url_parts[-1]
-                # Robustly extract ID: try to get it before the first dot or before query params
                 id_candidate = filename_part.split(".")[0].split("?")[0]
                 
                 prompt, negative_prompt = "", ""
-                if media_data.get("hasMeta", False) and media_data.get("type") == "image": # Prompts mainly for images
+                if media_data.get("hasMeta", False) and media_data.get("type") == "image":
                     if id_candidate.isdigit():
                         try:
                             prompt, negative_prompt = get_prompts_from_image(int(id_candidate))
@@ -143,12 +149,15 @@ def extract_info(json_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                     "is_video": is_video_file
                 })
             
-            # Ensure 'allowCommercialUse' is processed correctly
-            allow_commercial_use = json_data.get("allowCommercialUse", "Sell") # Default
-            if isinstance(allow_commercial_use, list):
-                allow_commercial_use = allow_commercial_use[0] if allow_commercial_use else "Sell"
-            elif not isinstance(allow_commercial_use, str): # If boolean or other, convert to expected string
-                 allow_commercial_use = "Sell" if allow_commercial_use else "None"
+            allow_commercial_use_raw = json_data.get("allowCommercialUse", "Sell")
+            if isinstance(allow_commercial_use_raw, list):
+                allow_commercial_use_processed = allow_commercial_use_raw[0] if allow_commercial_use_raw else "Sell"
+            elif isinstance(allow_commercial_use_raw, bool):
+                allow_commercial_use_processed = "Sell" if allow_commercial_use_raw else "None"
+            elif isinstance(allow_commercial_use_raw, str):
+                allow_commercial_use_processed = allow_commercial_use_raw
+            else: # Fallback for unexpected types
+                allow_commercial_use_processed = "Sell"
 
 
             info_dict = {
@@ -160,7 +169,7 @@ def extract_info(json_data: Dict[str, Any]) -> Optional[Dict[str, Any]]:
                 "creator": json_data.get("creator", {}).get("username", "Unknown Creator"),
                 "tags": json_data.get("tags", []),
                 "allowNoCredit": json_data.get("allowNoCredit", True),
-                "allowCommercialUse": allow_commercial_use,
+                "allowCommercialUse": allow_commercial_use_processed,
                 "allowDerivatives": json_data.get("allowDerivatives", True),
                 "allowDifferentLicense": json_data.get("allowDifferentLicense", True)
             }
@@ -171,24 +180,21 @@ def download_file_from_url(url: str, filename: str, folder: str = "."):
     headers = {}
     local_filepath = os.path.join(folder, filename)
     try:
-        # Add a User-Agent to mimic a browser, as some CDNs might block default requests User-Agent
         headers['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        if "CIVITAI_API_TOKEN" in os.environ and os.environ["CIVITAI_API_TOKEN"]: # Check for token existence and value
-            headers['Authorization'] = f'Bearer {os.environ["CIVITAI_API_TOKEN"]}'
+        civitai_token = os.environ.get("CIVITAI_API_TOKEN")
+        if civitai_token:
+            headers['Authorization'] = f'Bearer {civitai_token}'
         
-        response = requests.get(url, headers=headers, stream=True, timeout=120) # Increased timeout
+        response = requests.get(url, headers=headers, stream=True, timeout=120)
         response.raise_for_status()
 
         with open(local_filepath, 'wb') as f:
             for chunk in response.iter_content(chunk_size=8192):
                 f.write(chunk)
-        # print(f"Successfully downloaded {filename} to {folder}")
 
     except requests.exceptions.HTTPError as e_http:
-        # If 401/403 and no token was used, it's a clear auth issue.
-        # If token was used and still 401/403, token might be invalid or insufficient.
-        if e_http.response.status_code in [401, 403] and not headers.get('Authorization'):
-            print(f"Authorization error downloading {url}. Consider setting CIVITAI_API_TOKEN for restricted files.")
+        if e_http.response.status_code in [401, 403] and not headers.get('Authorization') and not civitai_token:
+            print(f"Authorization error (401/403) downloading {url}. Consider setting CIVITAI_API_TOKEN for restricted files.")
         raise gr.Error(f"HTTP Error downloading {filename}: {e_http.response.status_code} {e_http.response.reason}. URL: {url}")
     except requests.exceptions.RequestException as e_req:
         raise gr.Error(f"Request Error downloading {filename}: {e_req}. URL: {url}")
@@ -199,13 +205,11 @@ def download_files(info: Dict[str, Any], folder: str = ".") -> Dict[str, List[An
     downloaded_weights: List[str] = []
 
     for item in info["urls_to_download"]:
-        filename_to_save = item["filename"]
-        
-        # Sanitize filename (though os.path.basename usually handles paths well)
-        filename_to_save = re.sub(r'[<>:"/\\|?*]', '_', filename_to_save) # Basic sanitization
-        if not filename_to_save: # Handle case where filename becomes empty
-            filename_to_save = f"downloaded_file_{uuid.uuid4().hex[:8]}" + os.path.splitext(item["url"])[1]
-
+        filename_to_save_raw = item["filename"]
+        filename_to_save = re.sub(r'[<>:"/\\|?*]', '_', filename_to_save_raw)
+        if not filename_to_save:
+            base, ext = os.path.splitext(item["url"])
+            filename_to_save = f"downloaded_file_{uuid.uuid4().hex[:8]}{ext if ext else '.bin'}"
 
         gr.Info(f"Downloading {filename_to_save}...")
         download_file_from_url(item["url"], filename_to_save, folder)
@@ -266,12 +270,16 @@ def create_readme(info: Dict[str, Any], downloaded_files: Dict[str, List[Any]],
     if is_video_model:
         default_tags.append("video")
         default_tags.append("image-to-video" if is_i2v_model else "text-to-video")
-        default_tags.append("template:video-lora") # Added a template tag for video
+        default_tags.append("template:video-lora")
     else:
         default_tags.extend(["text-to-image", "stable-diffusion", "template:sd-lora"])
 
-    civit_tags = [t.replace(":", "").strip() for t in info.get("tags", []) if t.replace(":", "").strip() and t.replace(":", "").strip() not in default_tags]
-    tags = default_tags + civit_tags
+    civit_tags_raw = info.get("tags", [])
+    civit_tags_processed = []
+    if isinstance(civit_tags_raw, list):
+        civit_tags_processed = [str(t).replace(":", "").strip() for t in civit_tags_raw if str(t).replace(":", "").strip() and str(t).replace(":", "").strip() not in default_tags]
+
+    tags = default_tags + civit_tags_processed
     unpacked_tags = "\n- ".join(sorted(list(set(tags))))
     
     trained_words = [word for word in info.get('trainedWords', []) if word]
@@ -283,16 +291,24 @@ def create_readme(info: Dict[str, Any], downloaded_files: Dict[str, List[Any]],
     if not media_items_for_widget:
         widget_content = "# No example media available for widget.\n"
     else:
-        for media_item in media_items_for_widget[:5]: # Limit to 5 examples for widget
-            prompt = media_item["prompt"]
-            negative_prompt = media_item["negative_prompt"]
+        for media_item in media_items_for_widget[:5]:
+            prompt_text = media_item["prompt"]
+            negative_prompt_text = media_item["negative_prompt"]
             filename = media_item["filename"]
             
-            escaped_prompt = prompt.replace("'", "''").replace("\n", " ") # Escape and remove newlines
-            negative_prompt_content = f"""parameters:
-    negative_prompt: '{negative_prompt.replace("'", "''").replace("\n", " ")}'""" if negative_prompt else ""
+            escaped_prompt = prompt_text.replace("'", "''").replace("\n", " ")
+            
+            negative_prompt_cleaned_and_escaped = ""
+            if negative_prompt_text:
+                 negative_prompt_cleaned_and_escaped = negative_prompt_text.replace("'", "''").replace("\n", " ") # Correct
+            
+            negative_prompt_widget_entry = ""
+            if negative_prompt_cleaned_and_escaped: # Only add if non-empty
+                negative_prompt_widget_entry = f"""parameters:
+    negative_prompt: '{negative_prompt_cleaned_and_escaped}'"""
+
             widget_content += f"""- text: '{escaped_prompt if escaped_prompt else ' ' }'
-  {negative_prompt_content}
+  {negative_prompt_widget_entry}
   output:
     url: >-
       {filename}
@@ -301,18 +317,18 @@ def create_readme(info: Dict[str, Any], downloaded_files: Dict[str, List[Any]],
     dtype = "torch.bfloat16" if info["baseModel"] in flux_models_bf16 else "torch.float16"
         
     pipeline_import = "AutoPipelineForText2Image"
-    pipeline_call_example = f"image = pipeline('{formatted_words if formatted_words else 'Your custom prompt'}').images[0]"
     example_prompt_for_pipeline = formatted_words if formatted_words else 'Your custom prompt'
     if media_items_for_widget and media_items_for_widget[0]["prompt"]:
         example_prompt_for_pipeline = media_items_for_widget[0]["prompt"]
-    pipeline_call_example = f"image = pipeline('{example_prompt_for_pipeline.replace ciclo '','' ')').images[0]"
-
+    
+    cleaned_example_pipeline_prompt = example_prompt_for_pipeline.replace("'", "\\'").replace("\n", " ")
+    pipeline_call_example = f"image = pipeline('{cleaned_example_pipeline_prompt}').images[0]"
 
     if is_video_model:
         pipeline_import = "DiffusionPipeline" 
-        video_prompt_example = example_prompt_for_pipeline
+        video_prompt_example = cleaned_example_pipeline_prompt
         
-        pipeline_call_example = f"# Example prompt for video generation\nprompt = \"{video_prompt_example.replace ciclico '','' ')}\"\n"
+        pipeline_call_example = f"# Example prompt for video generation\nprompt = \"{video_prompt_example}\"\n"
         pipeline_call_example += "# Adjust parameters like num_frames, num_inference_steps, height, width as needed for the specific pipeline.\n"
         pipeline_call_example += "# video_frames = pipeline(prompt, num_frames=16, guidance_scale=7.5, num_inference_steps=25).frames # Example parameters"
         if "LTX-Video" in info["baseModel"]:
@@ -341,14 +357,18 @@ pipeline.to(device)
 # Load LoRA weights
 pipeline.load_lora_weights('{user_repo_id}', weight_name='{weight_name}')
 
-# For some pipelines, you might need to fuse LoRA layers:
-# pipeline.fuse_lora() # or pipeline.unfuse_lora()
+# For some pipelines, you might need to fuse LoRA layers before inference
+# and unfuse them after, or apply scaling. Check model card.
+# Example: pipeline.fuse_lora() or pipeline.set_adapters(["default"], adapter_weights=[0.8])
 
 # Example generation call (adjust parameters as needed for the specific pipeline)
 {pipeline_call_example}
+
+# If using fused LoRA:
+# pipeline.unfuse_lora()
 ```"""
     
-    commercial_use_val = info["allowCommercialUse"] # Already processed in extract_info
+    commercial_use_val = info["allowCommercialUse"]
     
     content = f"""---
 license: other
@@ -386,7 +406,6 @@ For more details, including weighting, merging and fusing LoRAs, check the [docu
     readme_path = os.path.join(folder, "README.md")
     with open(readme_path, "w", encoding="utf-8") as file:
         file.write(content)
-    # print(f"README.md created at {readme_path}")
 
 
 # --- Hugging Face Profile / Authorship ---
@@ -438,14 +457,15 @@ def check_civit_link(profile_state: Optional[gr.OAuthProfile], url_input: str):
 
     try:
         info, _ = process_url(url_input, profile_state, do_download=False)
-        if not info:
-             return "Could not process this CivitAI URL. Model might be unsupported.", gr.update(interactive=False), gr.update(visible=True), gr.update(visible=False)
-    except gr.Error as e:
-        return str(e), gr.update(interactive=False), gr.update(visible=True), gr.update(visible=False)
-    except Exception as e:
-        print(f"Unexpected error in check_civit_link: {e}\n{traceback.format_exc()}")
-        return f"An unexpected error occurred: {str(e)}", gr.update(interactive=False), gr.update(visible=True), gr.update(visible=False)
-
+        if not info: # Should be caught by process_url, but as a safeguard
+             return "Could not process this CivitAI URL. Model might be unsupported or invalid.", gr.update(interactive=False, visible=True), gr.update(visible=False), gr.update(visible=False)
+    except gr.Error as e: # Catch errors from process_url (like NSFW, unsupported, API fetch failed)
+        return str(e), gr.update(interactive=False, visible=True), gr.update(visible=False), gr.update(visible=False)
+    except Exception as e: # Catch any other unexpected error during processing check
+        print(f"Unexpected error in check_civit_link during process_url: {e}\n{traceback.format_exc()}")
+        return f"An unexpected error occurred: {str(e)}", gr.update(interactive=False, visible=True), gr.update(visible=False), gr.update(visible=False)
+
+    # If model is processable, then check authorship
     civitai_creator_username = info['creator']
     hf_username_on_civitai = extract_huggingface_username(civitai_creator_username)
     
@@ -459,7 +479,7 @@ def check_civit_link(profile_state: Optional[gr.OAuthProfile], url_input: str):
             f'Example: <br/><img width="60%" src="https://i.imgur.com/hCbo9uL.png" alt="CivitAI profile settings example"/><br/>'
             f'(If you are not "{civitai_creator_username}", you cannot submit their model at this time.)'
         )
-        return no_username_text, gr.update(interactive=False, visible=False), gr.update(visible=True), gr.update(visible=False) # Hide upload, show try_again
+        return no_username_text, gr.update(interactive=False, visible=False), gr.update(visible=True), gr.update(visible=False)
     
     if profile_state.username.lower() != hf_username_on_civitai.lower():
         unmatched_username_text = (
@@ -468,17 +488,16 @@ def check_civit_link(profile_state: Optional[gr.OAuthProfile], url_input: str):
             f'Please update it on <a href="https://civitai.com/user/account" target="_blank">CivitAI</a> or log in to Hugging Face as "{hf_username_on_civitai}".<br/>'
             f'<img src="https://i.imgur.com/hCbo9uL.png" alt="CivitAI profile settings example"/>'
         )
-        return unmatched_username_text, gr.update(interactive=False, visible=False), gr.update(visible=True), gr.update(visible=False) # Hide upload, show try_again
+        return unmatched_username_text, gr.update(interactive=False, visible=False), gr.update(visible=True), gr.update(visible=False)
     
-    return f'Authorship verified for "{civitai_creator_username}" (🤗 {profile_state.username}). Ready to upload!', gr.update(interactive=True, visible=True), gr.update(visible=False), gr.update(visible=True) # Show upload, hide try_again
+    return f'Authorship verified for "{civitai_creator_username}" (🤗 {profile_state.username}). Ready to upload!', gr.update(interactive=True, visible=True), gr.update(visible=False), gr.update(visible=True)
 
-def handle_auth_change(profile: Optional[gr.OAuthProfile]):
-    # This function is called by demo.load when auth state changes
-    # It updates the visibility of UI areas and clears inputs.
+def handle_auth_change_and_update_state(profile: Optional[gr.OAuthProfile]):
+    # This function now returns the profile to update the state
     if profile: # Logged in
-        return gr.update(visible=False), gr.update(visible=True), "", gr.update(value=""), gr.update(interactive=False, visible=False), gr.update(visible=False)
+        return profile, gr.update(visible=False), gr.update(visible=True), "", gr.update(value=""), gr.update(interactive=False, visible=False), gr.update(visible=False)
     else: # Logged out
-        return gr.update(visible=True), gr.update(visible=False), "", gr.update(value=""), gr.update(interactive=False, visible=False), gr.update(visible=False)
+        return None, gr.update(visible=True), gr.update(visible=False), "", gr.update(value=""), gr.update(interactive=False, visible=False), gr.update(visible=False)
 
 def show_output_area():
     return gr.update(visible=True)
@@ -486,19 +505,18 @@ def show_output_area():
 def list_civit_models(username: str) -> str:
     if not username.strip(): return ""
     
-    url = f"https://civitai.com/api/v1/models?username={username}&limit=100&sort=Newest"
+    url = f"https://civitai.com/api/v1/models?username={username}&limit=100&sort=Newest" # Max limit is 100 per page on CivitAI
     json_models_list = []
-    page_count, max_pages = 0, 5 # Limit pages
+    page_count, max_pages = 0, 1 # Limit to 1 page (100 models) for now to be quicker, can be increased
 
     gr.Info(f"Fetching LoRAs for CivitAI user: {username}...")
     while url and page_count < max_pages:
         try:
-            response = requests.get(url, timeout=10)
+            response = requests.get(url, timeout=15) # Increased timeout
             response.raise_for_status()
             data = response.json()
             
             current_items = data.get('items', [])
-            # Filter for LORAs and ensure they have a name for slugify
             json_models_list.extend(item for item in current_items if item.get("type") == "LORA" and item.get("name"))
 
             metadata = data.get('metadata', {})
@@ -529,7 +547,6 @@ def upload_civit_to_hf(profile: Optional[gr.OAuthProfile], oauth_token_obj: gr.O
     hf_auth_token = oauth_token_obj.token
     
     folder_uuid = str(uuid.uuid4())
-    # Create a unique subfolder in a general 'temp_uploads' directory
     base_temp_dir = "temp_uploads"
     os.makedirs(base_temp_dir, exist_ok=True)
     folder_path = os.path.join(base_temp_dir, folder_uuid)
@@ -540,16 +557,20 @@ def upload_civit_to_hf(profile: Optional[gr.OAuthProfile], oauth_token_obj: gr.O
     try:
         info, downloaded_data = process_url(url, profile, do_download=True, folder=folder_path)
         if not info or not downloaded_data:
+            # process_url should raise gr.Error, but this is a fallback.
             raise gr.Error("Failed to process URL or download files after initial checks.")
 
         slug_name = slugify(info["name"])
         user_repo_id = f"{profile.username}/{slug_name}"
         
-        is_author = False # Default
-        hf_username_on_civitai = extract_huggingface_username(info["creator"])
+        is_author = False
+        # Re-verify authorship just before upload, using info from processed model
+        civitai_creator_username_from_model = info.get('creator', 'Unknown Creator')
+        hf_username_on_civitai = extract_huggingface_username(civitai_creator_username_from_model)
+        
         if profile.username in TRUSTED_UPLOADERS or \
            (hf_username_on_civitai and profile.username.lower() == hf_username_on_civitai.lower()):
-            is_author = True # Or at least authorized to upload as/for them
+            is_author = True
         
         create_readme(info, downloaded_data, user_repo_id, link_civit_checkbox_val, is_author=is_author, folder=folder_path)
         
@@ -573,11 +594,9 @@ def upload_civit_to_hf(profile: Optional[gr.OAuthProfile], oauth_token_obj: gr.O
         print(f"Error during Hugging Face repo operations for {url}: {e}\n{traceback.format_exc()}")
         raise gr.Error(f"Upload failed for {url}: {str(e)}. Token might be expired. Try re-logging or check server logs.")
     finally:
-        # Cleanup local folder
         try:
             if os.path.exists(folder_path):
                 shutil.rmtree(folder_path)
-                # print(f"Cleaned up temporary folder: {folder_path}")
         except Exception as e_clean:
             print(f"Error cleaning up folder {folder_path}: {e_clean}")
 
@@ -597,14 +616,13 @@ def bulk_upload(profile: Optional[gr.OAuthProfile], oauth_token_obj: gr.OAuthTok
     for i, url in enumerate(urls):
         gr.Info(f"Processing model {i+1}/{total_urls}: {url}")
         try:
-            # Each call to upload_civit_to_hf will handle its own folder creation/cleanup
             result_message = upload_civit_to_hf(profile, oauth_token_obj, url, link_civit_checkbox_val)
             upload_results.append(result_message)
             gr.Info(f"Successfully processed {url}")
-        except gr.Error as ge:
+        except gr.Error as ge: # Catch Gradio specific errors to display them
             gr.Warning(f"Skipping model {url} due to error: {str(ge)}")
             upload_results.append(f"Failed to upload {url}: {str(ge)}")
-        except Exception as e:
+        except Exception as e: # Catch any other unhandled exception
             gr.Warning(f"Unhandled error uploading model {url}: {str(e)}")
             upload_results.append(f"Failed to upload {url}: Unhandled exception - {str(e)}")
             print(f"Unhandled exception during bulk upload for {url}: {e}\n{traceback.format_exc()}")
@@ -619,21 +637,20 @@ css = '''
 .gr-html ol { list-style-type: decimal; margin-left: 20px; }
 .gr-html a { color: #007bff; text-decoration: underline; }
 .gr-html img { max-width: 100%; height: auto; margin-top: 5px; margin-bottom: 5px; border: 1px solid #ddd; }
+#instructions_area { padding: 10px; border: 1px solid #eee; border-radius: 5px; margin-top: 10px; background-color: #f9f9f9; }
 '''
 
 with gr.Blocks(css=css, title="CivitAI to Hugging Face LoRA Uploader") as demo:
-    # States to hold authentication info globally within the Blocks context
-    auth_profile_state = gr.State()
-    # oauth_token_state = gr.State() # Token string will be passed directly from gr.OAuthToken
+    auth_profile_state = gr.State() # Stores the gr.OAuthProfile object
 
     gr.Markdown('''# Upload your CivitAI LoRA to Hugging Face 🤗
 By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free GPU-based Inference Widget, you'll be listed in [LoRA Studio](https://lorastudio.co/models) after a short review, and get the possibility to submit your model to the [LoRA the Explorer](https://huggingface.co/spaces/multimodalart/LoraTheExplorer) ✨
     ''')
     
     with gr.Row(elem_id="login_button_area"):
-        login_button = gr.LoginButton() # Default uses HF OAuth
+        # LoginButton updates auth_profile_state via the .then() chain on demo.load
+        login_button = gr.LoginButton() 
 
-    # This column is visible when the user is NOT logged in
     with gr.Column(visible=True, elem_id="disabled_upload_area") as disabled_area:
         gr.HTML("<h3>Please log in with Hugging Face to enable uploads.</h3>")
         gr.Textbox(
@@ -642,7 +659,6 @@ By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free
             interactive=False 
         )
 
-    # This column is visible when the user IS logged in
     with gr.Column(visible=False) as enabled_area:
         gr.HTML("<h3 style='color:green;'>Logged in! You can now upload models.</h3>")
         
@@ -653,17 +669,15 @@ By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free
                     label="CivitAI Model URL or ID",
                     info="Enter the full URL or just the numeric ID of the CivitAI LoRA model page.",
                 )
-                instructions_html = gr.HTML(elem_id="instructions_area")
-                
+                instructions_html = gr.HTML(elem_id="instructions_area") # For feedback
                 try_again_button = gr.Button("I've updated my CivitAI profile (Re-check Authorship)", visible=False)
-                
                 link_civit_checkbox_single = gr.Checkbox(label="Add a link back to CivitAI in the README?", value=True, visible=True)
                 submit_button_single_model = gr.Button("Upload This Model to Hugging Face", interactive=False, visible=False, variant="primary")
 
             with gr.TabItem("Bulk Upload"):
                 civit_username_to_bulk = gr.Textbox(
                     label="Your CivitAI Username (Optional)",
-                    info="Enter your CivitAI username to auto-populate the list below with your LoRAs (up to 50 newest)."
+                    info="Enter your CivitAI username to auto-populate the list below with your LoRAs (up to 100 newest)."
                 )
                 submit_bulk_civit_urls = gr.Textbox(
                     label="CivitAI Model URLs or IDs (One per line)",
@@ -676,41 +690,23 @@ By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free
         output_markdown_area = gr.Markdown(label="Upload Progress & Results", visible=False)
 
     # --- Event Handlers Wiring ---
-    
-    # Handle login/logout and initial load
-    # login_button.login() or logout() implicitly triggers demo.load()
-    # The .load event is triggered when the Gradio app starts or when login/logout happens.
-    # It receives profile and token from the gr.LoginButton's state.
-    # Inputs to handle_auth_change must match how gr.LoginButton provides them.
-    # LoginButton provides profile (OAuthProfile) and token (OAuthToken)
-    # These are implicitly passed to the function called by demo.load if it's the only .load.
-    # Using gr.State() for auth_profile_state.
-    
-    # This demo.load will be triggered by login/logout from gr.LoginButton
-    # and also on initial page load.
+    # This demo.load is triggered by login/logout from gr.LoginButton (which is a client-side component that calls this on auth change)
+    # and also on initial page load (where profile will be None if not logged in via cookies).
+    # The first input to demo.load for LoginButton is the profile.
     demo.load(
-        fn=handle_auth_change,
-        inputs=[auth_profile_state], # Pass the state which will be updated by login
-        outputs=[disabled_area, enabled_area, instructions_html, submit_source_civit_enabled, submit_button_single_model, try_again_button],
-        api_name=False, queue=False
-    ).then(
-        # After login/logout, update the auth_profile_state
-        # This is a bit of a workaround to get profile into a state for other functions
-        lambda profile: profile, # Identity function
-        inputs=[gr.Variable()], # This will receive the profile from LoginButton
-        outputs=[auth_profile_state],
+        fn=handle_auth_change_and_update_state,
+        inputs=gr.Variable(), # This will receive the profile from LoginButton
+        outputs=[auth_profile_state, disabled_area, enabled_area, instructions_html, submit_source_civit_enabled, submit_button_single_model, try_again_button],
         api_name=False, queue=False
     )
     
-    # When CivitAI URL changes (in the enabled area)
     submit_source_civit_enabled.change(
         fn=check_civit_link, 
         inputs=[auth_profile_state, submit_source_civit_enabled], 
-        outputs=[instructions_html, submit_button_single_model, try_again_button, submit_button_single_model],
+        outputs=[instructions_html, submit_button_single_model, try_again_button, submit_button_single_model], # submit_button_single_model is repeated to control both interactivity and visibility
         api_name=False 
     )
 
-    # When "Try Again" button is clicked
     try_again_button.click(
         fn=check_civit_link, 
         inputs=[auth_profile_state, submit_source_civit_enabled], 
@@ -718,15 +714,13 @@ By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free
         api_name=False
     )
     
-    # When CivitAI username for bulk input changes
-    civit_username_to_bulk.submit( # Use .submit for when user presses Enter or blurs
+    civit_username_to_bulk.submit(
         fn=list_civit_models, 
         inputs=[civit_username_to_bulk], 
         outputs=[submit_bulk_civit_urls],
         api_name=False
     )
     
-    # Single model upload button
     submit_button_single_model.click(
         fn=show_output_area, inputs=[], outputs=[output_markdown_area], api_name=False
     ).then(
@@ -736,7 +730,6 @@ By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free
         api_name="upload_single_model"
     )
     
-    # Bulk model upload button
     bulk_upload_button.click(
         fn=show_output_area, inputs=[], outputs=[output_markdown_area], api_name=False
     ).then(
@@ -746,9 +739,14 @@ By uploading your LoRAs to Hugging Face you get diffusers compatibility, a free
         api_name="upload_bulk_models"
     )
 
-demo.queue(default_concurrency_limit=3, max_size=10) # Adjusted concurrency
+demo.queue(default_concurrency_limit=3, max_size=10)
 if __name__ == "__main__":
-    # For local testing, you might need to set COOKIE_INFO and CIVITAI_API_TOKEN
-    # os.environ["COOKIE_INFO"] = "your_civitai_cookie_string_here"
-    # os.environ["CIVITAI_API_TOKEN"] = "your_civitai_api_token_here_if_needed"
+    # For local testing, you might need to set these environment variables:
+    # os.environ["COOKIE_INFO"] = "your_civitai_session_cookie_here" # For creator verification
+    # os.environ["CIVITAI_API_TOKEN"] = "your_civitai_api_key_here"   # For potentially restricted downloads
+    # os.environ["GRADIO_SERVER_NAME"] = "0.0.0.0" # To make it accessible on local network
+    
+    # To enable OAuth locally, you might need to set HF_HUB_DISABLE_OAUTH_CHECKMESSAGES="1"
+    # and ensure your HF OAuth app is configured for http://localhost:7860 or http://127.0.0.1:7860
+    
     demo.launch(debug=True, share=os.environ.get("GRADIO_SHARE") == "true")