ollamadiffuser 1.2.0__py3-none-any.whl → 1.2.2__py3-none-any.whl

ollamadiffuser/__init__.py

@@ -4,7 +4,7 @@ OllamaDiffuser - Local AI Image Generation with Ollama-style CLI
 A tool for managing and running Stable Diffusion, FLUX.1, and other AI image generation models locally.
 """
 
-__version__ = "1.2.0"
+__version__ = "1.2.2"
 __author__ = "OllamaDiffuser Team"
 __email__ = "ollamadiffuser@gmail.com"
 __description__ = "🎨 Local AI Image Generation with Ollama-style CLI for Stable Diffusion, FLUX.1, and LoRA support"

ollamadiffuser/api/server.py

@@ -20,7 +20,9 @@ class GenerateRequest(BaseModel):
     prompt: str
     negative_prompt: str = "low quality, bad anatomy, worst quality, low resolution"
     num_inference_steps: Optional[int] = None
+    steps: Optional[int] = None  # Alias for num_inference_steps for convenience
     guidance_scale: Optional[float] = None
+    cfg_scale: Optional[float] = None  # Alias for guidance_scale for convenience
     width: int = 1024
     height: int = 1024
     control_image_path: Optional[str] = None  # Path to control image file
@@ -232,12 +234,18 @@ def create_app() -> FastAPI:
             # Get current loaded inference engine
             engine = model_manager.loaded_model
             
+            # Handle parameter aliasing - prioritize shorter names for convenience
+            steps = request.steps if request.steps is not None else request.num_inference_steps
+            guidance = request.cfg_scale if request.cfg_scale is not None else request.guidance_scale
+            
             # Generate image
             image = engine.generate_image(
                 prompt=request.prompt,
                 negative_prompt=request.negative_prompt,
-                num_inference_steps=request.num_inference_steps,
-                guidance_scale=request.guidance_scale,
+                num_inference_steps=steps,
+                steps=steps,  # Pass both for GGUF compatibility
+                guidance_scale=guidance,
+                cfg_scale=guidance,  # Pass both for GGUF compatibility
                 width=request.width,
                 height=request.height,
                 control_image=request.control_image_path,

ollamadiffuser/core/models/gguf_loader.py

@@ -46,6 +46,7 @@ class GGUFModelLoader:
             
         # Map variant to actual file names
         variant_mapping = {
+            # FLUX.1-dev variants
             'gguf-q2k': 'flux1-dev-Q2_K.gguf',
             'gguf-q3ks': 'flux1-dev-Q3_K_S.gguf', 
             'gguf-q4ks': 'flux1-dev-Q4_K_S.gguf',
@@ -57,6 +58,52 @@ class GGUFModelLoader:
             'gguf-q6k': 'flux1-dev-Q6_K.gguf',
             'gguf-q8': 'flux1-dev-Q8_0.gguf',
             'gguf-f16': 'flux1-dev-F16.gguf',
+            
+            # FLUX.1-schnell variants
+            'gguf-schnell': 'flux1-schnell-F16.gguf',  # Default to F16
+            'gguf-schnell-q2k': 'flux1-schnell-Q2_K.gguf',
+            'gguf-schnell-q3ks': 'flux1-schnell-Q3_K_S.gguf',
+            'gguf-schnell-q4-0': 'flux1-schnell-Q4_0.gguf',
+            'gguf-schnell-q4-1': 'flux1-schnell-Q4_1.gguf',
+            'gguf-schnell-q4ks': 'flux1-schnell-Q4_K_S.gguf',
+            'gguf-schnell-q5-0': 'flux1-schnell-Q5_0.gguf',
+            'gguf-schnell-q5-1': 'flux1-schnell-Q5_1.gguf',
+            'gguf-schnell-q5ks': 'flux1-schnell-Q5_K_S.gguf',
+            'gguf-schnell-q6k': 'flux1-schnell-Q6_K.gguf',
+            'gguf-schnell-q8': 'flux1-schnell-Q8_0.gguf',
+            'gguf-schnell-f16': 'flux1-schnell-F16.gguf',
+            
+            # Stable Diffusion 3.5 Large variants
+            'gguf-large': 'sd3.5_large-F16.gguf',  # Default to F16
+            'gguf-large-q4-0': 'sd3.5_large-Q4_0.gguf',
+            'gguf-large-q4-1': 'sd3.5_large-Q4_1.gguf',
+            'gguf-large-q5-0': 'sd3.5_large-Q5_0.gguf',
+            'gguf-large-q5-1': 'sd3.5_large-Q5_1.gguf',
+            'gguf-large-q8-0': 'sd3.5_large-Q8_0.gguf',
+            'gguf-large-f16': 'sd3.5_large-F16.gguf',
+            
+            # Stable Diffusion 3.5 Large Turbo variants
+            'gguf-large-turbo': 'sd3.5_large_turbo.gguf',  # Default to standard format
+            'gguf-large-turbo-q4-0': 'sd3.5_large_turbo-Q4_0.gguf',
+            'gguf-large-turbo-q4-1': 'sd3.5_large_turbo-Q4_1.gguf',
+            'gguf-large-turbo-q5-0': 'sd3.5_large_turbo-Q5_0.gguf',
+            'gguf-large-turbo-q5-1': 'sd3.5_large_turbo-Q5_1.gguf',
+            'gguf-large-turbo-q8-0': 'sd3.5_large_turbo-Q8_0.gguf',
+            'gguf-large-turbo-f16': 'sd3.5_large_turbo-F16.gguf',
+            
+            # Other model variants
+            'gguf-medium': 'sd3.5-medium-F16.gguf',
+            'gguf-sd3-medium': 'sd3-medium-F16.gguf',
+            'gguf-lite': 'flux-lite-8b-F16.gguf',
+            'gguf-distilled': 'flux-dev-de-distill-F16.gguf',
+            'gguf-fill': 'flux-fill-dev-F16.gguf',
+            'gguf-full': 'hidream-i1-full-F16.gguf',
+            'gguf-dev': 'hidream-i1-dev-F16.gguf',
+            'gguf-fast': 'hidream-i1-fast-F16.gguf',
+            'gguf-i2v': 'ltx-video-i2v-F16.gguf',
+            'gguf-2b': 'ltx-video-2b-F16.gguf',
+            'gguf-t2v': 'hunyuan-video-t2v-F16.gguf',
+            
             'gguf': 'flux1-dev-Q4_K_S.gguf',  # Default to Q4_K_S
         }
         
@@ -132,27 +179,59 @@ class GGUFModelLoader:
             # Download required components
             components = self.download_required_components(model_path)
             
-            # Verify all components are available
-            missing_components = [name for name, path in components.items() if path is None]
-            if missing_components:
-                logger.error(f"Missing required components: {missing_components}")
-                return False
-            
-            # Initialize stable-diffusion.cpp
-            if not GGUF_AVAILABLE:
-                logger.error("stable-diffusion-cpp-python not properly installed")
-                return False
+            # Detect model type for appropriate validation
+            is_sd35 = any(pattern in model_name.lower() for pattern in ['3.5', 'sd3.5', 'stable-diffusion-3-5'])
+            
+            # Validate components based on model type
+            if is_sd35:
+                # SD 3.5 models need VAE, CLIP-L, CLIP-G, and T5XXL
+                required_components = ['vae', 'clip_l', 'clip_g', 't5xxl']
+                missing_components = [name for name in required_components if not components.get(name)]
+                if missing_components:
+                    logger.error(f"Missing required SD 3.5 components: {missing_components}")
+                    return False
+            else:
+                # FLUX models need VAE, CLIP-L, and T5XXL (no CLIP-G)
+                required_components = ['vae', 'clip_l', 't5xxl']
+                missing_components = [name for name in required_components if not components.get(name)]
+                if missing_components:
+                    logger.error(f"Missing required FLUX components: {missing_components}")
+                    return False
+            
+            # Initialize the stable-diffusion.cpp model
+            logger.info("Loading GGUF model with stable-diffusion.cpp...")
+            
+            if is_sd35:
+                logger.info("Detected SD 3.5 model - using appropriate configuration")
                 
-            # Create StableDiffusion instance with correct API for FLUX
-            # For FLUX models, use diffusion_model_path instead of model_path
-            self.stable_diffusion = StableDiffusion(
-                diffusion_model_path=str(gguf_file),  # FLUX GGUF models use this parameter
-                vae_path=str(components['vae']),
-                clip_l_path=str(components['clip_l']),
-                t5xxl_path=str(components['t5xxl']),
-                vae_decode_only=True,  # For txt2img only
-                n_threads=-1  # Auto-detect threads
-            )
+                sd_params = {
+                    'diffusion_model_path': str(gguf_file),
+                    'n_threads': 4
+                }
+                
+                if components['vae']:
+                    sd_params['vae_path'] = str(components['vae'])
+                if components['clip_l']:
+                    sd_params['clip_l_path'] = str(components['clip_l'])
+                if components['clip_g']:
+                    sd_params['clip_g_path'] = str(components['clip_g'])
+                if components['t5xxl']:
+                    sd_params['t5xxl_path'] = str(components['t5xxl'])
+                
+                logger.info(f"Initializing SD 3.5 model with params: {sd_params}")
+                self.stable_diffusion = StableDiffusion(**sd_params)
+                
+            else:
+                # FLUX models use different parameter structure
+                logger.info("Detected FLUX model - using CLIP-L and T5-XXL configuration")
+                self.stable_diffusion = StableDiffusion(
+                    diffusion_model_path=str(gguf_file),
+                    vae_path=str(components['vae']),
+                    clip_l_path=str(components['clip_l']),
+                    t5xxl_path=str(components['t5xxl']),
+                    vae_decode_only=True,
+                    n_threads=-1
+                )
             
             self.model_path = str(gguf_file)
             self.model_config = model_config
@@ -179,17 +258,17 @@ class GGUFModelLoader:
             width = kwargs.get('width', 1024)
             height = kwargs.get('height', 1024)
             
-            # Support both 'steps' and 'num_inference_steps'
-            steps = kwargs.get('steps') or kwargs.get('num_inference_steps', 20)  # Increased for better quality
+            # Support both 'steps' and 'num_inference_steps' - ensure not None
+            steps = kwargs.get('steps') or kwargs.get('num_inference_steps') or 20
             
-            # Support both 'cfg_scale' and 'guidance_scale' - FLUX works best with low CFG
-            cfg_scale = kwargs.get('cfg_scale') or kwargs.get('guidance_scale', 1.0)  # FLUX optimized CFG (reduced from 1.2)
+            # Support both 'cfg_scale' and 'guidance_scale' - FLUX works best with low CFG - ensure not None
+            cfg_scale = kwargs.get('cfg_scale') or kwargs.get('guidance_scale') or 1.0
             
             seed = kwargs.get('seed', 42)
             negative_prompt = kwargs.get('negative_prompt', "")
             
             # Allow custom sampler, with FLUX-optimized default
-            sampler = kwargs.get('sampler', kwargs.get('sample_method', 'dpmpp2m'))  # Better sampler for FLUX (fixed name)
+            sampler = kwargs.get('sampler', kwargs.get('sample_method', 'dpmpp2m'))
             
             # Validate sampler and provide fallback
             valid_samplers = ['euler_a', 'euler', 'heun', 'dpm2', 'dpmpp2s_a', 'dpmpp2m', 'dpmpp2mv2', 'ipndm', 'ipndm_v', 'lcm', 'ddim_trailing', 'tcd']
@@ -197,6 +276,13 @@ class GGUFModelLoader:
                 logger.warning(f"Invalid sampler '{sampler}', falling back to 'dpmpp2m'")
                 sampler = 'dpmpp2m'
             
+            # Ensure all values are proper types and not None
+            steps = int(steps) if steps is not None else 20
+            cfg_scale = float(cfg_scale) if cfg_scale is not None else 1.0
+            width = int(width) if width is not None else 1024
+            height = int(height) if height is not None else 1024
+            seed = int(seed) if seed is not None else 42
+            
             logger.info(f"Generating image: {width}x{height}, steps={steps}, cfg={cfg_scale}, sampler={sampler}, negative_prompt={negative_prompt}")
             
             # Log model quantization info for quality assessment
@@ -219,7 +305,7 @@ class GGUFModelLoader:
                     cfg_scale=cfg_scale,
                     width=width,
                     height=height,
-                    sample_method=sampler,  # Use optimized sampler
+                    sample_method=sampler,
                     sample_steps=steps,
                     seed=seed
                 )
@@ -313,17 +399,64 @@ class GGUFModelLoader:
         """
         # Map variant to specific GGUF file patterns
         variant_patterns = {
+            # FLUX.1-dev variants
             'gguf-q2k': ['*Q2_K*.gguf'],
             'gguf-q3ks': ['*Q3_K_S*.gguf'], 
+            'gguf-q4ks': ['*Q4_K_S*.gguf'],
             'gguf-q4-0': ['*Q4_0*.gguf'],
             'gguf-q4-1': ['*Q4_1*.gguf'],
-            'gguf-q4ks': ['*Q4_K_S*.gguf'],
+            'gguf-q5ks': ['*Q5_K_S*.gguf'],
             'gguf-q5-0': ['*Q5_0*.gguf'],
             'gguf-q5-1': ['*Q5_1*.gguf'],
-            'gguf-q5ks': ['*Q5_K_S*.gguf'],
             'gguf-q6k': ['*Q6_K*.gguf'],
-            'gguf-q8-0': ['*Q8_0*.gguf'],
-            'gguf-f16': ['*F16*.gguf']
+            'gguf-q8': ['*Q8_0*.gguf'],
+            'gguf-q8-0': ['*Q8_0*.gguf'],  # Keep for backward compatibility
+            'gguf-f16': ['*F16*.gguf'],
+            
+            # FLUX.1-schnell variants
+            'gguf-schnell': ['*flux1-schnell*F16*.gguf'],
+            'gguf-schnell-q2k': ['*flux1-schnell*Q2_K*.gguf'],
+            'gguf-schnell-q3ks': ['*flux1-schnell*Q3_K_S*.gguf'],
+            'gguf-schnell-q4-0': ['*flux1-schnell*Q4_0*.gguf'],
+            'gguf-schnell-q4-1': ['*flux1-schnell*Q4_1*.gguf'],
+            'gguf-schnell-q4ks': ['*flux1-schnell*Q4_K_S*.gguf'],
+            'gguf-schnell-q5-0': ['*flux1-schnell*Q5_0*.gguf'],
+            'gguf-schnell-q5-1': ['*flux1-schnell*Q5_1*.gguf'],
+            'gguf-schnell-q5ks': ['*flux1-schnell*Q5_K_S*.gguf'],
+            'gguf-schnell-q6k': ['*flux1-schnell*Q6_K*.gguf'],
+            'gguf-schnell-q8': ['*flux1-schnell*Q8_0*.gguf'],
+            'gguf-schnell-f16': ['*flux1-schnell*F16*.gguf'],
+            
+            # Stable Diffusion 3.5 Large variants
+            'gguf-large': ['*sd3.5_large-F16*.gguf'],
+            'gguf-large-q4-0': ['*sd3.5_large-Q4_0*.gguf'],
+            'gguf-large-q4-1': ['*sd3.5_large-Q4_1*.gguf'],
+            'gguf-large-q5-0': ['*sd3.5_large-Q5_0*.gguf'],
+            'gguf-large-q5-1': ['*sd3.5_large-Q5_1*.gguf'],
+            'gguf-large-q8-0': ['*sd3.5_large-Q8_0*.gguf'],
+            'gguf-large-f16': ['*sd3.5_large-F16*.gguf'],
+            
+            # Stable Diffusion 3.5 Large Turbo variants
+            'gguf-large-turbo': ['*sd3.5_large_turbo*F16*.gguf'],
+            'gguf-large-turbo-q4-0': ['*sd3.5_large_turbo*Q4_0*.gguf'],
+            'gguf-large-turbo-q4-1': ['*sd3.5_large_turbo*Q4_1*.gguf'],
+            'gguf-large-turbo-q5-0': ['*sd3.5_large_turbo*Q5_0*.gguf'],
+            'gguf-large-turbo-q5-1': ['*sd3.5_large_turbo*Q5_1*.gguf'],
+            'gguf-large-turbo-q8-0': ['*sd3.5_large_turbo*Q8_0*.gguf'],
+            'gguf-large-turbo-f16': ['*sd3.5_large_turbo*F16*.gguf'],
+            
+            # Other model variants
+            'gguf-medium': ['*sd3.5-medium*.gguf'],
+            'gguf-sd3-medium': ['*sd3-medium*.gguf'],
+            'gguf-lite': ['*flux-lite-8b*.gguf'],
+            'gguf-distilled': ['*flux-dev-de-distill*.gguf'],
+            'gguf-fill': ['*flux-fill-dev*.gguf'],
+            'gguf-full': ['*hidream-i1-full*.gguf'],
+            'gguf-dev': ['*hidream-i1-dev*.gguf'],
+            'gguf-fast': ['*hidream-i1-fast*.gguf'],
+            'gguf-i2v': ['*ltx-video-i2v*.gguf', '*hunyuan-video-i2v*.gguf'],
+            'gguf-2b': ['*ltx-video-2b*.gguf'],
+            'gguf-t2v': ['*hunyuan-video-t2v*.gguf'],
         }
         
         # Get the specific GGUF file pattern for this variant
