ollamadiffuser 1.1.0__py3-none-any.whl → 1.1.2__py3-none-any.whl

ollamadiffuser/__init__.py

@@ -0,0 +1,31 @@
+"""
+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.1.1"
+__author__ = "OllamaDiffuser Team"
+__email__ = "ollamadiffuser@gmail.com"
+__description__ = "🎨 Local AI Image Generation with Ollama-style CLI for Stable Diffusion, FLUX.1, and LoRA support"
+__url__ = "https://www.ollamadiffuser.com/"
+__repository__ = "https://github.com/ollamadiffuser/ollamadiffuser"
+
+def get_version_info():
+    """Get formatted version information"""
+    return {
+        "version": __version__,
+        "description": __description__,
+        "url": __url__,
+        "repository": __repository__
+    }
+
+def print_version():
+    """Print formatted version information"""
+    from rich import print as rprint
+    rprint(f"[bold cyan]OllamaDiffuser v{__version__}[/bold cyan]")
+    rprint(__description__)
+    rprint(f"🔗 {__url__}")
+
+# For backward compatibility
+__all__ = ["__version__", "__author__", "__email__", "__description__", "__url__", "__repository__", "get_version_info", "print_version"]

ollamadiffuser/__main__.py

@@ -1,50 +1,9 @@
 #!/usr/bin/env python3
-import sys
-import argparse
 from .cli.main import cli
-from .api.server import run_server
-from .ui.web import create_ui_app
-from .core.config.settings import settings
 
 def main():
     """Main entry function"""
-    # Check if first argument is a mode flag
-    if len(sys.argv) > 1 and sys.argv[1] in ['--mode']:
-        # Use argparse for mode selection
-        parser = argparse.ArgumentParser(
-            description='OllamaDiffuser - Image generation model management tool'
-        )
-        parser.add_argument(
-            '--mode', 
-            choices=['cli', 'api', 'ui'], 
-            required=True,
-            help='Running mode: cli (command line), api (API server), ui (Web interface)'
-        )
-        parser.add_argument('--host', default=None, help='Server host address')
-        parser.add_argument('--port', type=int, default=None, help='Server port')
-        parser.add_argument('--verbose', '-v', action='store_true', help='Verbose output')
-        
-        args, unknown = parser.parse_known_args()
-        
-        if args.mode == 'cli':
-            # Command line mode
-            sys.argv = [sys.argv[0]] + unknown
-            cli()
-        elif args.mode == 'api':
-            # API server mode
-            print("Starting OllamaDiffuser API server...")
-            run_server(host=args.host, port=args.port)
-        elif args.mode == 'ui':
-            # Web UI mode
-            print("Starting OllamaDiffuser Web UI...")
-            import uvicorn
-            app = create_ui_app()
-            host = args.host or settings.server.host
-            port = args.port or (settings.server.port + 1)  # Web UI uses different port
-            uvicorn.run(app, host=host, port=port)
-    else:
-        # Default to CLI mode for direct command usage
-        cli()
+    cli()
 
 if __name__ == '__main__':
     main() 

ollamadiffuser/cli/commands.py

@@ -0,0 +1,133 @@
+import click
+import subprocess
+import sys
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from ..core.models.manager import model_manager
+from ..core.config.settings import settings
+
+console = Console()
+
+@click.command()
+def verify_deps():
+    """Verify and install missing dependencies"""
+    console.print("\n🔍 [bold blue]Checking OllamaDiffuser Dependencies[/bold blue]")
+    
+    # Check critical dependencies
+    deps_status = {}
+    
+    # OpenCV check
+    try:
+        import cv2
+        deps_status['opencv-python'] = f"✅ Installed (v{cv2.__version__})"
+    except ImportError:
+        deps_status['opencv-python'] = "❌ Missing"
+    
+    # ControlNet Aux check
+    try:
+        import controlnet_aux
+        deps_status['controlnet-aux'] = "✅ Installed"
+    except ImportError:
+        deps_status['controlnet-aux'] = "❌ Missing"
+    
+    # Torch check
+    try:
+        import torch
+        deps_status['torch'] = f"✅ Installed (v{torch.__version__})"
+    except ImportError:
+        deps_status['torch'] = "❌ Missing"
+    
+    # Diffusers check
+    try:
+        import diffusers
+        deps_status['diffusers'] = f"✅ Installed (v{diffusers.__version__})"
+    except ImportError:
+        deps_status['diffusers'] = "❌ Missing"
+    
+    # Create status table
+    table = Table(title="Dependency Status")
+    table.add_column("Package", style="cyan")
+    table.add_column("Status", style="white")
+    
+    missing_deps = []
+    for dep, status in deps_status.items():
+        table.add_row(dep, status)
+        if "❌ Missing" in status:
+            missing_deps.append(dep)
+    
+    console.print(table)
+    
+    if missing_deps:
+        console.print(f"\n⚠️  [bold yellow]{len(missing_deps)} dependencies are missing[/bold yellow]")
+        
+        if click.confirm("\nWould you like to install missing dependencies?"):
+            for dep in missing_deps:
+                console.print(f"\n📦 Installing {dep}...")
+                
+                # Determine package name
+                if dep == 'opencv-python':
+                    package = 'opencv-python>=4.8.0'
+                elif dep == 'controlnet-aux':
+                    package = 'controlnet-aux>=0.0.7'
+                else:
+                    package = dep
+                
+                try:
+                    subprocess.check_call([
+                        sys.executable, "-m", "pip", "install", package
+                    ])
+                    console.print(f"✅ {dep} installed successfully")
+                except subprocess.CalledProcessError as e:
+                    console.print(f"❌ Failed to install {dep}: {e}")
+        
+        console.print("\n🔄 Re-run 'ollamadiffuser verify-deps' to check status")
+    else:
+        console.print("\n🎉 [bold green]All dependencies are installed![/bold green]")
+    
+    # Check ControlNet preprocessors
+    console.print("\n🔧 [bold blue]Testing ControlNet Preprocessors[/bold blue]")
+    try:
+        from ..core.utils.controlnet_preprocessors import controlnet_preprocessor
+        if controlnet_preprocessor.is_available():
+            available_types = controlnet_preprocessor.get_available_types()
+            console.print(f"✅ Available types: {', '.join(available_types)}")
+        else:
+            console.print("⚠️  ControlNet preprocessors not fully available")
+    except Exception as e:
+        console.print(f"❌ Error testing preprocessors: {e}")
+
+@click.command()
+def doctor():
+    """Run comprehensive system diagnostics"""
+    console.print(Panel.fit("🩺 [bold blue]OllamaDiffuser Doctor[/bold blue]"))
+    
+    # System info
+    import platform
+    console.print(f"\n💻 System: {platform.system()} {platform.release()}")
+    console.print(f"🐍 Python: {sys.version.split()[0]}")
+    
+    # GPU info
+    try:
+        import torch
+        if torch.cuda.is_available():
+            console.print(f"🎮 CUDA: Available ({torch.cuda.get_device_name()})")
+        elif hasattr(torch.backends, 'mps') and torch.backends.mps.is_available():
+            console.print("🍎 Apple Metal: Available")
+        else:
+            console.print("⚙️ GPU: CPU only")
+    except ImportError:
+        console.print("❌ PyTorch not installed")
+    
+    # Memory info
+    try:
+        import psutil
+        memory = psutil.virtual_memory()
+        console.print(f"🧠 RAM: {memory.total // (1024**3)} GB total, {memory.available // (1024**3)} GB available")
+    except ImportError:
+        console.print("⚠️ Cannot check memory (psutil missing)")
+    
+    # Run dependency check
+    console.print("\n" + "="*50)
+    ctx = click.Context(verify_deps)
+    ctx.invoke(verify_deps) 

ollamadiffuser/cli/main.py

@@ -5,23 +5,96 @@ import logging
 from typing import Optional
 from rich.console import Console
 from rich.table import Table
-from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, DownloadColumn, TransferSpeedColumn, TimeRemainingColumn
 from rich import print as rprint
+import time
 
+from .. import __version__, print_version
 from ..core.models.manager import model_manager
 from ..core.config.settings import settings
 from ..api.server import run_server
 
 console = Console()
 
-@click.group()
+class OllamaStyleProgress:
+    """Enhanced progress tracker that mimics Ollama's progress display"""
+    
+    def __init__(self, console: Console):
+        self.console = console
+        self.last_message = ""
+        
+    def update(self, message: str):
+        """Update progress with a message"""
+        # Skip duplicate messages
+        if message == self.last_message:
+            return
+            
+        self.last_message = message
+        
+        # Handle different types of messages
+        if message.startswith("pulling ") and ":" in message and "%" in message:
+            # This is a file progress message from download_utils
+            # Format: "pulling e6a7edc1a4d7: 12% ▕██                ▏ 617 MB/5200 MB 44 MB/s 1m44s"
+            self.console.print(message)
+        elif message.startswith("pulling manifest"):
+            self.console.print(message)
+        elif message.startswith("📦 Repository:"):
+            # Repository info
+            self.console.print(f"[dim]{message}[/dim]")
+        elif message.startswith("📁 Found"):
+            # Existing files info
+            self.console.print(f"[dim]{message}[/dim]")
+        elif message.startswith("✅") and "download completed" in message:
+            self.console.print(f"[green]{message}[/green]")
+        elif message.startswith("❌"):
+            self.console.print(f"[red]{message}[/red]")
+        elif message.startswith("⚠️"):
+            self.console.print(f"[yellow]{message}[/yellow]")
+        else:
+            # For other messages, print with dimmed style
+            self.console.print(f"[dim]{message}[/dim]")
+
+@click.group(invoke_without_command=True)
 @click.option('--verbose', '-v', is_flag=True, help='Enable verbose output')
