Update app.py

app.py

@@ -53,9 +53,36 @@ This app uses the FLUX.1-Fill-dev model which requires special access:
 # Try to get a Hugging Face token from environment variables
 def get_hf_token():
     # Check common environment variable names for HF tokens
-    for env_var in ['HF_TOKEN', 'HUGGINGFACE_TOKEN', 'HUGGING_FACE_HUB_TOKEN']:
-        if env_var in os.environ:
-            return os.environ[env_var]
+    token_env_vars = [
+        'HF_TOKEN', 
+        'HUGGINGFACE_TOKEN', 
+        'HUGGING_FACE_HUB_TOKEN',
+        'HF_API_TOKEN',
+        'HUGGINGFACE_API_TOKEN',
+        'HUGGINGFACE_HUB_TOKEN'
+    ]
+    
+    for env_var in token_env_vars:
+        if env_var in os.environ and os.environ[env_var].strip():
+            st.sidebar.success(f"Found token in {env_var}")
+            return os.environ[env_var].strip()
+    
+    # If we're here, no token was found
+    st.sidebar.warning("No Hugging Face token found in environment variables")
+    st.sidebar.info("Checking for cached credentials...")
+    
+    # Check if there's a cached token
+    try:
+        from huggingface_hub.constants import HF_TOKEN_PATH
+        if os.path.exists(HF_TOKEN_PATH):
+            with open(HF_TOKEN_PATH, "r") as f:
+                token = f.read().strip()
+                if token:
+                    st.sidebar.success("Found cached Hugging Face token")
+                    return token
+    except Exception as e:
+        st.sidebar.error(f"Error checking cached token: {str(e)}")
+    
     return None
 
 @st.cache_resource
@@ -73,29 +100,84 @@ def load_model():
         token = get_hf_token()
         
         st.info("Loading FLUX.1-Fill-dev model...")
+        st.info(f"Token available: {'Yes' if token else 'No'}")
         
-        # Try loading with token if available
-        if token:
-            model = FluxFillPipeline.from_pretrained(
-                "black-forest-labs/FLUX.1-Fill-dev", 
-                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                use_auth_token=token
-            )
-        else:
-            model = FluxFillPipeline.from_pretrained(
-                "black-forest-labs/FLUX.1-Fill-dev", 
-                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
-            )
+        try:
+            # Try loading with token if available
+            if token:
+                st.info("Attempting to load model with auth token...")
+                # Try the modern token parameter first
+                try:
+                    model = FluxFillPipeline.from_pretrained(
+                        "black-forest-labs/FLUX.1-Fill-dev", 
+                        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                        token=token,
+                        verbose=True
+                    )
+                except Exception as token_error:
+                    st.info(f"Trying with use_auth_token instead of token: {str(token_error)}")
+                    # Fall back to older parameter name
+                    model = FluxFillPipeline.from_pretrained(
+                        "black-forest-labs/FLUX.1-Fill-dev", 
+                        torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                        use_auth_token=token,
+                        verbose=True
+                    )
+            else:
+                st.info("Attempting to load model without auth token...")
+                model = FluxFillPipeline.from_pretrained(
+                    "black-forest-labs/FLUX.1-Fill-dev", 
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                    verbose=True  # Add verbose output
+                )
+            
+            st.success("Model loaded successfully!")
+            return model.to(device)
+        except Exception as detailed_error:
+            st.error(f"Detailed loading error: {str(detailed_error)}")
+            
+            # Try alternative approach - load with huggingface_hub directly
+            st.info("Trying alternative loading approach using huggingface_hub...")
+            try:
+                from huggingface_hub import login, HfApi
+                
+                if token:
+                    # First log in explicitly
+                    login(token)
+                    
+                    # Verify login worked and we have access
+                    api = HfApi()
+                    try:
+                        # Check if we can access the model
+                        model_info = api.model_info("black-forest-labs/FLUX.1-Fill-dev")
+                        st.info(f"Successfully authenticated and verified model access: {model_info.id}")
+                    except Exception as access_error:
+                        st.error(f"Authentication succeeded but access verification failed: {str(access_error)}")
                 
-        return model.to(device)
+                # Now try loading the model again (should use the login session)
+                model = FluxFillPipeline.from_pretrained(
+                    "black-forest-labs/FLUX.1-Fill-dev", 
+                    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
+                )
+                st.success("Successfully loaded model with alternative approach!")
+            except Exception as alt_error:
+                st.error(f"Alternative loading approach failed: {str(alt_error)}")
+                raise
+            
+            return model.to(device)
     except Exception as e:
         st.error(f"Error loading model: {str(e)}")
-        if "401 Client Error" in str(e):
+        if "401 Client Error" in str(e) or "401" in str(e) or "access" in str(e).lower() or "denied" in str(e).lower():
             st.error("""
             Access Denied: You need to:
             1. Request access to the model at https://huggingface.co/black-forest-labs/FLUX.1-Fill-dev
-            2. Make sure you've run 'huggingface-cli login' or set up the token in Spaces secrets
+            2. Set up your Hugging Face token in Spaces:
+               - Go to your Space settings > Secrets
+               - Add a new secret with name 'HF_TOKEN'
+               - Set its value to your Hugging Face API token
             3. Wait for approval from model owners
+            
+            Note: You can find your token at https://huggingface.co/settings/tokens
             """)
         elif "Tried to instantiate class" in str(e):
             st.error("""