@@ -342,26 +475,125 @@ class GGUFModelLoader:
         # Include the specific GGUF model file
         allow_patterns = essential_files + gguf_pattern
         
-        # Create ignore patterns - ignore all other GGUF variants
-        all_gguf_variants = []
-        for pattern_list in variant_patterns.values():
-            all_gguf_variants.extend(pattern_list)
+        # Create ignore patterns based on variant name (not pattern content)
+        # This prevents conflicts between allow and ignore patterns
+        ignore_patterns = []
         
-        # Remove the current variant from ignore list
-        ignore_patterns = [p for p in all_gguf_variants if p not in gguf_pattern]
+        # Determine model family from variant name
+        if variant.startswith('gguf-schnell') or 'schnell' in variant:
+            # FLUX.1-schnell variants - ignore other model types
+            ignore_patterns = [
+                '*flux1-dev*.gguf',     # Ignore FLUX.1-dev
+                '*sd3.5*.gguf',         # Ignore SD 3.5
+                '*ltx-video*.gguf',     # Ignore video models
+                '*hidream*.gguf',       # Ignore HiDream
+                '*hunyuan*.gguf'        # Ignore Hunyuan
+            ]
+            # Ignore other schnell quantizations except the one we want
+            for other_variant, other_patterns in variant_patterns.items():
+                if (other_variant.startswith('gguf-schnell') and 
+                    other_variant != variant and 
+                    other_variant != 'gguf'):
+                    # Only ignore if it doesn't conflict with our allow patterns
+                    for pattern in other_patterns:
+                        if pattern not in gguf_pattern:
+                            ignore_patterns.append(pattern)
+                    
+        elif (variant.startswith('gguf-large-turbo') or 
+              'large-turbo' in variant or 
+              variant.startswith('gguf-large') or
+              'sd3.5' in variant or
+              'stable-diffusion-3' in variant):
+            # SD 3.5 variants - ignore other model types  
+            ignore_patterns = [
+                '*flux1-dev*.gguf',     # Ignore FLUX.1-dev
+                '*flux1-schnell*.gguf', # Ignore FLUX.1-schnell
+                '*ltx-video*.gguf',     # Ignore video models
+                '*hidream*.gguf',       # Ignore HiDream  
+                '*hunyuan*.gguf'        # Ignore Hunyuan
+            ]
+            # Ignore other SD 3.5 quantizations except the one we want
+            for other_variant, other_patterns in variant_patterns.items():
+                if (('large' in other_variant or 'sd3.5' in other_variant or 'stable-diffusion-3' in other_variant) and 
+                    other_variant != variant and 
+                    other_variant != 'gguf'):
+                    # Only ignore if it doesn't conflict with our allow patterns
+                    for pattern in other_patterns:
+                        if pattern not in gguf_pattern:
+                            ignore_patterns.append(pattern)
+                    
+        elif ('video' in variant or 
+              'i2v' in variant or 
+              't2v' in variant or 
+              '2b' in variant):
+            # Video model variants
+            ignore_patterns = [
+                '*flux1-dev*.gguf',
+                '*flux1-schnell*.gguf',
+                '*sd3.5*.gguf'
+            ]
+            
+        elif ('hidream' in variant or 
+              'full' in variant or 
+              'fast' in variant):
+            # HiDream variants  
+            ignore_patterns = [
+                '*flux1-dev*.gguf',
+                '*flux1-schnell*.gguf', 
+                '*sd3.5*.gguf',
+                '*ltx-video*.gguf',
+                '*hunyuan*.gguf'
+            ]
+            
+        else:
+            # FLUX.1-dev variants (default case) - ignore other model types
+            ignore_patterns = [
+                '*flux1-schnell*.gguf', # Ignore FLUX.1-schnell
+                '*sd3.5*.gguf',         # Ignore SD 3.5
+                '*ltx-video*.gguf',     # Ignore video models
+                '*hidream*.gguf',       # Ignore HiDream
+                '*hunyuan*.gguf'        # Ignore Hunyuan
+            ]
+            # Ignore other FLUX.1-dev quantizations except the one we want
+            for other_variant, other_patterns in variant_patterns.items():
+                if (not other_variant.startswith('gguf-schnell') and 
+                    not 'large' in other_variant and
+                    not 'sd3.5' in other_variant and
+                    not 'video' in other_variant and
+                    not 'hidream' in other_variant and
+                    other_variant != variant and 
+                    other_variant != 'gguf'):
+                    # Only ignore if it doesn't conflict with our allow patterns
+                    for pattern in other_patterns:
+                        if pattern not in gguf_pattern:
+                            ignore_patterns.append(pattern)
         
         return {
             'allow_patterns': allow_patterns,
             'ignore_patterns': ignore_patterns
         }
     