-def cli(verbose):
+@click.option('--version', '-V', is_flag=True, help='Show version and exit')
+@click.option('--mode', type=click.Choice(['cli', 'api', 'ui']), help='Running mode: cli (command line), api (API server), ui (Web interface)')
+@click.option('--host', default=None, help='Server host address (for api/ui modes)')
+@click.option('--port', type=int, default=None, help='Server port (for api/ui modes)')
+@click.pass_context
+def cli(ctx, verbose, version, mode, host, port):
     """OllamaDiffuser - Image generation model management tool"""
+    if version:
+        print_version()
+        sys.exit(0)
+        
     if verbose:
         logging.basicConfig(level=logging.DEBUG)
     else:
         logging.basicConfig(level=logging.WARNING)
+    
+    # Handle mode-based execution
+    if mode:
+        if mode == 'api':
+            rprint("[blue]Starting OllamaDiffuser API server...[/blue]")
+            run_server(host=host, port=port)
+            sys.exit(0)
+        elif mode == 'ui':
+            rprint("[blue]Starting OllamaDiffuser Web UI...[/blue]")
+            import uvicorn
+            from ..ui.web import create_ui_app
+            app = create_ui_app()
+            ui_host = host or settings.server.host
+            ui_port = port or (settings.server.port + 1)  # Web UI uses different port
+            uvicorn.run(app, host=ui_host, port=ui_port)
+            sys.exit(0)
+        elif mode == 'cli':
+            # Continue with normal CLI processing
+            pass
+    
+    # If no subcommand is provided and no mode/version flag, show help
+    if ctx.invoked_subcommand is None and not version and not mode:
+        rprint(ctx.get_help())
+        sys.exit(0)
 
 @cli.command()
 @click.argument('model_name')
