Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,53 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+ACT-ODIDO-IMAGES/flux_dev_oddtopersonmark2.jpeg filter=lfs diff=lfs merge=lfs -text
+ACT-ODIDO-IMAGES/flux_dev_oddtopersonmark2_999-icecream.jpeg filter=lfs diff=lfs merge=lfs -text
+ACT-ODIDO-IMAGES/flux_dev_oddtopersonmark2_999.jpeg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_1503760_G1G3.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_2058141_G1G3.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_2511302_G1G2G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_2604801_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_3177699_G1G3.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_3414632_NO[[:space:]]GLOW.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_3737382_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_3890544_G2G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_3942209._G1G2G3G4jpg.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_4003550_G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_4103954_G1G3.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_4165779_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/Stocksy_comp_634618_G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_3841861_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_3992910_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_4173298_G2G34.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_4190225_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_4202421_G1G2G34.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_4363114_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+data/training_images/photocase_4687971_G1G2G3G4.jpg filter=lfs diff=lfs merge=lfs -text
+flux_dev_oddtopersonmark2.jpeg filter=lfs diff=lfs merge=lfs -text
+flux_dev_oddtopersonmark2_99.png filter=lfs diff=lfs merge=lfs -text
+flux_dev_oddtopersonmark2_999-icecream.jpeg filter=lfs diff=lfs merge=lfs -text
+flux_dev_oddtopersonmark2_999.jpeg filter=lfs diff=lfs merge=lfs -text
+models/Flux/hf_cache/models--black-forest-labs--FLUX.1-dev/blobs/f5b59a26851551b67ae1fe58d32e76486e1e812def4696a4bea97f16604d40a3 filter=lfs diff=lfs merge=lfs -text
+outputs/complete_local_flux/flux_dev_oddtopersonmark2_999.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_MWTfEJZVDWOaLY6cdoWfb_pytorch_lora_weights_42.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_MWTfEJZVDWOaLY6cdoWfb_pytorch_lora_weights_999.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtoperson_42.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtoperson_99.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2.jpeg filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_123[[:space:]]copy.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_123.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_42.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_777.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_99.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_992.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_999[[:space:]]copy[[:space:]]2.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_999[[:space:]]copy[[:space:]]3.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_999[[:space:]]copy.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_oddtopersonmark2_999.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_dev_wJavqTDrJzyC9ound57AP_pytorch_lora_weights_42.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_schnell_MWTfEJZVDWOaLY6cdoWfb_pytorch_lora_weights_42.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_schnell_oddtopersonmark2_2024.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_schnell_oddtopersonmark2_42.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_schnell_oddtopersonmark2_999.png filter=lfs diff=lfs merge=lfs -text
+outputs/flux_schnell_wJavqTDrJzyC9ound57AP_pytorch_lora_weights_42.png filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,95 @@
+*.zip
+*.tar.gz
+*.tar.bz2
+*.7z
+*.rar
+
+# Model files (often very large)
+*.safetensors
+*.ckpt
+*.bin
+*.pt
+*.pth
+*.h5
+*.pickle
+*.pkl
+
+# Python cache and temporary files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.pytest_cache/
+
+# Temporary files
+*.tmp
+*.temp
+*~
+.DS_Store
+Thumbs.db
+
+# Large image formats (consider using compressed versions)
+*.tiff
+*.tif
+*.bmp
+*.raw
+
+# Video files (typically large)
+*.mp4
+*.avi
+*.mov
+*.mkv
+*.flv
+
+# Audio files
+*.wav
+*.flac
+*.aiff
+
+# Large data files
+*.csv
+*.json
+*.xml
+*.sql
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Git LFS temporary files
+.git/lfs/tmp/
+
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints/
+
+# Environment variables
+.env
+.env.local
+.env.*.local
+
+# Log files
+*.log
+logs/
+
+# Large image directories (adjust as needed)
+# ACT-ODIDO-IMAGES/
+# **/large_images/
+# **/generated_images/
+`
+}

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,6 @@
 ---
-title: ACT Images
-emoji: 📊
-colorFrom: yellow
-colorTo: yellow
+title: ACT-images
+app_file: complete_fixed_flux_script.py
 sdk: gradio
-sdk_version: 5.33.0
-app_file: app.py
-pinned: false
+sdk_version: 5.20.0
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

complete_fixed_flux_script copy.py

@@ -0,0 +1,725 @@
+import gradio as gr
+import torch
+from diffusers import FluxPipeline
+from transformers import CLIPTextModel, T5EncoderModel, CLIPTokenizer, T5Tokenizer
+from safetensors.torch import load_file
+import os
+import socket
+from PIL import Image
+import base64
+import io
+import requests
+import json
+
+def find_free_port(start_port=7860):
+    """Find a free port"""
+    for port in range(start_port, start_port + 20):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(('localhost', port))
+                return port
+            except OSError:
+                continue
+    return None
+
+class CompleteLocalFlux:
+    def __init__(self):
+        # Set up Groq API key (you'll need to set this)
+        self.groq_api_key = os.getenv("GROQ_API_KEY")
+        if not self.groq_api_key:
+            print("⚠️  GROQ_API_KEY not found in environment variables")
+            print("   Set it with: export GROQ_API_KEY='your_api_key_here'")
+        else:
+            print("✅ Groq API key found")
+        
+        if torch.backends.mps.is_available():
+            self.device = torch.device("mps")
+            print("🚀 Using Apple M2 Max with MPS")
+        else:
+            self.device = torch.device("cpu")
+        
+        # Find your models
+        self.flux_models = {}
+        self.local_t5_path = None
+        
+        # Check for Flux models
+        possible_flux_files = [
+            ("Flux Dev", "./models/Flux/flux-dev.safetensors"),
+            ("Flux Schnell", "./models/Flux/flux1-schnell.safetensors"),
+            ("Flux Kontex", "./models/Flux/flux-kontex.safetensors"),
+            ("Flux Dev Alt", "./flux-dev.safetensors"),
+            ("Flux Schnell Alt", "./flux1-schnell.safetensors"),
+            ("Flux Kontex Alt", "./flux-kontex.safetensors")
+        ]
+        
+        for name, path in possible_flux_files:
+            if os.path.exists(path):
+                size_gb = os.path.getsize(path) / (1024*1024*1024)
+                self.flux_models[name] = {"path": path, "size": size_gb}
+                print(f"✅ Found {name}: {path} ({size_gb:.1f} GB)")
+        
+        # Check for local T5 model
+        possible_t5_paths = [
+            "./models/Flux/google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors",
+            "./google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors",
+            "./models/google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors"
+        ]
+        
+        for path in possible_t5_paths:
+            if os.path.exists(path):
+                size_gb = os.path.getsize(path) / (1024*1024*1024)
+                self.local_t5_path = path
+                print(f"✅ Found T5 model: {path} ({size_gb:.1f} GB)")
+                break
+        
+        # Check for local VAE model (including downloaded cache)
+        self.local_vae_path = None
+        self.cached_vae_path = "./models/Flux/vae_cache"  # Cache directory for downloaded VAE
+        
+        possible_vae_paths = [
+            "./models/Flux/ae.safetensors",
+            "./ae.safetensors", 
+            "./models/ae.safetensors",
+            "./models/Flux/vae.safetensors",
+            "./vae.safetensors",
+            self.cached_vae_path  # Check for cached downloaded VAE
+        ]
+        
+        for path in possible_vae_paths:
+            if os.path.exists(path):
+                if os.path.isdir(path):  # Cached VAE directory
+                    self.local_vae_path = path
+                    print(f"✅ Found cached VAE: {path}")
+                else:  # Single VAE file
+                    size_gb = os.path.getsize(path) / (1024*1024*1024)
+                    self.local_vae_path = path
+                    print(f"✅ Found VAE model: {path} ({size_gb:.1f} GB)")
+                break
+        
+        # Find LoRA files - simple and working approach
+        self.lora_files = []
+        
+        # Check multiple directories for LoRA files
+        lora_search_paths = [
+            "./models/lora",  # Main LoRA directory
+            ".",  # Current directory
+            "./models",
+            "./lora",
+            "./LoRA"
+        ]
+        
+        for search_path in lora_search_paths:
+            if os.path.exists(search_path):
+                try:
+                    files = [f for f in os.listdir(search_path) if f.endswith(".safetensors")]
+                    # Add full path for files not in current directory
+                    if search_path != ".":
+                        files = [os.path.join(search_path, f) for f in files]
+                    self.lora_files.extend(files)
+                except PermissionError:
+                    continue
+        
+        # Also specifically look for your LoRA files
+        specific_lora_files = [
+            "./models/lora/act_person_trained.safetensors",
+            "./models/lora/oddtoperson.safetensors",
+            "./models/lora/oddtopersonmark2.safetensors",
+        
+        ]
+        
+        for lora_file in specific_lora_files:
+            if os.path.exists(lora_file) and lora_file not in self.lora_files:
+                self.lora_files.append(lora_file)
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        unique_lora_files = []
+        for f in self.lora_files:
+            if f not in seen:
+                seen.add(f)
+                unique_lora_files.append(f)
+        self.lora_files = unique_lora_files
+        
+        self.pipeline = None
+        self.current_model = None
+        self.lora_loaded = False
+        self.encoders_loaded = False
+        
+        print(f"✅ Found {len(self.lora_files)} LoRA files")
+        for f in self.lora_files:
+            print(f"   - {f}")
+    
+    def cleanup_memory(self):
+        """Clean up GPU/MPS memory"""
+        if hasattr(self, 'pipeline') and self.pipeline is not None:
+            del self.pipeline
+            self.pipeline = None
+        
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        elif self.device.type == "mps":
+            torch.mps.empty_cache()
+        
+        print("🧹 Memory cleaned up")
+    
+    def load_local_text_encoders(self):
+        """Load text encoders using local and remote models"""
+        try:
+            print("🔄 Loading text encoders...")
+            
+            # Use consistent dtype for MPS compatibility
+            dtype = torch.float32  # Use float32 for better MPS compatibility
+            
+            # Load CLIP text encoder (download - small ~1GB)
+            print("   Loading CLIP text encoder (downloading ~1GB)...")
+            self.clip_text_encoder = CLIPTextModel.from_pretrained(
+                "openai/clip-vit-large-patch14",
+                torch_dtype=dtype
+            )
+            self.clip_tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
+            
+            # Load T5 encoder - fix the tokenizer warning and local loading
+            if self.local_t5_path:
+                print(f"   Loading T5 from local file: {self.local_t5_path}")
+                
+                # Load tokenizer with legacy=False to suppress warning
+                print("   Loading T5 tokenizer...")
+                self.t5_tokenizer = T5Tokenizer.from_pretrained(
+                    "google/t5-v1_1-xxl", 
+                    legacy=False  # This fixes the warning
+                )
+                
+                print("   Loading local T5 weights...")
+                # Load the model architecture first
+                self.t5_text_encoder = T5EncoderModel.from_pretrained(
+                    "google/t5-v1_1-xxl",
+                    torch_dtype=dtype
+                )
+                
+                # Try to load and apply your local weights
+                try:
+                    print("   Attempting to load local T5 safetensors...")
+                    local_t5_weights = load_file(self.local_t5_path)
+                    
+                    # Filter weights to only include those that match the model structure
+                    model_state_dict = self.t5_text_encoder.state_dict()
+                    filtered_weights = {}
+                    
+                    for key, value in local_t5_weights.items():
+                        if key in model_state_dict:
+                            if model_state_dict[key].shape == value.shape:
+                                filtered_weights[key] = value
+                            else:
+                                print(f"⚠️  Skipping {key}: shape mismatch {model_state_dict[key].shape} vs {value.shape}")
+                        else:
+                            print(f"⚠️  Skipping {key}: not found in model")
+                    
+                    # Load the filtered weights
+                    missing_keys, unexpected_keys = self.t5_text_encoder.load_state_dict(filtered_weights, strict=False)
+                    
+                    if missing_keys:
+                        print(f"⚠️  Missing keys: {len(missing_keys)} (this is often normal)")
+                    if unexpected_keys:
+                        print(f"⚠️  Unexpected keys: {len(unexpected_keys)}")
+                    
+                    print("✅ Local T5 weights loaded successfully!")
+                    
+                except Exception as e:
+                    print(f"❌ Error loading local T5 weights: {e}")
+                    print("   Your T5 file may be corrupted or incomplete.")
+                    print("   Falling back to downloaded weights (model architecture already loaded)...")
+                    # Keep the downloaded model architecture - don't try to reload
+                    
+            else:
+                print("   No local T5 found, downloading...")
+                self.t5_tokenizer = T5Tokenizer.from_pretrained(
+                    "google/t5-v1_1-xxl",
+                    legacy=False  # This fixes the warning
+                )
+                self.t5_text_encoder = T5EncoderModel.from_pretrained(
+                    "google/t5-v1_1-xxl",
+                    torch_dtype=dtype
+                )
+            
+            # Move to device
+            self.clip_text_encoder = self.clip_text_encoder.to(self.device)
+            self.t5_text_encoder = self.t5_text_encoder.to(self.device)
+            
+            self.encoders_loaded = True
+            print("✅ All text encoders loaded successfully!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error loading text encoders: {e}")
+            import traceback
+            traceback.print_exc()  # This will help debug the exact issue
+            return False
+    
+    def load_flux_complete(self, model_choice, lora_choice):
+        """Load complete Flux setup with better memory management"""
+        try:
+            # Clean up previous model if switching
+            if self.current_model and self.current_model != model_choice:
+                print("🧹 Cleaning up previous model...")
+                self.cleanup_memory()
+            
+            # Load encoders if needed
+            if not self.encoders_loaded:
+                if not self.load_local_text_encoders():
+                    return "❌ Failed to load text encoders"
+            
+            if model_choice not in self.flux_models:
+                return f"❌ Model {model_choice} not found"
+            
+            model_path = self.flux_models[model_choice]["path"]
+            print(f"🔄 Loading {model_choice} with complete setup...")
+            
+            # Load VAE separately (required for Flux)
+            print("   Loading VAE...")
+            from diffusers import AutoencoderKL
+            
+            # Check if we have a cached VAE first
+            if self.local_vae_path and os.path.isdir(self.local_vae_path):
+                print(f"   Using cached VAE from: {self.local_vae_path}")
+                try:
+                    vae = AutoencoderKL.from_pretrained(
+                        self.local_vae_path,
+                        torch_dtype=torch.float32
+                    )
+                    # Ensure all VAE weights are float32 for MPS compatibility
+                    vae = vae.to(torch.float32)
+                    print("✅ Cached VAE loaded successfully!")
+                except Exception as e:
+                    print(f"❌ Cached VAE failed: {e}")
+                    vae = None
+            else:
+                vae = None
+            
+            # Download and cache VAE if no local version works
+            if vae is None:
+                print("   Downloading VAE from HuggingFace...")
+                try:
+                    # Create cache directory
+                    os.makedirs(os.path.dirname(self.cached_vae_path), exist_ok=True)
+                    
+                    # Download and save to cache
+                    vae = AutoencoderKL.from_pretrained(
+                        "black-forest-labs/FLUX.1-dev", 
+                        subfolder="vae",
+                        torch_dtype=torch.float32,
+                        cache_dir="./models/Flux/hf_cache"  # Local cache for HuggingFace downloads
+                    )
+                    
+                    # Ensure all VAE weights are float32 for MPS compatibility
+                    vae = vae.to(torch.float32)
+                    
+                    # Save the VAE locally for next time
+                    print(f"   Caching VAE to: {self.cached_vae_path}")
+                    vae.save_pretrained(self.cached_vae_path)
+                    self.local_vae_path = self.cached_vae_path  # Update for future runs
+                    
+                    print("✅ VAE downloaded and cached locally!")
+                    
+                except Exception as e:
+                    print(f"❌ Failed to download VAE: {e}")
+                    return f"❌ Could not load VAE: {e}"
+                vae = AutoencoderKL.from_pretrained(
+                    "black-forest-labs/FLUX.1-dev", 
+                    subfolder="vae",
+                    torch_dtype=torch.bfloat16 if self.device.type == "mps" else torch.float32
+                )
+            
+            # Load Flux with all components including VAE
+            self.pipeline = FluxPipeline.from_single_file(
+                model_path,
+                text_encoder=self.clip_text_encoder,
+                text_encoder_2=self.t5_text_encoder,
+                tokenizer=self.clip_tokenizer,
+                tokenizer_2=self.t5_tokenizer,
+                vae=vae,  # Add the VAE component
+                torch_dtype=torch.float32,  # Use float32 for MPS compatibility
+            )
+            
+            self.current_model = model_choice
+            print(f"✅ {model_choice} loaded completely!")
+            
+            # Load LoRA
+            self.lora_loaded = False
+            if lora_choice != "None" and lora_choice in self.lora_files:
+                try:
+                    print(f"🔄 Loading LoRA: {lora_choice}")
+                    
+                    # Load LoRA with better error handling and warnings suppression
+                    import warnings
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings("ignore", message="No LoRA keys associated to CLIPTextModel found")
+                        warnings.filterwarnings("ignore", message="You can also try specifying")
+                        
+                        self.pipeline.load_lora_weights(".", weight_name=lora_choice)
+                    
+                    self.lora_loaded = True
+                    print("✅ LoRA loaded successfully!")
+                    
+                except Exception as e:
+                    print(f"❌ LoRA loading failed: {e}")
+                    # Continue without LoRA if it fails
+                    self.lora_loaded = False
+            
+            # Move pipeline to device (MPS for Apple Silicon)
+            self.pipeline = self.pipeline.to(self.device)
+            
+            # Ensure all pipeline components are float32 for MPS compatibility
+            if self.device.type == "mps":
+                print("   Converting all components to float32 for MPS...")
+                self.pipeline.vae = self.pipeline.vae.to(torch.float32)
+                self.pipeline.text_encoder = self.pipeline.text_encoder.to(torch.float32)
+                self.pipeline.text_encoder_2 = self.pipeline.text_encoder_2.to(torch.float32)
+                
+                # Enable MPS-specific optimizations
+                self.pipeline.enable_attention_slicing()
+                print("✅ Enabled MPS optimizations and float32 conversion")
+            
+            status = f"✅ {model_choice} ready"
+            if self.local_t5_path:
+                status += " (using local T5)"
+            if self.lora_loaded:
+                status += f" + LoRA ({lora_choice})"
+            
+            return status
+            
+        except Exception as e:
+            print(f"❌ Error in load_flux_complete: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"❌ Error: {e}"
+    
+    def generate_image(self, prompt, model_choice, lora_choice, steps, guidance, seed):
+        """Generate with complete local setup - YOUR SETTINGS ARE RESPECTED"""
+        
+        # Convert clean LoRA name back to full path if needed
+        actual_lora_choice = lora_choice
+        if hasattr(self, 'lora_path_mapping') and lora_choice in self.lora_path_mapping:
+            actual_lora_choice = self.lora_path_mapping[lora_choice]
+        
+        # Load if needed
+        if self.pipeline is None or self.current_model != model_choice:
+            print(f"🔄 Need to load model: {model_choice}")
+            load_status = self.load_flux_complete(model_choice, actual_lora_choice)
+            if "❌" in load_status:
+                print(f"❌ Model loading failed: {load_status}")
+                return None, load_status
+        
+        if not prompt.strip():
+            return None, "❌ Please enter a prompt"
+        
+        try:
+            print(f"🎨 Starting generation...")
+            print(f"   Prompt: {prompt[:60]}...")
+            print(f"   Model: {model_choice}")
+            print(f"   LoRA: {lora_choice}")
+            print(f"   Steps: {steps}, Guidance: {guidance}, Seed: {seed}")
+            
+            torch.manual_seed(int(seed))
+            
+            # USE YOUR EXACT SETTINGS - NO OVERRIDES!
+            print(f"   Using your exact settings: {steps} steps, guidance: {guidance}")
+            
+            print("🔄 Running pipeline...")
+            with torch.inference_mode():
+                result = self.pipeline(
+                    prompt=prompt,
+                    num_inference_steps=int(steps),
+                    guidance_scale=guidance,
+                    width=1024,
+                    height=1024,
+                    generator=torch.Generator(device=self.device).manual_seed(int(seed))
+                )
+                
+                if hasattr(result, 'images') and len(result.images) > 0:
+                    image = result.images[0]
+                    print("✅ Image generated successfully!")
+                else:
+                    print("❌ No images in pipeline result")
+                    return None, "❌ Pipeline returned no images"
+            
+            if self.device.type == "mps":
+                torch.mps.empty_cache()
+            
+            # Save with clean filename
+            os.makedirs("outputs/complete_local_flux", exist_ok=True)
+            model_name = model_choice.replace(" ", "_").lower()
+            
+            # Clean LoRA name for filename
+            if lora_choice != "None":
+                lora_name = os.path.basename(lora_choice).replace(".safetensors", "")
+                lora_name = lora_name.replace("/", "_").replace("\\", "_").replace(" ", "_")
+            else:
+                lora_name = "no_lora"
+            filename = f"{model_name}_{lora_name}_{seed}.png"
+            filepath = os.path.join("outputs/complete_local_flux", filename)
+            
+            print(f"💾 Saving to: {filepath}")
+            image.save(filepath, optimize=True)
+            
+            status = f"✅ Generated with {model_choice}"
+            if self.lora_loaded:
+                status += f" + LoRA"
+            if self.local_t5_path:
+                status += " (local T5)"
+            status += f"\n📐 1024x1024 • {steps} steps • Guidance: {guidance} • Seed: {seed}"
+            status += f"\n💾 {filepath}"
+            
+            print("🎉 Generation complete!")
+            return image, status
+            
+        except Exception as e:
+            error_msg = f"❌ Generation failed: {str(e)}"
+            print(error_msg)
+            import traceback
+            traceback.print_exc()
+            return None, error_msg
+    
+    def image_to_base64(self, image):
+        """Convert PIL Image to base64 string"""
+        try:
+            # Resize image if too large (Groq has size limits)
+            max_size = 1024
+            if image.width > max_size or image.height > max_size:
+                image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+            
+            # Convert to RGB if needed
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Convert to base64
+            buffered = io.BytesIO()
+            image.save(buffered, format="JPEG", quality=85)
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            return img_str
+        except Exception as e:
+            print(f"❌ Error converting image to base64: {e}")
+            return None
+    
+    def analyze_image_with_groq(self, image):
+        """Analyze image using Groq Vision API and return description"""
+        if not self.groq_api_key:
+            return "❌ Groq API key not configured. Set GROQ_API_KEY environment variable."
+        
+        try:
+            print("🔍 Analyzing image with Groq Vision...")
+            
+            # Convert image to base64
+            base64_image = self.image_to_base64(image)
+            if not base64_image:
+                return "❌ Failed to convert image to base64"
+            
+            # Prepare the API request
+            headers = {
+                "Authorization": f"Bearer {self.groq_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "model": "meta-llama/llama-4-scout-17b-16e-instruct",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": "Describe this image in detail for an AI image generation prompt. Focus on visual elements, style, composition, lighting, colors, mood, and artistic techniques. Be descriptive but concise. Format it as a prompt that could be used to recreate a similar image."
+                            },
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/jpeg;base64,{base64_image}"
+                                }
+                            }
+                        ]
+                    }
+                ],
+                "max_tokens": 300,
+                "temperature": 0.3
+            }
+            
+            # Make the API call
+            response = requests.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                description = result['choices'][0]['message']['content'].strip()
+                print("✅ Image analysis complete!")
+                return description
+            else:
+                error_msg = f"Groq API error: {response.status_code} - {response.text}"
+                print(f"❌ {error_msg}")
+                return f"❌ {error_msg}"
+                
+        except Exception as e:
+            error_msg = f"Error analyzing image: {str(e)}"
+            print(f"❌ {error_msg}")
+            return f"❌ {error_msg}"
+    
+    def create_interface(self):
+        """Create complete interface"""
+        
+        model_choices = list(self.flux_models.keys())
+        if not model_choices:
+            model_choices = ["No models found"]
+        
+        # Clean up LoRA choices - show only the filename
+        clean_lora_choices = ["None"]
+        for lora_path in self.lora_files:
+            filename = os.path.basename(lora_path)  # Get just the filename
+            clean_lora_choices.append(filename)
+        
+        # Create a mapping from clean names to full paths
+        self.lora_path_mapping = {"None": "None"}
+        for lora_path in self.lora_files:
+            filename = os.path.basename(lora_path)
+            self.lora_path_mapping[filename] = lora_path
+        
+        with gr.Blocks(title="Complete Local Flux Studio", theme=gr.themes.Soft()) as interface:
+            
+            gr.Markdown("# 🏠 Complete Local Flux Studio")
+            gr.Markdown("*Using your local Flux models + T5 + LoRA - maximum efficiency!*")
+            
+            # Show what's available locally
+            if self.flux_models:
+                gr.Markdown("## 📁 Your Local Setup:")
+                for name, info in self.flux_models.items():
+                    gr.Markdown(f"- **{name}**: {info['size']:.1f} GB")
+                if self.local_t5_path:
+                    t5_size = os.path.getsize(self.local_t5_path) / (1024*1024*1024)
+                    gr.Markdown(f"- **T5 Encoder**: {t5_size:.1f} GB (local)")
+                if self.local_vae_path:
+                    if os.path.isdir(self.local_vae_path):
+                        gr.Markdown(f"- **VAE**: cached (local)")
+                    else:
+                        vae_size = os.path.getsize(self.local_vae_path) / (1024*1024*1024)
+                        gr.Markdown(f"- **VAE**: {vae_size:.1f} GB (local)")
+                gr.Markdown(f"- **LoRA Models**: {len(self.lora_files)} found")
+            
+            # IMAGE ANALYSIS SECTION - MOVED TO TOP LEVEL
+            gr.Markdown("## 🔍 Image Analysis with Groq Vision")
+            gr.Markdown("*Upload an image to automatically generate a prompt description*")
+            
+            input_image = gr.Image(
+                label="📤 Upload Image to Analyze", 
+                type="pil",
+                height=200
+            )
+            
+            analyze_btn = gr.Button(
+                "🔍 Analyze Image with Groq Vision",
+                variant="primary",
+                size="lg"
+            )
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("## 🎨 Generate")
+                    
+                    model_choice = gr.Dropdown(
+                        choices=model_choices,
+                        value=model_choices[0] if model_choices[0] != "No models found" else None,
+                        label="Flux Model"
+                    )
+                    
+                    lora_choice = gr.Dropdown(
+                        choices=clean_lora_choices,
+                        value=clean_lora_choices[1] if len(clean_lora_choices) > 1 else "None",
+                        label="Your LoRA"
+                    )
+                    
+                    prompt = gr.Textbox(
+                        label="Prompt",
+                        value="artistic lifestyle portrait, person wearing vibrant orange bucket hat, expressive face, golden hour lighting, street style photography, film aesthetic",
+                        lines=6,
+                        placeholder="Enter your prompt here, or upload an image above and click 'Analyze' to auto-generate..."
+                    )
+                    
+                    with gr.Row():
+                        steps = gr.Slider(4, 50, value=20, label="Steps")
+                        guidance = gr.Slider(0.0, 10.0, value=3.5, label="Guidance")
+                        seed = gr.Number(value=42, label="Seed")
+                    
+                    generate_btn = gr.Button("🏠 Generate Locally", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    output_image = gr.Image(label="Generated Image", height=600)
+                    status = gr.Textbox(label="Status", interactive=False, lines=4)
+            
+            # Quick prompts for your artistic style
+            gr.Markdown("## 🎨 Your Artistic Style")
+            with gr.Row():
+                portrait_btn = gr.Button("🎭 Portrait")
+                vibrant_btn = gr.Button("🌈 Vibrant") 
+                street_btn = gr.Button("📸 Street")
+            
+            # Event handlers
+            analyze_btn.click(
+                fn=self.analyze_image_with_groq,
+                inputs=[input_image],
+                outputs=[prompt]
+            )
+            
+            portrait_btn.click(
+                lambda: "artistic lifestyle portrait, person with expressive face, vibrant clothing, golden hour lighting",
+                outputs=[prompt]
+            )
+            
+            vibrant_btn.click(
+                lambda: "person in colorful streetwear, vibrant orange bucket hat, street photography, film aesthetic",
+                outputs=[prompt]
+            )
+            
+            street_btn.click(
+                lambda: "urban street style portrait, candid expression, natural lighting, contemporary photography",
+                outputs=[prompt]
+            )
+            
+            generate_btn.click(
+                fn=self.generate_image,
+                inputs=[prompt, model_choice, lora_choice, steps, guidance, seed],
+                outputs=[output_image, status]
+            )
+        
+        return interface
+    
+    def launch(self):
+        """Launch complete interface"""
+        interface = self.create_interface()
+        
+        port = find_free_port()
+        print("🏠 Launching Complete Local Flux Studio...")
+        print(f"📱 Interface: http://localhost:{port}")
+        print("🚀 Using maximum local resources!")
+        
+        try:
+            interface.launch(
+                server_port=port,
+                share=True,
+                inbrowser=True
+                
+            )
+        except Exception as e:
+            print(f"❌ Launch failed: {e}")
+
+if __name__ == "__main__":
+    # Check if sentencepiece is installed
+    try:
+        import sentencepiece
+        print("✅ SentencePiece found")
+    except ImportError:
+        print("❌ SentencePiece not found")
+        print("🔧 Install with: pip install sentencepiece protobuf")
+        exit(1)
+    
+    interface = CompleteLocalFlux()
+    interface.launch()

complete_fixed_flux_script.py

@@ -0,0 +1,791 @@
+import gradio as gr
+import torch
+from diffusers import FluxPipeline
+from transformers import CLIPTextModel, T5EncoderModel, CLIPTokenizer, T5Tokenizer
+from safetensors.torch import load_file
+import os
+import socket
+from PIL import Image
+import base64
+import io
+import requests
+import json
+
+def find_free_port(start_port=7860):
+    """Find a free port"""
+    for port in range(start_port, start_port + 20):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(('localhost', port))
+                return port
+            except OSError:
+                continue
+    return None
+
+class CompleteLocalFlux:
+    def __init__(self):
+        # Set up Groq API key (you'll need to set this)
+        self.groq_api_key = os.getenv("GROQ_API_KEY")
+        if not self.groq_api_key:
+            print("⚠️  GROQ_API_KEY not found in environment variables")
+            print("   Set it with: export GROQ_API_KEY='your_api_key_here'")
+        else:
+            print("✅ Groq API key found")
+        
+        if torch.backends.mps.is_available():
+            self.device = torch.device("mps")
+            print("🚀 Using Apple M2 Max with MPS")
+        else:
+            self.device = torch.device("cpu")
+        
+        # Find your models
+        self.flux_models = {}
+        self.local_t5_path = None
+        
+        # Check for Flux models
+        possible_flux_files = [
+            ("Flux Dev", "./models/Flux/flux-dev.safetensors"),
+            ("Flux Schnell", "./models/Flux/flux1-schnell.safetensors"),
+            ("Flux Kontex", "./models/Flux/flux-kontex.safetensors"),
+            ("Flux Dev Alt", "./flux-dev.safetensors"),
+            ("Flux Schnell Alt", "./flux1-schnell.safetensors"),
+            ("Flux Kontex Alt", "./flux-kontex.safetensors")
+        ]
+        
+        for name, path in possible_flux_files:
+            if os.path.exists(path):
+                size_gb = os.path.getsize(path) / (1024*1024*1024)
+                self.flux_models[name] = {"path": path, "size": size_gb}
+                print(f"✅ Found {name}: {path} ({size_gb:.1f} GB)")
+        
+        # Check for local T5 model
+        possible_t5_paths = [
+            "./models/Flux/google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors",
+            "./google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors",
+            "./models/google_t5-v1_1-xxl_encoderonly-fp8_e4m3fn.safetensors"
+        ]
+        
+        for path in possible_t5_paths:
+            if os.path.exists(path):
+                size_gb = os.path.getsize(path) / (1024*1024*1024)
+                self.local_t5_path = path
+                print(f"✅ Found T5 model: {path} ({size_gb:.1f} GB)")
+                break
+        
+        # Check for local CLIP model
+        self.local_clip_path = None
+        possible_clip_paths = [
+            "./models/clip",
+            "./models/CLIP/clip-vit-large-patch14",
+            "./clip-vit-large-patch14"
+        ]
+        
+        for path in possible_clip_paths:
+            if os.path.exists(path) and os.path.exists(os.path.join(path, "config.json")):
+                self.local_clip_path = path
+                print(f"✅ Found local CLIP model: {path}")
+                break
+        
+        if not self.local_clip_path:
+            print("⚠️  No local CLIP model found - will download on first use")
+        
+        # Check for local VAE model (including downloaded cache)
+        self.local_vae_path = None
+        self.cached_vae_path = "./models/Flux/vae_cache"  # Cache directory for downloaded VAE
+        
+        possible_vae_paths = [
+            "./models/Flux/vae_local",  # New local VAE location
+            "./models/Flux/ae.safetensors",
+            "./ae.safetensors", 
+            "./models/ae.safetensors",
+            "./models/Flux/vae.safetensors",
+            "./vae.safetensors",
+            self.cached_vae_path  # Check for cached downloaded VAE
+        ]
+        
+        for path in possible_vae_paths:
+            if os.path.exists(path):
+                if os.path.isdir(path):  # Cached VAE directory
+                    self.local_vae_path = path
+                    print(f"✅ Found cached VAE: {path}")
+                else:  # Single VAE file
+                    size_gb = os.path.getsize(path) / (1024*1024*1024)
+                    self.local_vae_path = path
+                    print(f"✅ Found VAE model: {path} ({size_gb:.1f} GB)")
+                break
+        
+        # Find LoRA files - simple and working approach
+        self.lora_files = []
+        
+        # Check multiple directories for LoRA files
+        lora_search_paths = [
+            "./models/lora",  # Main LoRA directory
+            ".",  # Current directory
+            "./models",
+            "./lora",
+            "./LoRA"
+        ]
+        
+        for search_path in lora_search_paths:
+            if os.path.exists(search_path):
+                try:
+                    files = [f for f in os.listdir(search_path) if f.endswith(".safetensors")]
+                    # Add full path for files not in current directory
+                    if search_path != ".":
+                        files = [os.path.join(search_path, f) for f in files]
+                    self.lora_files.extend(files)
+                except PermissionError:
+                    continue
+        
+        # Also specifically look for your LoRA files
+        specific_lora_files = [
+            "./models/lora/act_person_trained.safetensors",
+            "./models/lora/oddtoperson.safetensors",
+            "./models/lora/oddtopersonmark2.safetensors",
+        
+        ]
+        
+        for lora_file in specific_lora_files:
+            if os.path.exists(lora_file) and lora_file not in self.lora_files:
+                self.lora_files.append(lora_file)
+        
+        # Remove duplicates while preserving order
+        seen = set()
+        unique_lora_files = []
+        for f in self.lora_files:
+            if f not in seen:
+                seen.add(f)
+                unique_lora_files.append(f)
+        self.lora_files = unique_lora_files
+        
+        self.pipeline = None
+        self.current_model = None
+        self.lora_loaded = False
+        self.encoders_loaded = False
+        
+        print(f"✅ Found {len(self.lora_files)} LoRA files")
+        for f in self.lora_files:
+            print(f"   - {f}")
+    
+    def cleanup_memory(self):
+        """Clean up GPU/MPS memory"""
+        if hasattr(self, 'pipeline') and self.pipeline is not None:
+            del self.pipeline
+            self.pipeline = None
+        
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        elif self.device.type == "mps":
+            torch.mps.empty_cache()
+        
+        print("🧹 Memory cleaned up")
+    
+    def load_local_text_encoders(self):
+        """Load text encoders using local and remote models"""
+        try:
+            print("🔄 Loading text encoders...")
+            
+            # Use consistent dtype for MPS compatibility
+            dtype = torch.float32  # Use float32 for better MPS compatibility
+            
+            # Load CLIP text encoder from local folder if available
+            if self.local_clip_path:
+                print(f"   Loading CLIP from local folder: {self.local_clip_path}")
+                try:
+                    self.clip_text_encoder = CLIPTextModel.from_pretrained(
+                        self.local_clip_path,
+                        torch_dtype=dtype,
+                        local_files_only=True  # Force local only
+                    )
+                    self.clip_tokenizer = CLIPTokenizer.from_pretrained(
+                        self.local_clip_path,
+                        local_files_only=True  # Force local only
+                    )
+                    print("✅ Local CLIP model loaded successfully!")
+                except Exception as e:
+                    print(f"❌ Error loading local CLIP folder: {e}")
+                    print("   Falling back to download...")
+                    # Fallback to download if local fails
+                    self.clip_text_encoder = CLIPTextModel.from_pretrained(
+                        "openai/clip-vit-large-patch14",
+                        torch_dtype=dtype
+                    )
+                    self.clip_tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
+            else:
+                print("   Loading CLIP text encoder (downloading ~1GB)...")
+                self.clip_text_encoder = CLIPTextModel.from_pretrained(
+                    "openai/clip-vit-large-patch14",
+                    torch_dtype=dtype
+                )
+                self.clip_tokenizer = CLIPTokenizer.from_pretrained("openai/clip-vit-large-patch14")
+            
+            # Load T5 encoder - fix the tokenizer warning and local loading
+            if self.local_t5_path:
+                print(f"   Loading T5 from local file: {self.local_t5_path}")
+                
+                # Load tokenizer with legacy=False to suppress warning
+                print("   Loading T5 tokenizer...")
+                self.t5_tokenizer = T5Tokenizer.from_pretrained(
+                    "google/t5-v1_1-xxl", 
+                    legacy=False  # This fixes the warning
+                )
+                
+                print("   Loading local T5 weights...")
+                # Load the model architecture first
+                self.t5_text_encoder = T5EncoderModel.from_pretrained(
+                    "google/t5-v1_1-xxl",
+                    torch_dtype=dtype
+                )
+                
+                # Try to load and apply your local weights
+                try:
+                    print("   Attempting to load local T5 safetensors...")
+                    local_t5_weights = load_file(self.local_t5_path)
+                    
+                    # Filter weights to only include those that match the model structure
+                    model_state_dict = self.t5_text_encoder.state_dict()
+                    filtered_weights = {}
+                    
+                    for key, value in local_t5_weights.items():
+                        if key in model_state_dict:
+                            if model_state_dict[key].shape == value.shape:
+                                filtered_weights[key] = value
+                            else:
+                                print(f"⚠️  Skipping {key}: shape mismatch {model_state_dict[key].shape} vs {value.shape}")
+                        else:
+                            print(f"⚠️  Skipping {key}: not found in model")
+                    
+                    # Load the filtered weights
+                    missing_keys, unexpected_keys = self.t5_text_encoder.load_state_dict(filtered_weights, strict=False)
+                    
+                    if missing_keys:
+                        print(f"⚠️  Missing keys: {len(missing_keys)} (this is often normal)")
+                    if unexpected_keys:
+                        print(f"⚠️  Unexpected keys: {len(unexpected_keys)}")
+                    
+                    print("✅ Local T5 weights loaded successfully!")
+                    
+                except Exception as e:
+                    print(f"❌ Error loading local T5 weights: {e}")
+                    print("   Your T5 file may be corrupted or incomplete.")
+                    print("   Falling back to downloaded weights (model architecture already loaded)...")
+                    # Keep the downloaded model architecture - don't try to reload
+                    
+            else:
+                print("   No local T5 found, downloading...")
+                self.t5_tokenizer = T5Tokenizer.from_pretrained(
+                    "google/t5-v1_1-xxl",
+                    legacy=False  # This fixes the warning
+                )
+                self.t5_text_encoder = T5EncoderModel.from_pretrained(
+                    "google/t5-v1_1-xxl",
+                    torch_dtype=dtype
+                )
+            
+            # Move to device
+            self.clip_text_encoder = self.clip_text_encoder.to(self.device)
+            self.t5_text_encoder = self.t5_text_encoder.to(self.device)
+            
+            self.encoders_loaded = True
+            print("✅ All text encoders loaded successfully!")
+            return True
+            
+        except Exception as e:
+            print(f"❌ Error loading text encoders: {e}")
+            import traceback
+            traceback.print_exc()  # This will help debug the exact issue
+            return False
+    
+    def load_flux_complete(self, model_choice, lora_choice):
+        """Load complete Flux setup with better memory management"""
+        try:
+            # Clean up previous model if switching
+            if self.current_model and self.current_model != model_choice:
+                print("🧹 Cleaning up previous model...")
+                self.cleanup_memory()
+            
+            # Load encoders if needed
+            if not self.encoders_loaded:
+                if not self.load_local_text_encoders():
+                    return "❌ Failed to load text encoders"
+            
+            if model_choice not in self.flux_models:
+                return f"❌ Model {model_choice} not found"
+            
+            model_path = self.flux_models[model_choice]["path"]
+            print(f"🔄 Loading {model_choice} with complete setup...")
+            
+            # Load VAE separately (required for Flux)
+            print("   Loading VAE...")
+            from diffusers import AutoencoderKL
+            
+            # Check if we have a local VAE first
+            if self.local_vae_path:
+                print(f"   Using local VAE from: {self.local_vae_path}")
+                try:
+                    if os.path.isdir(self.local_vae_path):
+                        # Local VAE folder
+                        vae = AutoencoderKL.from_pretrained(
+                            self.local_vae_path,
+                            torch_dtype=torch.float32,
+                            local_files_only=True  # Force local only
+                        )
+                    else:
+                        # Single VAE file - load the base model and apply weights
+                        vae = AutoencoderKL.from_pretrained(
+                            "black-forest-labs/FLUX.1-dev", 
+                            subfolder="vae",
+                            torch_dtype=torch.float32
+                        )
+                        # Load local weights if it's a safetensors file
+                        if self.local_vae_path.endswith('.safetensors'):
+                            from safetensors.torch import load_file
+                            vae_weights = load_file(self.local_vae_path)
+                            vae.load_state_dict(vae_weights, strict=False)
+                    
+                    # Ensure all VAE weights are float32 for MPS compatibility
+                    vae = vae.to(torch.float32)
+                    print("✅ Local VAE loaded successfully!")
+                    
+                except Exception as e:
+                    print(f"❌ Local VAE failed: {e}")
+                    print("   Falling back to download...")
+                    vae = None
+            else:
+                vae = None
+            
+            # Download and cache VAE if no local version works
+            if vae is None:
+                print("   ⚠️ No local VAE found - downloading from HuggingFace...")
+                print("   Consider running download_vae.py for 100% local operation")
+                try:
+                    # Create cache directory
+                    os.makedirs(os.path.dirname(self.cached_vae_path), exist_ok=True)
+                    
+                    # Download and save to cache
+                    vae = AutoencoderKL.from_pretrained(
+                        "black-forest-labs/FLUX.1-dev", 
+                        subfolder="vae",
+                        torch_dtype=torch.float32,
+                        cache_dir="./models/Flux/hf_cache"  # Local cache for HuggingFace downloads
+                    )
+                    
+                    # Ensure all VAE weights are float32 for MPS compatibility
+                    vae = vae.to(torch.float32)
+                    
+                    # Save the VAE locally for next time
+                    print(f"   Caching VAE to: {self.cached_vae_path}")
+                    vae.save_pretrained(self.cached_vae_path)
+                    self.local_vae_path = self.cached_vae_path  # Update for future runs
+                    
+                    print("✅ VAE downloaded and cached locally!")
+                    
+                except Exception as e:
+                    print(f"❌ Failed to download VAE: {e}")
+                    return f"❌ Could not load VAE: {e}"
+            
+            # Load Flux with all components including VAE
+            self.pipeline = FluxPipeline.from_single_file(
+                model_path,
+                text_encoder=self.clip_text_encoder,
+                text_encoder_2=self.t5_text_encoder,
+                tokenizer=self.clip_tokenizer,
+                tokenizer_2=self.t5_tokenizer,
+                vae=vae,  # Add the VAE component
+                torch_dtype=torch.float32,  # Use float32 for MPS compatibility
+            )
+            
+            self.current_model = model_choice
+            print(f"✅ {model_choice} loaded completely!")
+            
+            # Load LoRA
+            self.lora_loaded = False
+            if lora_choice != "None" and lora_choice in self.lora_files:
+                try:
+                    print(f"🔄 Loading LoRA: {lora_choice}")
+                    
+                    # Load LoRA with better error handling and warnings suppression
+                    import warnings
+                    with warnings.catch_warnings():
+                        warnings.filterwarnings("ignore", message="No LoRA keys associated to CLIPTextModel found")
+                        warnings.filterwarnings("ignore", message="You can also try specifying")
+                        
+                        self.pipeline.load_lora_weights(".", weight_name=lora_choice)
+                    
+                    self.lora_loaded = True
+                    print("✅ LoRA loaded successfully!")
+                    
+                except Exception as e:
+                    print(f"❌ LoRA loading failed: {e}")
+                    # Continue without LoRA if it fails
+                    self.lora_loaded = False
+            
+            # Move pipeline to device (MPS for Apple Silicon)
+            self.pipeline = self.pipeline.to(self.device)
+            
+            # Ensure all pipeline components are float32 for MPS compatibility
+            if self.device.type == "mps":
+                print("   Converting all components to float32 for MPS...")
+                self.pipeline.vae = self.pipeline.vae.to(torch.float32)
+                self.pipeline.text_encoder = self.pipeline.text_encoder.to(torch.float32)
+                self.pipeline.text_encoder_2 = self.pipeline.text_encoder_2.to(torch.float32)
+                
+                # Enable MPS-specific optimizations
+                self.pipeline.enable_attention_slicing()
+                print("✅ Enabled MPS optimizations and float32 conversion")
+            
+            status = f"✅ {model_choice} ready"
+            if self.local_t5_path:
+                status += " (local T5)"
+            if self.local_clip_path:
+                status += " (local CLIP)"
+            if self.local_vae_path:
+                status += " (local VAE)"
+            if self.lora_loaded:
+                status += f" + LoRA ({lora_choice})"
+            
+            return status
+            
+        except Exception as e:
+            print(f"❌ Error in load_flux_complete: {e}")
+            import traceback
+            traceback.print_exc()
+            return f"❌ Error: {e}"
+    
+    def generate_image(self, prompt, model_choice, lora_choice, steps, guidance, seed):
+        """Generate with complete local setup - YOUR SETTINGS ARE RESPECTED"""
+        
+        # Convert clean LoRA name back to full path if needed
+        actual_lora_choice = lora_choice
+        if hasattr(self, 'lora_path_mapping') and lora_choice in self.lora_path_mapping:
+            actual_lora_choice = self.lora_path_mapping[lora_choice]
+        
+        # Load if needed
+        if self.pipeline is None or self.current_model != model_choice:
+            print(f"🔄 Need to load model: {model_choice}")
+            load_status = self.load_flux_complete(model_choice, actual_lora_choice)
+            if "❌" in load_status:
+                print(f"❌ Model loading failed: {load_status}")
+                return None, load_status
+        
+        if not prompt.strip():
+            return None, "❌ Please enter a prompt"
+        
+        try:
+            print(f"🎨 Starting generation...")
+            print(f"   Prompt: {prompt[:60]}...")
+            print(f"   Model: {model_choice}")
+            print(f"   LoRA: {lora_choice}")
+            print(f"   Steps: {steps}, Guidance: {guidance}, Seed: {seed}")
+            
+            torch.manual_seed(int(seed))
+            
+            # USE YOUR EXACT SETTINGS - NO OVERRIDES!
+            print(f"   Using your exact settings: {steps} steps, guidance: {guidance}")
+            
+            print("🔄 Running pipeline...")
+            with torch.inference_mode():
+                result = self.pipeline(
+                    prompt=prompt,
+                    num_inference_steps=int(steps),
+                    guidance_scale=guidance,
+                    width=1024,
+                    height=1024,
+                    generator=torch.Generator(device=self.device).manual_seed(int(seed))
+                )
+                
+                if hasattr(result, 'images') and len(result.images) > 0:
+                    image = result.images[0]
+                    print("✅ Image generated successfully!")
+                else:
+                    print("❌ No images in pipeline result")
+                    return None, "❌ Pipeline returned no images"
+            
+            if self.device.type == "mps":
+                torch.mps.empty_cache()
+            
+            # Save with clean filename
+            os.makedirs("outputs/complete_local_flux", exist_ok=True)
+            model_name = model_choice.replace(" ", "_").lower()
+            
+            # Clean LoRA name for filename
+            if lora_choice != "None":
+                lora_name = os.path.basename(lora_choice).replace(".safetensors", "")
+                lora_name = lora_name.replace("/", "_").replace("\\", "_").replace(" ", "_")
+            else:
+                lora_name = "no_lora"
+            filename = f"{model_name}_{lora_name}_{seed}.png"
+            filepath = os.path.join("outputs/complete_local_flux", filename)
+            
+            print(f"💾 Saving to: {filepath}")
+            image.save(filepath, optimize=True)
+            
+            status = f"✅ Generated with {model_choice}"
+            if self.lora_loaded:
+                status += f" + LoRA"
+            if self.local_t5_path:
+                status += " (local T5)"
+            status += f"\n📐 1024x1024 • {steps} steps • Guidance: {guidance} • Seed: {seed}"
+            status += f"\n💾 {filepath}"
+            
+            print("🎉 Generation complete!")
+            return image, status
+            
+        except Exception as e:
+            error_msg = f"❌ Generation failed: {str(e)}"
+            print(error_msg)
+            import traceback
+            traceback.print_exc()
+            return None, error_msg
+    
+    def image_to_base64(self, image):
+        """Convert PIL Image to base64 string"""
+        try:
+            # Resize image if too large (Groq has size limits)
+            max_size = 1024
+            if image.width > max_size or image.height > max_size:
+                image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
+            
+            # Convert to RGB if needed
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Convert to base64
+            buffered = io.BytesIO()
+            image.save(buffered, format="JPEG", quality=85)
+            img_str = base64.b64encode(buffered.getvalue()).decode()
+            return img_str
+        except Exception as e:
+            print(f"❌ Error converting image to base64: {e}")
+            return None
+    
+    def analyze_image_with_groq(self, image):
+        """Analyze image using Groq Vision API and return description"""
+        if not self.groq_api_key:
+            return "❌ Groq API key not configured. Set GROQ_API_KEY environment variable."
+        
+        try:
+            print("🔍 Analyzing image with Groq Vision...")
+            
+            # Convert image to base64
+            base64_image = self.image_to_base64(image)
+            if not base64_image:
+                return "❌ Failed to convert image to base64"
+            
+            # Prepare the API request
+            headers = {
+                "Authorization": f"Bearer {self.groq_api_key}",
+                "Content-Type": "application/json"
+            }
+            
+            payload = {
+                "model": "meta-llama/llama-4-scout-17b-16e-instruct",
+                "messages": [
+                    {
+                        "role": "user",
+                        "content": [
+                            {
+                                "type": "text",
+                                "text": "Describe this image in detail for an AI image generation prompt. Focus on visual elements, style, composition, lighting, colors, mood, and artistic techniques. Be descriptive but concise. Format it as a prompt that could be used to recreate a similar image."
+                            },
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": f"data:image/jpeg;base64,{base64_image}"
+                                }
+                            }
+                        ]
+                    }
+                ],
+                "max_tokens": 300,
+                "temperature": 0.3
+            }
+            
+            # Make the API call
+            response = requests.post(
+                "https://api.groq.com/openai/v1/chat/completions",
+                headers=headers,
+                json=payload,
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                description = result['choices'][0]['message']['content'].strip()
+                print("✅ Image analysis complete!")
+                return description
+            else:
+                error_msg = f"Groq API error: {response.status_code} - {response.text}"
+                print(f"❌ {error_msg}")
+                return f"❌ {error_msg}"
+                
+        except Exception as e:
+            error_msg = f"Error analyzing image: {str(e)}"
+            print(f"❌ {error_msg}")
+            return f"❌ {error_msg}"
+    
+    def create_interface(self):
+        """Create complete interface"""
+        
+        model_choices = list(self.flux_models.keys())
+        if not model_choices:
+            model_choices = ["No models found"]
+        
+        # Clean up LoRA choices - show only the filename
+        clean_lora_choices = ["None"]
+        for lora_path in self.lora_files:
+            filename = os.path.basename(lora_path)  # Get just the filename
+            clean_lora_choices.append(filename)
+        
+        # Create a mapping from clean names to full paths
+        self.lora_path_mapping = {"None": "None"}
+        for lora_path in self.lora_files:
+            filename = os.path.basename(lora_path)
+            self.lora_path_mapping[filename] = lora_path
+        
+        with gr.Blocks(title="Complete Local Flux Studio", theme=gr.themes.Soft()) as interface:
+            
+            gr.Markdown("# 🏠 Complete Local Flux Studio")
+            gr.Markdown("*Using your local Flux models + T5 + LoRA - maximum efficiency!*")
+            
+            # Show what's available locally
+            if self.flux_models:
+                gr.Markdown("## 📁 Your Local Setup:")
+                for name, info in self.flux_models.items():
+                    gr.Markdown(f"- **{name}**: {info['size']:.1f} GB")
+                if self.local_t5_path:
+                    t5_size = os.path.getsize(self.local_t5_path) / (1024*1024*1024)
+                    gr.Markdown(f"- **T5 Encoder**: {t5_size:.1f} GB (local)")
+                if self.local_clip_path:
+                    clip_file = os.path.join(self.local_clip_path, "model.safetensors")
+                    if os.path.exists(clip_file):
+                        clip_size = os.path.getsize(clip_file) / (1024*1024*1024)
+                        gr.Markdown(f"- **CLIP Encoder**: {clip_size:.1f} GB (local)")
+                    else:
+                        gr.Markdown(f"- **CLIP Encoder**: local folder found")
+                if self.local_vae_path:
+                    if os.path.isdir(self.local_vae_path):
+                        gr.Markdown(f"- **VAE**: cached (local)")
+                    else:
+                        vae_size = os.path.getsize(self.local_vae_path) / (1024*1024*1024)
+                        gr.Markdown(f"- **VAE**: {vae_size:.1f} GB (local)")
+                gr.Markdown(f"- **LoRA Models**: {len(self.lora_files)} found")
+            
+            # IMAGE ANALYSIS SECTION - MOVED TO TOP LEVEL
+            gr.Markdown("## 🔍 Image Analysis with Groq Vision")
+            gr.Markdown("*Upload an image to automatically generate a prompt description*")
+            
+            input_image = gr.Image(
+                label="📤 Upload Image to Analyze", 
+                type="pil",
+                height=200
+            )
+            
+            analyze_btn = gr.Button(
+                "🔍 Analyze Image with Groq Vision",
+                variant="primary",
+                size="lg"
+            )
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("## 🎨 Generate")
+                    
+                    model_choice = gr.Dropdown(
+                        choices=model_choices,
+                        value=model_choices[0] if model_choices[0] != "No models found" else None,
+                        label="Flux Model"
+                    )
+                    
+                    lora_choice = gr.Dropdown(
+                        choices=clean_lora_choices,
+                        value=clean_lora_choices[1] if len(clean_lora_choices) > 1 else "None",
+                        label="Your LoRA"
+                    )
+                    
+                    prompt = gr.Textbox(
+                        label="Prompt",
+                        value="artistic lifestyle portrait, person wearing vibrant orange bucket hat, expressive face, golden hour lighting, street style photography, film aesthetic",
+                        lines=6,
+                        placeholder="Enter your prompt here, or upload an image above and click 'Analyze' to auto-generate..."
+                    )
+                    
+                    with gr.Row():
+                        steps = gr.Slider(4, 50, value=20, label="Steps")
+                        guidance = gr.Slider(0.0, 10.0, value=3.5, label="Guidance")
+                        seed = gr.Number(value=42, label="Seed")
+                    
+                    generate_btn = gr.Button("🏠 Generate Locally", variant="primary", size="lg")
+                
+                with gr.Column(scale=1):
+                    output_image = gr.Image(label="Generated Image", height=600)
+                    status = gr.Textbox(label="Status", interactive=False, lines=4)
+            
+            # Quick prompts for your artistic style
+            gr.Markdown("## 🎨 Your Artistic Style")
+            with gr.Row():
+                portrait_btn = gr.Button("🎭 Portrait")
+                vibrant_btn = gr.Button("🌈 Vibrant") 
+                street_btn = gr.Button("📸 Street")
+            
+            # Event handlers
+            analyze_btn.click(
+                fn=self.analyze_image_with_groq,
+                inputs=[input_image],
+                outputs=[prompt]
+            )
+            
+            portrait_btn.click(
+                lambda: "artistic lifestyle portrait, person with expressive face, vibrant clothing, golden hour lighting",
+                outputs=[prompt]
+            )
+            
+            vibrant_btn.click(
+                lambda: "person in colorful streetwear, vibrant orange bucket hat, street photography, film aesthetic",
+                outputs=[prompt]
+            )
+            
+            street_btn.click(
+                lambda: "urban street style portrait, candid expression, natural lighting, contemporary photography",
+                outputs=[prompt]
+            )
+            
+            generate_btn.click(
+                fn=self.generate_image,
+                inputs=[prompt, model_choice, lora_choice, steps, guidance, seed],
+                outputs=[output_image, status]
+            )
+        
+        return interface
+    
+    def launch(self):
+        """Launch complete interface"""
+        interface = self.create_interface()
+        
+        port = find_free_port()
+        print("🏠 Launching Complete Local Flux Studio...")
+        print(f"📱 Interface: http://localhost:{port}")
+        print("🚀 Using maximum local resources!")
+        
+        try:
+            interface.launch(
+                server_port=port,
+                share=True,
+                inbrowser=True
+                
+            )
+        except Exception as e:
+            print(f"❌ Launch failed: {e}")
+
+if __name__ == "__main__":
+    # Check if sentencepiece is installed
+    try:
+        import sentencepiece
+        print("✅ SentencePiece found")
+    except ImportError:
+        print("❌ SentencePiece not found")
+        print("🔧 Install with: pip install sentencepiece protobuf")
+        exit(1)
+    
+    interface = CompleteLocalFlux()
+    interface.launch()