+    def _get_model_family(self, pattern: str) -> str:
+        """Extract model family from a pattern (e.g., flux1-dev, flux1-schnell, sd3.5-large)"""
+        if 'flux1-dev' in pattern:
+            return 'flux1-dev'
+        elif 'flux1-schnell' in pattern:
+            return 'flux1-schnell'
+        elif 'sd3.5-large-turbo' in pattern:
+            return 'sd3.5-large-turbo'
+        elif 'sd3.5-large' in pattern:
+            return 'sd3.5-large'
+        elif 'sd3.5' in pattern:
+            return 'sd3.5'
+        else:
+            return pattern.split('*')[1].split('*')[0] if '*' in pattern else pattern
+    
     def download_required_components(self, model_path: Path) -> Dict[str, Optional[Path]]:
         """Download or locate required VAE, CLIP-L, and T5XXL components
         
-        For FLUX GGUF models, these components need to be downloaded separately:
-        - VAE: ae.safetensors from black-forest-labs/FLUX.1-dev
-        - CLIP-L: clip_l.safetensors from comfyanonymous/flux_text_encoders
-        - T5XXL: t5xxl_fp16.safetensors from comfyanonymous/flux_text_encoders
+        For different model types:
+        - FLUX GGUF models need: ae.safetensors (VAE), clip_l.safetensors, t5xxl_fp16.safetensors
+        - SD 3.5 models need: different text encoders and VAE
         """
         from ..utils.download_utils import robust_snapshot_download
         from ..config.settings import settings