@@ -30,24 +103,26 @@ def pull(model_name: str, force: bool):
     """Download model"""
     rprint(f"[blue]Downloading model: {model_name}[/blue]")
     
-    with Progress(
-        SpinnerColumn(),
-        TextColumn("[progress.description]{task.description}"),
-        console=console
-    ) as progress:
-        task = progress.add_task(f"Downloading {model_name}...", total=None)
-        
-        def progress_callback(message: str):
-            """Update progress display with download status"""
-            progress.update(task, description=message)
-        
+    # Use the new Ollama-style progress tracker
+    progress_tracker = OllamaStyleProgress(console)
+    
+    def progress_callback(message: str):
+        """Enhanced progress callback with Ollama-style display"""
+        progress_tracker.update(message)
+    
+    try:
         if model_manager.pull_model(model_name, force=force, progress_callback=progress_callback):
-            progress.update(task, description=f"✅ {model_name} download completed")
+            progress_tracker.update("✅ download completed")
             rprint(f"[green]Model {model_name} downloaded successfully![/green]")
         else:
-            progress.update(task, description=f"❌ {model_name} download failed")
             rprint(f"[red]Model {model_name} download failed![/red]")
             sys.exit(1)
+    except KeyboardInterrupt:
+        rprint("\n[yellow]Download cancelled by user[/yellow]")
+        sys.exit(1)
+    except Exception as e:
+        rprint(f"[red]Download failed: {str(e)}[/red]")
+        sys.exit(1)
 
 @cli.command()
 @click.argument('model_name')
@@ -849,8 +924,39 @@ def show(lora_name: str):
 @cli.command()
 def version():
     """Show version information"""
-    rprint("[bold cyan]OllamaDiffuser v1.0.0[/bold cyan]")
-    rprint("Image generation model management tool")
+    print_version()
+    rprint("\n[bold]Features:[/bold]")
+    rprint("• 🚀 Fast Startup with lazy loading architecture")
+    rprint("• 🎛️ ControlNet Support with 10+ control types")
+    rprint("• 🔄 LoRA Integration with dynamic loading")
+    rprint("• 🌐 Multiple Interfaces: CLI, Python API, Web UI, REST API")
+    rprint("• 📦 Easy model management and switching")
+    rprint("• ⚡ Performance optimized with GPU acceleration")
+    
+    rprint("\n[bold]Supported Models:[/bold]")
+    rprint("• FLUX.1-schnell (Apache 2.0, Commercial OK, 4-step generation)")
+    rprint("• FLUX.1-dev (Non-commercial, High quality, 50-step generation)")
+    rprint("• Stable Diffusion 3.5 Medium")
+    rprint("• Stable Diffusion XL Base")
+    rprint("• Stable Diffusion 1.5")
+    rprint("• ControlNet models for SD15 and SDXL")
+    
+    rprint("\n[dim]For help: ollamadiffuser --help[/dim]")
+    rprint("[dim]For diagnostics: ollamadiffuser doctor[/dim]")
+
+@cli.command(name='verify-deps')
+def verify_deps_cmd():
+    """Verify and install missing dependencies"""
+    from .commands import verify_deps
+    ctx = click.Context(verify_deps)
+    ctx.invoke(verify_deps)
+
+@cli.command()
+def doctor():
+    """Run comprehensive system diagnostics"""
+    from .commands import doctor
+    ctx = click.Context(doctor)
+    ctx.invoke(doctor)
 
 if __name__ == '__main__':
     cli() 

ollamadiffuser/core/utils/controlnet_preprocessors.py

@@ -1,4 +1,10 @@
-import cv2
+try:
+    import cv2
+    CV2_AVAILABLE = True
+except ImportError:
+    CV2_AVAILABLE = False
+    cv2 = None
+
 import numpy as np
 from PIL import Image
 import logging
@@ -15,6 +21,13 @@ class ControlNetPreprocessorManager:
         self._initialized = False
         self._initialization_attempted = False
         self._available_types = []
+        
+        # Check dependencies on initialization
+        if not CV2_AVAILABLE:
+            logger.warning(
+                "OpenCV (cv2) is not installed. "
+                "Install it with: pip install opencv-python>=4.8.0"
+            )
     
     def is_initialized(self) -> bool:
         """Check if preprocessors are initialized"""
@@ -22,6 +35,9 @@ class ControlNetPreprocessorManager:
     
     def is_available(self) -> bool:
         """Check if ControlNet preprocessors are available"""
+        if not CV2_AVAILABLE:
+            return False
+            
         if not self._initialization_attempted:
             # Try a lightweight check without full initialization
             try:
@@ -41,6 +57,12 @@ class ControlNetPreprocessorManager:
         Returns:
             True if initialization successful, False otherwise
         """
+        if not CV2_AVAILABLE:
+            raise ImportError(
+                "OpenCV (cv2) is required for ControlNet preprocessors. "
+                "Install it with: pip install opencv-python>=4.8.0"
+            )
+            
         if self._initialized and not force:
             return True
             
@@ -164,17 +186,28 @@ class ControlNetPreprocessorManager:
     
     def _init_basic_processors(self):
         """Initialize basic OpenCV-based processors as fallback"""
-        logger.info("Using basic OpenCV-based preprocessors")
-        self.processors = {
-            'canny': self._canny_opencv,
-            'depth': self._depth_basic,
-            'scribble': self._scribble_basic,
-        }
+        if not CV2_AVAILABLE:
+            logger.warning("OpenCV not available, using minimal fallback processors")
+            self.processors = {
+                'canny': self._simple_edge_fallback,
+                'depth': self._simple_depth_fallback,
+                'scribble': self._simple_edge_fallback,
+            }
+        else:
+            logger.info("Using basic OpenCV-based preprocessors")
+            self.processors = {
+                'canny': self._canny_opencv,
+                'depth': self._depth_basic,
+                'scribble': self._scribble_basic,
+            }
         self._initialized = True
         self._available_types = list(self.processors.keys())
     
     def _canny_opencv(self, image: Image.Image, low_threshold: int = 100, high_threshold: int = 200) -> Image.Image:
         """Basic Canny edge detection using OpenCV"""
+        if not CV2_AVAILABLE:
+            raise ImportError("OpenCV is required for Canny edge detection")
+            
         # Convert PIL to OpenCV format
         image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
         
@@ -187,6 +220,9 @@ class ControlNetPreprocessorManager:
     
     def _depth_basic(self, image: Image.Image) -> Image.Image:
         """Basic depth estimation using simple gradients"""
+        if not CV2_AVAILABLE:
+            raise ImportError("OpenCV is required for depth estimation")
+            
         # Convert to grayscale
         gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
         
@@ -207,6 +243,9 @@ class ControlNetPreprocessorManager:
     
     def _scribble_basic(self, image: Image.Image) -> Image.Image:
         """Basic scribble detection using edge detection"""
+        if not CV2_AVAILABLE:
+            raise ImportError("OpenCV is required for scribble detection")
+            
         # Convert to grayscale
         gray = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2GRAY)
         
@@ -221,6 +260,39 @@ class ControlNetPreprocessorManager:
         edges_rgb = cv2.cvtColor(edges, cv2.COLOR_GRAY2RGB)
         return Image.fromarray(edges_rgb)
     
+    def _simple_edge_fallback(self, image: Image.Image, **kwargs) -> Image.Image:
+        """Simple edge detection fallback using PIL/numpy only"""
+        # Convert to numpy array
+        img_array = np.array(image.convert('L'))  # Convert to grayscale
+        
+        # Simple gradient-based edge detection
+        grad_x = np.abs(np.diff(img_array, axis=1))
+        grad_y = np.abs(np.diff(img_array, axis=0))
+        
+        # Pad to maintain original size
+        grad_x = np.pad(grad_x, ((0, 0), (0, 1)), mode='edge')
+        grad_y = np.pad(grad_y, ((0, 1), (0, 0)), mode='edge')
+        
+        # Combine gradients
+        edges = np.sqrt(grad_x**2 + grad_y**2)
+        edges = np.uint8(255 * edges / np.max(edges) if np.max(edges) > 0 else edges)
+        
+        # Convert to RGB
+        edges_rgb = np.stack([edges, edges, edges], axis=2)
+        return Image.fromarray(edges_rgb)
+    
+    def _simple_depth_fallback(self, image: Image.Image, **kwargs) -> Image.Image:
+        """Simple depth estimation fallback using PIL/numpy only"""
+        # Convert to grayscale
+        gray = np.array(image.convert('L'))
+        
+        # Simple depth based on intensity (brighter = closer)
+        depth = 255 - gray  # Invert so darker areas are "further"
+        
+        # Convert to RGB
+        depth_rgb = np.stack([depth, depth, depth], axis=2)
+        return Image.fromarray(depth_rgb)
+    
     def preprocess(self, 
                    image: Union[Image.Image, str], 
                    control_type: str,

ollamadiffuser/core/utils/download_utils.py

@@ -11,25 +11,107 @@ from pathlib import Path
 from huggingface_hub import snapshot_download, hf_hub_download, HfApi
 from tqdm import tqdm
 import threading
+import requests
 
 logger = logging.getLogger(__name__)
 
-class ProgressTracker:
-    """Track download progress across multiple files"""
+class EnhancedProgressTracker:
+    """Enhanced progress tracker that provides Ollama-style detailed progress information"""
     
     def __init__(self, total_files: int = 0, progress_callback: Optional[Callable] = None):
         self.total_files = total_files
         self.completed_files = 0
         self.current_file = ""
         self.file_progress = {}
+        self.file_start_times = {}
+        self.file_speeds = {}
         self.progress_callback = progress_callback
         self.lock = threading.Lock()
+        self.overall_start_time = time.time()
+        self.total_size = 0
+        self.downloaded_size = 0
         
+    def set_total_size(self, total_size: int):
+        """Set the total size for all files"""
+        with self.lock:
+            self.total_size = total_size
+    
+    def start_file(self, filename: str, file_size: int = 0):
+        """Mark a file as started"""
+        with self.lock:
+            self.current_file = filename
+            self.file_start_times[filename] = time.time()
+            self.file_progress[filename] = (0, file_size)
+            
+            # Extract hash-like identifier for Ollama-style display
+            import re
+            hash_match = re.search(r'([a-f0-9]{8,})', filename)
+            if hash_match:
+                display_name = hash_match.group(1)[:12]  # First 12 characters
+            else:
+                # Fallback to filename without extension
+                display_name = Path(filename).stem[:12]
+            
+            if self.progress_callback:
+                self.progress_callback(f"pulling {display_name}")
+    
     def update_file_progress(self, filename: str, downloaded: int, total: int):
-        """Update progress for a specific file"""
+        """Update progress for a specific file with speed calculation"""
         with self.lock:
+            current_time = time.time()
+            
+            # Update file progress
+            old_downloaded = self.file_progress.get(filename, (0, 0))[0]
             self.file_progress[filename] = (downloaded, total)
-            self._report_progress()
+            
+            # Update overall downloaded size
+            size_diff = downloaded - old_downloaded
+            self.downloaded_size += size_diff
+            
+            # Calculate speed for this file
+            if filename in self.file_start_times:
+                elapsed = current_time - self.file_start_times[filename]
+                if elapsed > 0 and downloaded > 0:
+                    speed = downloaded / elapsed  # bytes per second
+                    self.file_speeds[filename] = speed
+            
+            # Report progress in Ollama style
+            if self.progress_callback and total > 0:
+                percentage = (downloaded / total) * 100
+                
+                # Format sizes
+                downloaded_mb = downloaded / (1024 * 1024)
+                total_mb = total / (1024 * 1024)
+                
+                # Calculate speed in MB/s
+                speed_mbps = self.file_speeds.get(filename, 0) / (1024 * 1024)
+                
+                # Calculate ETA
+                if speed_mbps > 0:
+                    remaining_mb = total_mb - downloaded_mb
+                    eta_seconds = remaining_mb / speed_mbps
+                    eta_min = int(eta_seconds // 60)
+                    eta_sec = int(eta_seconds % 60)
+                    eta_str = f"{eta_min}m{eta_sec:02d}s"
+                else:
+                    eta_str = "?"
+                
+                # Extract hash for display
+                import re
+                hash_match = re.search(r'([a-f0-9]{8,})', filename)
+                if hash_match:
+                    display_name = hash_match.group(1)[:12]
+                else:
+                    display_name = Path(filename).stem[:12]
+                
+                # Create progress bar
+                bar_width = 20
+                filled = int((percentage / 100) * bar_width)
+                bar = "█" * filled + " " * (bar_width - filled)
+                
+                progress_msg = f"pulling {display_name}: {percentage:3.0f}% ▕{bar}▏ {downloaded_mb:.0f} MB/{total_mb:.0f} MB {speed_mbps:.0f} MB/s {eta_str}"
+                
+                self.progress_callback(progress_msg)
     
     def complete_file(self, filename: str):
         """Mark a file as completed"""
@@ -38,34 +120,42 @@ class ProgressTracker:
             if filename in self.file_progress:
                 downloaded, total = self.file_progress[filename]
                 self.file_progress[filename] = (total, total)
-            self._report_progress()
-    
-    def set_current_file(self, filename: str):
-        """Set the currently downloading file"""
-        with self.lock:
-            self.current_file = filename
-            self._report_progress()
+            
+            # Report completion
+            if self.progress_callback:
+                import re
+                hash_match = re.search(r'([a-f0-9]{8,})', filename)
+                if hash_match:
+                    display_name = hash_match.group(1)[:12]
+                else:
+                    display_name = Path(filename).stem[:12]
+                
+                total_mb = self.file_progress.get(filename, (0, 0))[1] / (1024 * 1024)
+                self.progress_callback(f"pulling {display_name}: 100% ▕████████████████████▏ {total_mb:.0f} MB/{total_mb:.0f} MB")
     
-    def _report_progress(self):
-        """Report current progress"""
+    def report_overall_progress(self):
+        """Report overall progress"""
         if self.progress_callback:
-            # Calculate overall progress
-            total_downloaded = 0
-            total_size = 0
-            
-            for downloaded, size in self.file_progress.values():
-                total_downloaded += downloaded
-                total_size += size
-            
-            progress_msg = f"Files: {self.completed_files}/{self.total_files}"
-            if total_size > 0:
-                percent = (total_downloaded / total_size) * 100
-                progress_msg += f" | Overall: {percent:.1f}%"
-            
-            if self.current_file:
-                progress_msg += f" | Current: {self.current_file}"
-            
-            self.progress_callback(progress_msg)
+            if self.total_size > 0:
+                overall_percent = (self.downloaded_size / self.total_size) * 100
+                downloaded_gb = self.downloaded_size / (1024 * 1024 * 1024)
+                total_gb = self.total_size / (1024 * 1024 * 1024)
+                
+                elapsed = time.time() - self.overall_start_time
+                if elapsed > 0:
+                    overall_speed = self.downloaded_size / elapsed / (1024 * 1024)  # MB/s
+                    
+                    if overall_speed > 0:
+                        remaining_gb = total_gb - downloaded_gb
+                        eta_seconds = (remaining_gb * 1024) / overall_speed  # Convert GB to MB for calculation
+                        eta_min = int(eta_seconds // 60)
+                        eta_sec = int(eta_seconds % 60)
+                        eta_str = f"{eta_min}m{eta_sec:02d}s"
+                    else:
+                        eta_str = "?"
+                    
+                    progress_msg = f"Overall progress: {overall_percent:.1f}% | {downloaded_gb:.1f} GB/{total_gb:.1f} GB | {overall_speed:.1f} MB/s | ETA: {eta_str}"
+                    self.progress_callback(progress_msg)
 
 def configure_hf_environment():
     """Configure HuggingFace Hub environment for better downloads"""
@@ -132,7 +222,7 @@ def robust_snapshot_download(
     
     # Get file list and sizes for progress tracking
     if progress_callback:
-        progress_callback("📋 Getting repository information...")
+        progress_callback("pulling manifest")
     
     file_sizes = get_repo_file_list(repo_id)
     total_size = sum(file_sizes.values())
@@ -140,20 +230,65 @@ def robust_snapshot_download(
     if progress_callback and file_sizes:
         progress_callback(f"📦 Repository: {len(file_sizes)} files, {format_size(total_size)} total")
     
+    # Initialize enhanced progress tracker
+    progress_tracker = EnhancedProgressTracker(len(file_sizes), progress_callback)
+    progress_tracker.set_total_size(total_size)
+    
     # Check what's already downloaded
     local_path = Path(local_dir)
+    existing_size = 0
     if local_path.exists() and not force_download:
         existing_files = []
-        existing_size = 0
         for file_path in local_path.rglob('*'):
             if file_path.is_file():
                 rel_path = file_path.relative_to(local_path)
                 existing_files.append(str(rel_path))
-                existing_size += file_path.stat().st_size
+                file_size = file_path.stat().st_size
+                existing_size += file_size
+                # Mark existing files as completed in progress tracker
+                progress_tracker.file_progress[str(rel_path)] = (file_size, file_size)
+                progress_tracker.downloaded_size += file_size
+                progress_tracker.completed_files += 1
         
         if progress_callback and existing_files:
             progress_callback(f"📁 Found {len(existing_files)} existing files ({format_size(existing_size)})")
     
+    # Custom tqdm class to capture HuggingFace download progress
+    class OllamaStyleTqdm(tqdm):
+        def __init__(self, *args, **kwargs):
+            # Extract description to get filename
+            desc = kwargs.get('desc', '')
+            self.current_filename = desc
+            
+            # Get file size from our pre-fetched data
+            file_size = file_sizes.get(self.current_filename, 0)
+            if file_size > 0:
+                kwargs['total'] = file_size
+                
+            super().__init__(*args, **kwargs)
+            
+            # Start tracking this file
+            if self.current_filename and progress_callback:
+                progress_tracker.start_file(self.current_filename, file_size)
+        
+        def update(self, n=1):
+            super().update(n)
+            
+            # Update our progress tracker
+            if self.current_filename and progress_callback:
+                downloaded = getattr(self, 'n', 0)
+                total = getattr(self, 'total', 0) or file_sizes.get(self.current_filename, 0)
+                
+                if total > 0:
+                    progress_tracker.update_file_progress(self.current_filename, downloaded, total)
+        
+        def close(self):
+            super().close()
+            
+            # Mark file as completed
+            if self.current_filename and progress_callback:
+                progress_tracker.complete_file(self.current_filename)
+    
     last_exception = None
     
     for attempt in range(max_retries):
@@ -166,12 +301,6 @@ def robust_snapshot_download(
             
             logger.info(f"Download attempt {attempt + 1}/{max_retries} with {workers} workers")
             
-            # Create a custom progress callback for tqdm
-            def tqdm_callback(t):
-                def inner(chunk_size):
-                    t.update(chunk_size)
-                return inner
-            
             result = snapshot_download(
                 repo_id=repo_id,
                 local_dir=local_dir,
@@ -181,7 +310,7 @@ def robust_snapshot_download(
                 resume_download=True,  # Enable resume
                 etag_timeout=300 + (attempt * 60),  # Increase timeout on retries
                 force_download=force_download,
-                tqdm_class=tqdm if progress_callback else None
+                tqdm_class=OllamaStyleTqdm if progress_callback else None
             )
             
             if progress_callback:

{ollamadiffuser-1.1.0.dist-info → ollamadiffuser-1.1.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ollamadiffuser
-Version: 1.1.0
+Version: 1.1.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
@@ -70,6 +70,7 @@ Dynamic: requires-python
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 
+
 ## Local AI Image Generation with OllamaDiffuser
 
 **OllamaDiffuser** simplifies local deployment of **Stable Diffusion**, **FLUX.1**, and other AI image generation models. An intuitive **local SD** tool inspired by **Ollama's** simplicity - perfect for **local diffuser** workflows with CLI, web UI, and LoRA support.
@@ -109,7 +110,7 @@ curl -X POST http://localhost:8000/api/generate \
 ### Option 2: Development Installation
 ```bash
 # Clone the repository
-git clone https://github.com/yourusername/ollamadiffuser.git
+git clone https://github.com/ollamadiffuser/ollamadiffuser.git
 cd ollamadiffuser
 
 # Install dependencies
@@ -118,17 +119,25 @@ pip install -e .
 
 ### Basic Usage
 ```bash
+# Check version
+ollamadiffuser -V
+
 # Install a model
 ollamadiffuser pull stable-diffusion-1.5
 
-# Load the model
-ollamadiffuser load stable-diffusion-1.5
+# Run the model (loads and starts API server)
+ollamadiffuser run stable-diffusion-1.5
 
-# Generate an image
-ollamadiffuser generate "a beautiful sunset over mountains"
+# Generate an image via API
+curl -X POST http://localhost:8000/api/generate \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "a beautiful sunset over mountains"}' \
+  --output image.png
 
 # Start web interface
 ollamadiffuser --mode ui
+
+open http://localhost:8001
 ```
 
 ### ControlNet Quick Start
@@ -136,8 +145,8 @@ ollamadiffuser --mode ui
 # Install ControlNet model
 ollamadiffuser pull controlnet-canny-sd15
 
-# Load ControlNet model
-ollamadiffuser load controlnet-canny-sd15
+# Run ControlNet model (loads and starts API server)
+ollamadiffuser run controlnet-canny-sd15
 
 # Generate with control image
 curl -X POST http://localhost:8000/api/generate/controlnet \
@@ -219,21 +228,29 @@ ollamadiffuser lora unload
 
 ### Command Line Interface
 ```bash
-# Generate with advanced parameters
-ollamadiffuser generate \
-  "a futuristic cityscape" \
-  --negative-prompt "blurry, low quality" \
-  --steps 30 \
-  --guidance 7.5 \
-  --width 1024 \
-  --height 1024
+# Pull and run a model
+ollamadiffuser pull stable-diffusion-1.5
+ollamadiffuser run stable-diffusion-1.5
+
+# In another terminal, generate images via API
+curl -X POST http://localhost:8000/api/generate \
+  -H "Content-Type: application/json" \
+  -d '{
+    "prompt": "a futuristic cityscape",
+    "negative_prompt": "blurry, low quality",
+    "num_inference_steps": 30,
+    "guidance_scale": 7.5,
+    "width": 1024,
+    "height": 1024
+  }' \
+  --output image.png
 ```
 
 ### Web UI
 ```bash
 # Start web interface
 ollamadiffuser --mode ui
-# Open http://localhost:8001
+Open http://localhost:8001
 ```
 
 Features:
@@ -247,10 +264,15 @@ Features:
 # Start API server
 ollamadiffuser --mode api
 
+ollamadiffuser load stable-diffusion-1.5
+
 # Generate image
 curl -X POST http://localhost:8000/api/generate \
   -H "Content-Type: application/json" \
   -d '{"prompt": "a beautiful landscape", "width": 1024, "height": 1024}'
+
+# API document
+http://localhost:8000/docs
 ```
 
 ### Python API
@@ -258,16 +280,19 @@ curl -X POST http://localhost:8000/api/generate \
 from ollamadiffuser.core.models.manager import model_manager
 
 # Load model
-model_manager.load_model("stable-diffusion-1.5")
-engine = model_manager.loaded_model
-
-# Generate image
-image = engine.generate_image(
-    prompt="a beautiful sunset",
-    width=1024,
-    height=1024
-)
-image.save("output.jpg")
+success = model_manager.load_model("stable-diffusion-1.5")
+if success:
+    engine = model_manager.loaded_model
+    
+    # Generate image
+    image = engine.generate_image(
+        prompt="a beautiful sunset",
+        width=1024,
+        height=1024
+    )
+    image.save("output.jpg")
+else:
+    print("Failed to load model")
 ```
 
 ## 📦 Supported Models
@@ -297,18 +322,6 @@ Models are automatically configured with optimal settings:
 - **Precision Handling**: FP16/BF16 support for efficiency
 - **Safety Features**: NSFW filter bypass for creative freedom
 
-### Performance Tuning
-```bash
-# Enable verbose logging
-ollamadiffuser -v generate "test prompt"
-
-# Check system status
-ollamadiffuser status
-
-# Monitor memory usage
-ollamadiffuser info
-```
-
 ## 🔧 Advanced Usage
 
 ### ControlNet Parameters
@@ -331,8 +344,9 @@ from ollamadiffuser.core.utils.controlnet_preprocessors import controlnet_prepro
 controlnet_preprocessor.initialize()
 
 # Process multiple images
-for image_path in image_list:
-    control_img = controlnet_preprocessor.preprocess(image, "canny")
+prompt = "beautiful landscape"  # Define the prompt
+for i, image_path in enumerate(image_list):
+    control_img = controlnet_preprocessor.preprocess(image_path, "canny")
     result = engine.generate_image(prompt, control_image=control_img)
     result.save(f"output_{i}.jpg")
 ```
@@ -360,8 +374,6 @@ with open("control.jpg", "rb") as f:
 ## 📚 Documentation & Guides
 
 - **[ControlNet Guide](CONTROLNET_GUIDE.md)**: Comprehensive ControlNet usage and examples
-- **[LoRA Guide](LORA_GUIDE.md)**: LoRA management and best practices
-- **[API Reference](API_REFERENCE.md)**: Complete API documentation
 - **[Website Documentation](https://www.ollamadiffuser.com/)**: Complete tutorials and guides
 
 ## 🚀 Performance & Hardware
@@ -383,6 +395,43 @@ with open("control.jpg", "rb") as f:
 
 ## 🔧 Troubleshooting
 
+### Installation Issues
+
+#### Missing Dependencies (cv2/OpenCV Error)
+If you encounter `ModuleNotFoundError: No module named 'cv2'`, run:
+
+```bash
+# Quick fix
+pip install opencv-python>=4.8.0
+
+# Or use the built-in verification tool
+ollamadiffuser verify-deps
+
+# Or install with all optional dependencies
+pip install ollamadiffuser[full]
+```
+
+#### Complete Dependency Check
+```bash
+# Run comprehensive system diagnostics
+ollamadiffuser doctor
+
+# Verify and install missing dependencies interactively
+ollamadiffuser verify-deps
+```
+
+#### Clean Installation
+If you're having persistent issues:
+
+```bash
+# Uninstall and reinstall
+pip uninstall ollamadiffuser
+pip install --no-cache-dir ollamadiffuser[full]
+
+# Verify installation
+ollamadiffuser verify-deps
+```
+
 ### Common Issues
 
 #### Slow Startup
@@ -407,46 +456,49 @@ curl -X POST http://localhost:8000/api/controlnet/initialize
 
 #### Memory Issues
 ```bash
-# Use smaller image sizes
-ollamadiffuser generate "test" --width 512 --height 512
+# Use smaller image sizes via API
+curl -X POST http://localhost:8000/api/generate \
+  -H "Content-Type: application/json" \
+  -d '{"prompt": "test", "width": 512, "height": 512}' \
+  --output test.png
 
-# Enable CPU offloading (automatic)
-# Close other applications
+# CPU offloading is automatic
+# Close other applications to free memory
 # Use basic preprocessors instead of advanced ones
 ```
 
-### Debug Mode
-```bash
-# Enable verbose logging
-ollamadiffuser -v run model-name
+### Platform-Specific Issues
 
-# Check system information
-ollamadiffuser info
-
-# Validate installation
-ollamadiffuser doctor
+#### macOS Apple Silicon
+```bash
+# If you encounter OpenCV issues on Apple Silicon
+pip uninstall opencv-python
+pip install opencv-python-headless>=4.8.0
 ```
 
-## 🤝 Contributing
-
-We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+#### Windows
+```bash
+# If you encounter build errors
+pip install --only-binary=all opencv-python>=4.8.0
+```
 
-### Development Setup
+#### Linux
 ```bash
-# Clone repository
-git clone https://github.com/yourusername/ollamadiffuser.git
-cd ollamadiffuser
+# If you need system dependencies
+sudo apt-get update
+sudo apt-get install libgl1-mesa-glx libglib2.0-0
+pip install opencv-python>=4.8.0
+```
 
-# Install in development mode
-pip install -e ".[dev]"
+### Debug Mode
+```bash
+# Enable verbose logging
+ollamadiffuser --verbose run model-name
+```
 
-# Run tests
-pytest tests/
+## 🤝 Contributing
 
-# Run linting
-flake8 ollamadiffuser/
-black ollamadiffuser/
-```
+We welcome contributions! Please check the GitHub repository for contribution guidelines.
 
 ## 🤝 Community & Support
 
@@ -476,9 +528,8 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 
 ## 📞 Support
 
-- **Documentation**: [Full documentation](docs/)
-- **Issues**: [GitHub Issues](https://github.com/yourusername/ollamadiffuser/issues)
-- **Discussions**: [GitHub Discussions](https://github.com/yourusername/ollamadiffuser/discussions)
+- **Issues**: [GitHub Issues](https://github.com/ollamadiffuser/ollamadiffuser/issues)
+- **Discussions**: [GitHub Discussions](https://github.com/ollamadiffuser/ollamadiffuser/discussions)
 
 ---
 

{ollamadiffuser-1.1.0.dist-info → ollamadiffuser-1.1.2.dist-info}/RECORD

@@ -1,9 +1,10 @@
-ollamadiffuser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ollamadiffuser/__main__.py,sha256=-3WVAex0P3PgfIUtOhVof9nF4Zor8mvMNTK5nKFlrHU,1841
+ollamadiffuser/__init__.py,sha256=g3eMrHnQLoWpqIII85gv5ScYrmImGjtRIoM8-qEK7o8,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/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ollamadiffuser/cli/main.py,sha256=V0UEEGVBeMJ_I0tem1YJWCyX4yO6GjqEBUMH14U5Hm0,37045
+ollamadiffuser/cli/commands.py,sha256=qEYCAt07O37kAPBNlhYwyS9rEZWw-rw5UgtiqWoZGdo,4715
+ollamadiffuser/cli/main.py,sha256=f1jopRvZsfgQ49gvb-iTMCP_XCmHpuSnTUrYqB4Mp5w,41481
 ollamadiffuser/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ollamadiffuser/core/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ollamadiffuser/core/config/settings.py,sha256=VhI1vLGmOAQ7-XtyHrT5KoMpcGeGt-Mij-9NxX_ZKsI,4881
@@ -12,16 +13,16 @@ ollamadiffuser/core/inference/engine.py,sha256=ky76lAjWexlrgmHSZZILa3FPQP7xx2WQ0
 ollamadiffuser/core/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ollamadiffuser/core/models/manager.py,sha256=vO1Az_aO5lZKMgSyK_6j2wT5nzPMowZgKhcH2mQVLkI,24139
 ollamadiffuser/core/utils/__init__.py,sha256=ZdXZWX1hfDnnV6OmRD6UStNljDJIQ892da2CtC-zdDw,31
-ollamadiffuser/core/utils/controlnet_preprocessors.py,sha256=JcLxvnuYAJdQb9EM1mAgyye1nARHwyjFdWzyl7yh7So,12684
-ollamadiffuser/core/utils/download_utils.py,sha256=LSsTMSpFS39KSnZwufTw1Z1eu3w7p-BbrTgrWHzudcs,14806
+ollamadiffuser/core/utils/controlnet_preprocessors.py,sha256=v21X_Bk-a4gKbUZUKoeP2W8TSGlv-ST8IYNsn3NrZ2c,15446
+ollamadiffuser/core/utils/download_utils.py,sha256=DvCt-cjH6WSBJniJT112b4a9AUzlwOYhQtPuEfISmtM,20961
 ollamadiffuser/core/utils/lora_manager.py,sha256=SrZydPSGJqCS_Vek35bEdG2Q51qCOLZmPvnNzUjjIN0,14328
 ollamadiffuser/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ollamadiffuser/ui/web.py,sha256=xZ5Ja47B-51LRyadfC-gW_aE_B3D571RgpQX0RDzVxM,15290
 ollamadiffuser/ui/templates/index.html,sha256=qTQVFxiTbeZ90O-iNqWC_4pYP6yyIs2z6U69VJPqAB4,38176
 ollamadiffuser/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ollamadiffuser-1.1.0.dist-info/licenses/LICENSE,sha256=cnGL9l2P510Uk3TCnv62kot6vAfdSawhOZh7Y-oYoIE,1071
-ollamadiffuser-1.1.0.dist-info/METADATA,sha256=vLK3Xz7s81u4jcPgWZCdP_oAUUKg1EuDAPbRYm6ygnE,15278
-ollamadiffuser-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ollamadiffuser-1.1.0.dist-info/entry_points.txt,sha256=tHXXO3N0GSnIobDe_eSOLfHPjjVFjeTg2Fd-APoD6sY,64
-ollamadiffuser-1.1.0.dist-info/top_level.txt,sha256=97wOGgTCxDE765Nr_o7B4Kwr_M_jy8fCCeQ81sMKlC4,15
-ollamadiffuser-1.1.0.dist-info/RECORD,,
+ollamadiffuser-1.1.2.dist-info/licenses/LICENSE,sha256=cnGL9l2P510Uk3TCnv62kot6vAfdSawhOZh7Y-oYoIE,1071
+ollamadiffuser-1.1.2.dist-info/METADATA,sha256=CQ_rn3y4ktSe8wqTCPBbtoNf6Wz0xHu_rPTq1m5l3EQ,16632
+ollamadiffuser-1.1.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ollamadiffuser-1.1.2.dist-info/entry_points.txt,sha256=tHXXO3N0GSnIobDe_eSOLfHPjjVFjeTg2Fd-APoD6sY,64
+ollamadiffuser-1.1.2.dist-info/top_level.txt,sha256=97wOGgTCxDE765Nr_o7B4Kwr_M_jy8fCCeQ81sMKlC4,15
+ollamadiffuser-1.1.2.dist-info/RECORD,,