@@ -369,66 +601,168 @@ class GGUFModelLoader:
         components = {
             'vae': None,
             'clip_l': None, 
+            'clip_g': None,  # Needed for SD 3.5 models
             't5xxl': None
         }
         
-        logger.info("Downloading required FLUX components...")
+        # Detect model type based on model path or name
+        model_name = model_path.name.lower()
+        is_sd35 = any(pattern in model_name for pattern in ['3.5', 'sd3.5', 'stable-diffusion-3-5'])
+        is_flux = any(x in model_name for x in ['flux', 'flux1'])
+        
+        logger.info(f"Downloading required components for model type: {'SD3.5' if is_sd35 else 'FLUX' if is_flux else 'Unknown'}")
         
         try:
-            # Download VAE from official FLUX repository
-            vae_dir = model_path.parent / "flux_vae"
-            if not (vae_dir / "ae.safetensors").exists():
-                logger.info("Downloading FLUX VAE...")
-                robust_snapshot_download(
-                    repo_id="black-forest-labs/FLUX.1-dev",
-                    local_dir=str(vae_dir),
-                    cache_dir=str(settings.cache_dir),
-                    allow_patterns=['ae.safetensors'],
-                    max_retries=3
-                )
-            
-            vae_path = vae_dir / "ae.safetensors"
-            if vae_path.exists():
-                components['vae'] = vae_path
-                logger.info(f"VAE found at: {vae_path}")
-            
-            # Download text encoders
-            text_encoders_dir = model_path.parent / "flux_text_encoders"
-            
-            # Download CLIP-L
-            if not (text_encoders_dir / "clip_l.safetensors").exists():
-                logger.info("Downloading CLIP-L text encoder...")
-                robust_snapshot_download(
-                    repo_id="comfyanonymous/flux_text_encoders",
-                    local_dir=str(text_encoders_dir),
-                    cache_dir=str(settings.cache_dir),
-                    allow_patterns=['clip_l.safetensors'],
-                    max_retries=3
-                )
-            
-            clip_l_path = text_encoders_dir / "clip_l.safetensors"
-            if clip_l_path.exists():
-                components['clip_l'] = clip_l_path
-                logger.info(f"CLIP-L found at: {clip_l_path}")
-            
-            # Download T5XXL  
-            if not (text_encoders_dir / "t5xxl_fp16.safetensors").exists():
-                logger.info("Downloading T5XXL text encoder...")
-                robust_snapshot_download(
-                    repo_id="comfyanonymous/flux_text_encoders", 
-                    local_dir=str(text_encoders_dir),
-                    cache_dir=str(settings.cache_dir),
-                    allow_patterns=['t5xxl_fp16.safetensors'],
-                    max_retries=3
-                )
-            
-            t5xxl_path = text_encoders_dir / "t5xxl_fp16.safetensors"
-            if t5xxl_path.exists():
-                components['t5xxl'] = t5xxl_path
-                logger.info(f"T5XXL found at: {t5xxl_path}")
+            if is_sd35:
+                # SD 3.5 models - use SD 3.5 specific components
+                logger.info("Downloading SD 3.5 components...")
+                
+                # Download SD 3.5 VAE
+                vae_dir = model_path.parent / "sd35_vae"
+                if not (vae_dir / "vae.safetensors").exists():
+                    logger.info("Downloading SD 3.5 VAE...")
+                    robust_snapshot_download(
+                        repo_id="stabilityai/stable-diffusion-3.5-large",
+                        local_dir=str(vae_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['vae/diffusion_pytorch_model.safetensors'],
+                        max_retries=3
+                    )
+                    # Move to expected location if needed
+                    vae_source = vae_dir / "vae" / "diffusion_pytorch_model.safetensors"
+                    vae_target = vae_dir / "vae.safetensors"
+                    if vae_source.exists() and not vae_target.exists():
+                        vae_source.rename(vae_target)
+                
+                vae_path = vae_dir / "vae.safetensors"
+                if vae_path.exists():
+                    components['vae'] = vae_path
+                    logger.info(f"SD 3.5 VAE found at: {vae_path}")
+                
+                # Download SD 3.5 text encoders
+                text_encoders_dir = model_path.parent / "sd35_text_encoders"
+                
+                # Download CLIP-L for SD 3.5
+                if not (text_encoders_dir / "clip_l.safetensors").exists():
+                    logger.info("Downloading SD 3.5 CLIP-L text encoder...")
+                    robust_snapshot_download(
+                        repo_id="stabilityai/stable-diffusion-3.5-large",
+                        local_dir=str(text_encoders_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['text_encoders/clip_l.safetensors'],
+                        max_retries=3
+                    )
+                    # Move to expected location if needed
+                    clip_source = text_encoders_dir / "text_encoders" / "clip_l.safetensors"
+                    clip_target = text_encoders_dir / "clip_l.safetensors"
+                    if clip_source.exists() and not clip_target.exists():
+                        clip_source.rename(clip_target)
+                
+                clip_l_path = text_encoders_dir / "clip_l.safetensors"
+                if clip_l_path.exists():
+                    components['clip_l'] = clip_l_path
+                    logger.info(f"SD 3.5 CLIP-L found at: {clip_l_path}")
+                
+                # Download CLIP-G for SD 3.5  
+                if not (text_encoders_dir / "clip_g.safetensors").exists():
+                    logger.info("Downloading SD 3.5 CLIP-G text encoder...")
+                    robust_snapshot_download(
+                        repo_id="stabilityai/stable-diffusion-3.5-large",
+                        local_dir=str(text_encoders_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['text_encoders/clip_g.safetensors'],
+                        max_retries=3
+                    )
+                    # Move to expected location if needed
+                    clipg_source = text_encoders_dir / "text_encoders" / "clip_g.safetensors"
+                    clipg_target = text_encoders_dir / "clip_g.safetensors"
+                    if clipg_source.exists() and not clipg_target.exists():
+                        clipg_source.rename(clipg_target)
+                
+                clip_g_path = text_encoders_dir / "clip_g.safetensors"
+                if clip_g_path.exists():
+                    components['clip_g'] = clip_g_path
+                    logger.info(f"SD 3.5 CLIP-G found at: {clip_g_path}")
+                
+                # Download T5XXL for SD 3.5
+                if not (text_encoders_dir / "t5xxl_fp16.safetensors").exists():
+                    logger.info("Downloading SD 3.5 T5XXL text encoder...")
+                    robust_snapshot_download(
+                        repo_id="stabilityai/stable-diffusion-3.5-large",
+                        local_dir=str(text_encoders_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['text_encoders/t5xxl_fp16.safetensors'],
+                        max_retries=3
+                    )
+                    # Move to expected location if needed
+                    t5_source = text_encoders_dir / "text_encoders" / "t5xxl_fp16.safetensors"
+                    t5_target = text_encoders_dir / "t5xxl_fp16.safetensors"
+                    if t5_source.exists() and not t5_target.exists():
+                        t5_source.rename(t5_target)
+                
+                t5xxl_path = text_encoders_dir / "t5xxl_fp16.safetensors"
+                if t5xxl_path.exists():
+                    components['t5xxl'] = t5xxl_path
+                    logger.info(f"SD 3.5 T5XXL found at: {t5xxl_path}")
+                    
+            else:
+                # FLUX models (default) - use FLUX specific components
+                logger.info("Downloading FLUX components...")
+                
+                # Download VAE from official FLUX repository
+                vae_dir = model_path.parent / "flux_vae"
+                if not (vae_dir / "ae.safetensors").exists():
+                    logger.info("Downloading FLUX VAE...")
+                    robust_snapshot_download(
+                        repo_id="black-forest-labs/FLUX.1-dev",
+                        local_dir=str(vae_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['ae.safetensors'],
+                        max_retries=3
+                    )
+                
+                vae_path = vae_dir / "ae.safetensors"
+                if vae_path.exists():
+                    components['vae'] = vae_path
+                    logger.info(f"FLUX VAE found at: {vae_path}")
+                
+                # Download text encoders
+                text_encoders_dir = model_path.parent / "flux_text_encoders"
+                
+                # Download CLIP-L
+                if not (text_encoders_dir / "clip_l.safetensors").exists():
+                    logger.info("Downloading FLUX CLIP-L text encoder...")
+                    robust_snapshot_download(
+                        repo_id="comfyanonymous/flux_text_encoders",
+                        local_dir=str(text_encoders_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['clip_l.safetensors'],
+                        max_retries=3
+                    )
+                
+                clip_l_path = text_encoders_dir / "clip_l.safetensors"
+                if clip_l_path.exists():
+                    components['clip_l'] = clip_l_path
+                    logger.info(f"FLUX CLIP-L found at: {clip_l_path}")
+                
+                # Download T5XXL  
+                if not (text_encoders_dir / "t5xxl_fp16.safetensors").exists():
+                    logger.info("Downloading FLUX T5XXL text encoder...")
+                    robust_snapshot_download(
+                        repo_id="comfyanonymous/flux_text_encoders", 
+                        local_dir=str(text_encoders_dir),
+                        cache_dir=str(settings.cache_dir),
+                        allow_patterns=['t5xxl_fp16.safetensors'],
+                        max_retries=3
+                    )
+                
+                t5xxl_path = text_encoders_dir / "t5xxl_fp16.safetensors"
+                if t5xxl_path.exists():
+                    components['t5xxl'] = t5xxl_path
+                    logger.info(f"FLUX T5XXL found at: {t5xxl_path}")
                 
         except Exception as e:
-            logger.error(f"Failed to download FLUX components: {e}")
+            logger.error(f"Failed to download components: {e}")
             
         return components
 

{ollamadiffuser-1.2.0.dist-info → ollamadiffuser-1.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ollamadiffuser
-Version: 1.2.0
+Version: 1.2.2
 Summary: 🎨 Local AI Image Generation with Ollama-style CLI for Stable Diffusion, FLUX.1, and LoRA support
 Home-page: https://github.com/ollamadiffuser/ollamadiffuser
 Author: OllamaDiffuser Team
@@ -82,6 +82,63 @@ Dynamic: requires-python
 
 ---
 
+## 🔑 Hugging Face Authentication
+
+**Do you need a Hugging Face token?** It depends on which models you want to use!
+
+### 🟢 Models that DON'T require a token:
+- **FLUX.1-schnell** - Apache 2.0 license, ready to use ✅
+- **Stable Diffusion 1.5** - Basic model, no authentication needed ✅
+- **Most ControlNet models** - Generally public access ✅
+
+### 🟡 Models that DO require a token:
+- **FLUX.1-dev** - Requires HF token and license agreement ⚠️
+- **Stable Diffusion 3.5** - Requires HF token and license agreement ⚠️
+- **Some premium LoRAs** - Gated models from Hugging Face ⚠️
+
+### 🚀 Quick Setup
+
+**For basic usage** (no token needed):
+```bash
+# These work immediately without any setup:
+ollamadiffuser pull flux.1-schnell
+ollamadiffuser pull stable-diffusion-1.5
+```
+
+**For advanced models** (token required):
+```bash
+# 1. Set your token
+export HF_TOKEN=your_token_here
+
+# 2. Now you can access gated models
+ollamadiffuser pull flux.1-dev
+ollamadiffuser pull stable-diffusion-3.5-medium
+```
+
+### 🔧 How to get a Hugging Face token:
+
+1. **Create account**: Visit [huggingface.co](https://huggingface.co) and sign up
+2. **Generate token**: Go to Settings → Access Tokens → Create new token
+3. **Accept licenses**: Visit the model pages and accept license agreements:
+   - [FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev)
+   - [Stable Diffusion 3.5](https://huggingface.co/stabilityai/stable-diffusion-3.5-medium)
+4. **Set environment variable**:
+   ```bash
+   # Temporary (current session)
+   export HF_TOKEN=your_token_here
+   
+   # Permanent (add to ~/.bashrc or ~/.zshrc)
+   echo 'export HF_TOKEN=your_token_here' >> ~/.bashrc
+   ```
+
+### 💡 Pro Tips:
+- **Start simple**: Begin with FLUX.1-schnell (no token required, commercial use OK)
+- **Token scope**: Use "read" permissions for downloading models
+- **Privacy**: Your token stays local - never shared with OllamaDiffuser servers
+- **Troubleshooting**: If downloads fail, verify your token and model access permissions
+
+---
+
 ## ✨ Features
 
 - **🚀 Fast Startup**: Instant application launch with lazy loading architecture
@@ -423,7 +480,6 @@ with open("control.jpg", "rb") as f:
 
 - **[GGUF Models Guide](GGUF_GUIDE.md)**: Complete guide to memory-efficient GGUF models
 - **[ControlNet Guide](CONTROLNET_GUIDE.md)**: Comprehensive ControlNet usage and examples
-- **[Installation Guide](INSTALLATION_GUIDE.md)**: Detailed installation instructions
 - **[Website Documentation](https://www.ollamadiffuser.com/)**: Complete tutorials and guides
 
 ## 🚀 Performance & Hardware

{ollamadiffuser-1.2.0.dist-info → ollamadiffuser-1.2.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
-ollamadiffuser/__init__.py,sha256=DjwIN2FSK0VDarxOtEUAW9LGNRCYHSo1uH_pEgYioJQ,1127
+ollamadiffuser/__init__.py,sha256=QcfqaWxnceRL7tqVm88tAbTRc5wHU4L0XNsIC_MxRpE,1127
 ollamadiffuser/__main__.py,sha256=tNWMvEHq4ddtKLp7DrhIoOdnFw3F8RNrETC_u5xpkFI,141
 ollamadiffuser/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ollamadiffuser/api/server.py,sha256=4-3gT8W1404bxvJ7y9htvKbd2yxrrbtAUvT7shOlJss,17679
+ollamadiffuser/api/server.py,sha256=kc-Up50zmLfSM4f4InYR4Btkl35lyEN6UFcxlvxICSQ,18237
 ollamadiffuser/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ollamadiffuser/cli/commands.py,sha256=Pe0vyfGiffwd10QlVxBCTtNnMqHi8nJ3oNn_k8nAi5k,8903
 ollamadiffuser/cli/main.py,sha256=qj0VKTOjw_gox2dPVtbU-9kCo25TqshyVyqW8qsv4Pk,56081
@@ -12,7 +12,7 @@ ollamadiffuser/core/config/settings.py,sha256=VhI1vLGmOAQ7-XtyHrT5KoMpcGeGt-Mij-
 ollamadiffuser/core/inference/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ollamadiffuser/core/inference/engine.py,sha256=-EVcH4NyRVBQ-puvI_Az3KOZJYG9b-ySzsvoBTY3mlY,73962
 ollamadiffuser/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ollamadiffuser/core/models/gguf_loader.py,sha256=jlmluhq4VawkxHD8ASjB_XrbhTGOisN1-4Lt0Xcc5wg,18153
+ollamadiffuser/core/models/gguf_loader.py,sha256=ocfl3_MDVXC9nSjW8YJdz4kX1Q-Qe2ltu6w4fbqhxVY,35724
 ollamadiffuser/core/models/manager.py,sha256=rTEAameGih3wPcVG_Y-4k_brBeEqEoBjoI7fjggNtiY,16799
 ollamadiffuser/core/models/registry.py,sha256=YPx3xcHnCHogyowi9fQ6oXZg7_jz0fM5bDyyg-BgSFY,15125
 ollamadiffuser/core/utils/__init__.py,sha256=ZdXZWX1hfDnnV6OmRD6UStNljDJIQ892da2CtC-zdDw,31
@@ -37,9 +37,9 @@ ollamadiffuser/ui/samples/scribble/face_sketch.png,sha256=MVVYy_aS48xoS_RnIDzLUa
 ollamadiffuser/ui/samples/scribble/tree_sketch.png,sha256=3P-NGgW25xRwreDxiBYKcDhd2oHZAwKSkjNVM5oPTWY,3017
 ollamadiffuser/ui/templates/index.html,sha256=qTQVFxiTbeZ90O-iNqWC_4pYP6yyIs2z6U69VJPqAB4,38176
 ollamadiffuser/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ollamadiffuser-1.2.0.dist-info/licenses/LICENSE,sha256=cnGL9l2P510Uk3TCnv62kot6vAfdSawhOZh7Y-oYoIE,1071
-ollamadiffuser-1.2.0.dist-info/METADATA,sha256=h9t99eLyVINJNkrFnreqF8APYdzsqV2Y293lZxownWg,19808
-ollamadiffuser-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ollamadiffuser-1.2.0.dist-info/entry_points.txt,sha256=tHXXO3N0GSnIobDe_eSOLfHPjjVFjeTg2Fd-APoD6sY,64
-ollamadiffuser-1.2.0.dist-info/top_level.txt,sha256=97wOGgTCxDE765Nr_o7B4Kwr_M_jy8fCCeQ81sMKlC4,15
-ollamadiffuser-1.2.0.dist-info/RECORD,,
+ollamadiffuser-1.2.2.dist-info/licenses/LICENSE,sha256=cnGL9l2P510Uk3TCnv62kot6vAfdSawhOZh7Y-oYoIE,1071
+ollamadiffuser-1.2.2.dist-info/METADATA,sha256=Z2z38MfQ3SzUrpvb6Yk67eWEfx8kuhvJ8w-aRyCMZcY,21756
+ollamadiffuser-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ollamadiffuser-1.2.2.dist-info/entry_points.txt,sha256=tHXXO3N0GSnIobDe_eSOLfHPjjVFjeTg2Fd-APoD6sY,64
+ollamadiffuser-1.2.2.dist-info/top_level.txt,sha256=97wOGgTCxDE765Nr_o7B4Kwr_M_jy8fCCeQ81sMKlC4,15
+ollamadiffuser-1.2.2.dist-info/RECORD,,