Fix dependency versions and improve error handling for HuggingFace compatibility

backup/app.py.improved

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""
+ColorCraft SDXL + CPDS Line Art Generator
+HuggingFace Space deployment of your working SDXL pipeline
+"""
+
+import os
+import cv2
+import torch
+import numpy as np
+from PIL import Image
+import logging
+import gradio as gr
+from typing import Optional
+import gc
+import time
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ControlNet imports with better error handling
+try:
+    from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
+    # Handle different controlnet-aux versions
+    try:
+        from controlnet_aux import CannyDetector
+        CONTROLNET_AVAILABLE = True
+        logger.info("✅ ControlNet imports successful (newer version)")
+    except ImportError:
+        # Fallback for older versions
+        try:
+            from controlnet_aux.canny import CannyDetector
+            CONTROLNET_AVAILABLE = True
+            logger.info("✅ ControlNet imports successful (older version)")
+        except ImportError:
+            CONTROLNET_AVAILABLE = False
+            logger.warning("⚠️ ControlNet not available, using OpenCV fallback")
+except ImportError as e:
+    CONTROLNET_AVAILABLE = False
+    logger.warning(f"⚠️ ControlNet not available: {e}")
+
+class ColorCraftSDXLProcessor:
+    """Your exact SDXL + CPDS pipeline deployed to HuggingFace"""
+    
+    def __init__(self):
+        self.pipeline = None
+        self.canny_detector = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        logger.info(f"🔧 Initializing ColorCraft SDXL Processor on {self.device}")
+        
+        # Initialize detectors
+        if CONTROLNET_AVAILABLE:
+            try:
+                self.canny_detector = CannyDetector()
+                logger.info("✅ Canny detector initialized")
+            except Exception as e:
+                logger.warning(f"⚠️ Canny detector failed to load: {e}")
+                self.canny_detector = None
+        
+        # Load models on initialization
+        self._load_models()
+        
+    def _load_models(self):
+        """Load your exact SDXL + CPDS setup"""
+        logger.info("🔧 Loading SDXL with CPDS ControlNet...")
+        
+        # Clear GPU memory
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            torch.cuda.synchronize()
+            gc.collect()
+        
+        try:
+            # Load SDXL-compatible ControlNet (same as your local setup)
+            controlnet_model = "diffusers/controlnet-canny-sdxl-1.0"
+            
+            logger.info(f"🔄 Loading ControlNet: {controlnet_model}")
+            self.controlnet = ControlNetModel.from_pretrained(
+                controlnet_model,
+                torch_dtype=torch.float16,
+                use_safetensors=True
+            )
+            logger.info("✅ ControlNet loaded successfully")
+            
+            # Load SDXL base model (same as your local setup)
+            sdxl_model = "stabilityai/stable-diffusion-xl-base-1.0"
+            
+            logger.info(f"🔄 Loading SDXL: {sdxl_model}")
+            self.pipeline = StableDiffusionControlNetPipeline.from_pretrained(
+                sdxl_model,
+                controlnet=self.controlnet,
+                torch_dtype=torch.float16,
+                use_safetensors=True,
+                safety_checker=None,
+                requires_safety_checker=False,
+                variant="fp16"
+            )
+            
+            # Move to GPU
+            if torch.cuda.is_available():
+                self.pipeline = self.pipeline.to("cuda")
+                logger.info("✅ Pipeline moved to GPU")
+            
+            # Enable memory optimizations (same as your local setup)
+            logger.info("🔧 Applying memory optimizations...")
+            
+            try:
+                self.pipeline.enable_attention_slicing("max")
+                logger.info("✅ Enabled attention slicing")
+            except:
+                pass
+                
+            try:
+                # Try xformers first, fallback to CPU offload
+                self.pipeline.enable_xformers_memory_efficient_attention()
+                logger.info("✅ Enabled xformers")
+            except:
+                try:
+                    self.pipeline.enable_model_cpu_offload()
+                    logger.info("✅ Enabled CPU offload")
+                except:
+                    logger.info("⚠️ Memory optimizations not available")
+            
+            logger.info("🎉 SDXL pipeline ready!")
+            
+        except Exception as e:
+            logger.error(f"❌ Failed to load models: {e}")
+            # Don't raise here, let the fallback handle it
+            self.pipeline = None
+    
+    def process_image_to_lineart(
+        self, 
+        image: Image.Image,
+        style: str = "clean",
+        detail_level: float = 0.7,
+        noise_reduction: bool = True
+    ) -> Image.Image:
+        """Convert image to line art using your SDXL + CPDS pipeline"""
+        
+        start_time = time.time()
+        logger.info(f"🎨 Processing image: {image.size}")
+        
+        # Check if SDXL pipeline is available
+        if self.pipeline is None:
+            logger.warning("⚠️ SDXL pipeline not available, using fallback")
+            return self._fallback_lineart(image, style, detail_level, noise_reduction)
+        
+        try:
+            # Preprocess image (same as your local pipeline)
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            # Resize to optimal size for SDXL (1024x1024 or maintain aspect ratio)
+            max_size = 1024
+            if max(image.size) > max_size:
+                ratio = max_size / max(image.size)
+                new_size = (int(image.width * ratio), int(image.height * ratio))
+                image = image.resize(new_size, Image.Resampling.LANCZOS)
+            
+            # Generate Canny edges as control
+            if self.canny_detector:
+                logger.info("🔍 Generating Canny edges")
+                canny_image = self.canny_detector(image)
+            else:
+                # Fallback Canny detection
+                img_array = np.array(image)
+                gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+                edges = cv2.Canny(gray, 50, 150)
+                canny_image = Image.fromarray(edges).convert('RGB')
+            
+            # Your exact prompt engineering for line art
+            positive_prompt = f"""
+            black and white line art, coloring book style, clean outlines, 
+            simple lines, minimal shading, high contrast, white background,
+            detailed line drawing, professional illustration, {style} style,
+            monochrome, pen and ink drawing, clear boundaries
+            """
+            
+            negative_prompt = """
+            color, colored, painting, photorealistic, photograph, realistic,
+            shading, gradients, complex details, noise, blurry, low quality,
+            watermark, signature, text, cropped, worst quality, low quality,
+            normal quality, jpeg artifacts, signature, watermark, username,
+            blurry, artist name, trademark, title, multiple views, Reference sheet
+            """
+            
+            # Generate with your exact parameters
+            logger.info("🚀 Generating line art with SDXL...")
+            
+            result = self.pipeline(
+                prompt=positive_prompt.strip(),
+                negative_prompt=negative_prompt.strip(),
+                image=canny_image,
+                num_inference_steps=20,  # Same as your local setup
+                guidance_scale=7.5,      # Same as your local setup
+                controlnet_conditioning_scale=0.7,  # Your detail_level
+                width=image.width,
+                height=image.height,
+                generator=torch.Generator().manual_seed(42)  # Reproducible results
+            ).images[0]
+            
+            # Post-process for optimal coloring book quality (same as your pipeline)
+            result_array = np.array(result)
+            if len(result_array.shape) == 3 and result_array.shape[2] == 3:
+                # Convert to grayscale
+                gray = cv2.cvtColor(result_array, cv2.COLOR_RGB2GRAY)
+                
+                # Enhance contrast and clean up
+                enhanced = cv2.convertScaleAbs(gray, alpha=1.3, beta=10)
+                
+                # Apply bilateral filter to reduce noise while preserving edges
+                denoised = cv2.bilateralFilter(enhanced, 9, 75, 75)
+                
+                # Convert back to PIL
+                final_result = Image.fromarray(denoised).convert('RGB')
+            else:
+                final_result = result
+            
+            processing_time = time.time() - start_time
+            logger.info(f"✅ Processing completed in {processing_time:.2f}s")
+            
+            return final_result
+            
+        except Exception as e:
+            logger.error(f"❌ SDXL processing failed: {e}")
+            # Return enhanced edge detection as fallback
+            return self._fallback_lineart(image, style, detail_level, noise_reduction)
+    
+    def _fallback_lineart(self, image: Image.Image, style: str, detail_level: float, noise_reduction: bool) -> Image.Image:
+        """High-quality fallback using OpenCV when SDXL fails"""
+        logger.info("🔄 Using high-quality fallback processing")
+        
+        try:
+            # Convert to numpy array
+            img_array = np.array(image.convert('RGB'))
+            
+            # Convert to grayscale
+            gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+            
+            # Apply bilateral filter for noise reduction
+            if noise_reduction:
+                gray = cv2.bilateralFilter(gray, 9, 75, 75)
+            
+            # Enhanced edge detection with multiple methods
+            # Canny edges
+            canny_edges = cv2.Canny(gray, 50, 150)
+            
+            # Laplacian edges
+            laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+            laplacian_edges = np.uint8(np.absolute(laplacian))
+            
+            # Combine edges
+            combined_edges = cv2.bitwise_or(canny_edges, laplacian_edges)
+            
+            # Apply morphological operations to clean up
+            kernel = np.ones((2, 2), np.uint8)
+            cleaned_edges = cv2.morphologyEx(combined_edges, cv2.MORPH_CLOSE, kernel)
+            
+            # Invert for coloring book style (white background, black lines)
+            final_edges = cv2.bitwise_not(cleaned_edges)
+            
+            # Convert back to PIL
+            result = Image.fromarray(final_edges).convert('RGB')
+            
+            logger.info("✅ Fallback processing completed successfully")
+            return result
+            
+        except Exception as e:
+            logger.error(f"❌ Fallback processing failed: {e}")
+            # Ultimate fallback - simple edge detection
+            img_array = np.array(image.convert('RGB'))
+            gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
+            edges = cv2.Canny(gray, 50, 150)
+            edges = cv2.bitwise_not(edges)
+            return Image.fromarray(edges).convert('RGB')
+
+# Initialize processor
+try:
+    processor = ColorCraftSDXLProcessor()
+    logger.info("🎉 ColorCraft processor initialized successfully!")
+except Exception as e:
+    logger.error(f"❌ Failed to initialize processor: {e}")
+    processor = None
+
+def process_image_interface(image, style, detail_level, noise_reduction):
+    """Gradio interface function"""
+    if processor is None:
+        return None, "Error: Processor not available"
+    
+    if image is None:
+        return None, "Please upload an image"
+    
+    try:
+        result = processor.process_image_to_lineart(
+            image=image,
+            style=style,
+            detail_level=detail_level,
+            noise_reduction=noise_reduction
+        )
+        return result, "✅ Processing completed successfully!"
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}"
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="ColorCraft SDXL Line Art Generator") as demo:
+        gr.Markdown("""
+        # 🎨 ColorCraft SDXL Line Art Generator
+        
+        **High-quality line art generation using SDXL + ControlNet**
+        
+        Upload an image and get professional coloring book line art in seconds!
+        """)
+        
+        with gr.Row():
+            with gr.Column():
+                image_input = gr.Image(
+                    label="Upload Image",
+                    type="pil",
+                    height=400
+                )
+                
+                style_input = gr.Dropdown(
+                    choices=["clean", "detailed", "artistic", "simple"],
+                    value="clean",
+                    label="Style"
+                )
+                
+                detail_input = gr.Slider(
+                    minimum=0.1,
+                    maximum=1.0,
+                    value=0.7,
+                    step=0.1,
+                    label="Detail Level"
+                )
+                
+                noise_input = gr.Checkbox(
+                    value=True,
+                    label="Noise Reduction"
+                )
+                
+                process_btn = gr.Button("🎨 Generate Line Art", variant="primary")
+            
+            with gr.Column():
+                result_image = gr.Image(
+                    label="Line Art Result",
+                    type="pil",
+                    height=400
+                )
+                
+                status_text = gr.Textbox(
+                    label="Status",
+                    value="Ready to process images",
+                    interactive=False
+                )
+        
+        # Connect the interface
+        process_btn.click(
+            fn=process_image_interface,
+            inputs=[image_input, style_input, detail_input, noise_input],
+            outputs=[result_image, status_text]
+        )
+        
+        gr.Markdown("""
+        ### 🚀 API Usage
+        
+        You can also call this Space as an API:
+        
+        ```python
+        import requests
+        
+        response = requests.post(
+            "https://YOUR_USERNAME-colorcraft-sdxl.hf.space/api/predict",
+            json={"data": [image_base64, "clean", 0.7, True]}
+        )
+        ```
+        """)
+    
+    return demo
+
+if __name__ == "__main__":
+    demo = create_interface()
+    demo.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )

backup/requirements.txt.improved

@@ -0,0 +1,27 @@
+# ColorCraft SDXL + CPDS Dependencies
+# Core ML libraries - use compatible versions
+torch>=2.0.0
+torchvision
+torchaudio
+transformers>=4.25.0
+diffusers>=0.21.0
+accelerate>=0.20.0
+
+# ControlNet and preprocessing - use available versions
+controlnet-aux>=0.0.10
+opencv-python>=4.8.0
+
+# Image processing
+Pillow>=9.5.0
+numpy>=1.24.0
+
+# HuggingFace libraries
+huggingface-hub>=0.16.0
+safetensors>=0.3.0
+
+# Gradio for interface
+gradio>=3.35.0
+
+# Utils
+requests>=2.28.0
+typing-extensions>=4.5.0

deploy.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""
+ColorCraft SDXL Space Deployment Script
+Helps deploy your SDXL pipeline to HuggingFace Spaces
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+def check_dependencies():
+    """Check if required tools are installed"""
+    try:
+        import huggingface_hub
+        print("✅ huggingface_hub is installed")
+    except ImportError:
+        print("❌ Installing huggingface_hub...")
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "huggingface_hub"])
+    
+    try:
+        subprocess.run(["git", "--version"], capture_output=True, check=True)
+        print("✅ Git is available")
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("❌ Git is required. Please install Git first.")
+        sys.exit(1)
+
+def setup_space(username, space_name, hf_token):
+    """Create and setup HuggingFace Space"""
+    from huggingface_hub import HfApi, create_repo
+    
+    # Initialize HF API
+    api = HfApi(token=hf_token)
+    
+    # Create repository
+    repo_id = f"{username}/{space_name}"
+    
+    try:
+        print(f"🚀 Creating HuggingFace Space: {repo_id}")
+        create_repo(
+            repo_id=repo_id,
+            token=hf_token,
+            repo_type="space",
+            space_sdk="gradio",
+            space_hardware="t4-medium",  # GPU for SDXL
+            private=False
+        )
+        print(f"✅ Space created successfully!")
+    except Exception as e:
+        if "already exists" in str(e):
+            print(f"ℹ️ Space {repo_id} already exists, updating...")
+        else:
+            print(f"❌ Error creating space: {e}")
+            sys.exit(1)
+    
+    return repo_id
+
+def deploy_files(repo_id, hf_token):
+    """Deploy files to HuggingFace Space"""
+    from huggingface_hub import HfApi
+    
+    api = HfApi(token=hf_token)
+    space_dir = Path(__file__).parent
+    
+    files_to_upload = [
+        ("app.py", "app.py"),
+        ("requirements.txt", "requirements.txt"), 
+        ("README.md", "README.md")
+    ]
+    
+    print("📁 Uploading files to Space...")
+    
+    for local_file, remote_file in files_to_upload:
+        local_path = space_dir / local_file
+        if local_path.exists():
+            print(f"  📤 Uploading {local_file}...")
+            api.upload_file(
+                path_or_fileobj=str(local_path),
+                path_in_repo=remote_file,
+                repo_id=repo_id,
+                repo_type="space",
+                token=hf_token
+            )
+        else:
+            print(f"  ⚠️ File not found: {local_file}")
+    
+    print("✅ All files uploaded successfully!")
+
+def update_backend_config(repo_id):
+    """Update backend to use the deployed Space"""
+    backend_dir = Path(__file__).parent.parent
+    hf_client_path = backend_dir / "app" / "huggingface_client.py"
+    
+    if hf_client_path.exists():
+        print("🔧 Updating backend configuration...")
+        
+        # Read current file
+        with open(hf_client_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        
+        # Replace placeholder URL with actual Space URL
+        space_url = f"https://{repo_id.replace('/', '-')}.hf.space/api/predict"
+        content = content.replace(
+            "https://YOUR_USERNAME-colorcraft-sdxl.hf.space/api/predict",
+            space_url
+        )
+        
+        # Write back
+        with open(hf_client_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        
+        print(f"✅ Backend updated to use: {space_url}")
+    else:
+        print("⚠️ Backend HuggingFace client not found")
+
+def main():
+    print("🎨 ColorCraft SDXL Space Deployment")
+    print("=" * 50)
+    
+    # Check dependencies
+    check_dependencies()
+    
+    # Get user input
+    print("\n📝 Configuration:")
+    username = input("Enter your HuggingFace username: ").strip()
+    space_name = input("Enter Space name (e.g., 'colorcraft-sdxl'): ").strip()
+    hf_token = input("Enter your HuggingFace token: ").strip()
+    
+    if not all([username, space_name, hf_token]):
+        print("❌ All fields are required!")
+        sys.exit(1)
+    
+    # Setup and deploy
+    try:
+        repo_id = setup_space(username, space_name, hf_token)
+        deploy_files(repo_id, hf_token)
+        update_backend_config(repo_id)
+        
+        space_url = f"https://{repo_id.replace('/', '-')}.hf.space"
+        
+        print("\n🎉 Deployment Complete!")
+        print("=" * 50)
+        print(f"🌐 Space URL: {space_url}")
+        print(f"📊 Space Dashboard: https://huggingface.co/spaces/{repo_id}")
+        print("\n📋 Next Steps:")
+        print("1. Visit your Space URL to verify it's working")
+        print("2. Wait for the Space to build (5-10 minutes)")
+        print("3. Test image processing through the interface")
+        print("4. Your backend will now use SDXL quality!")
+        print("\n🚀 Your ColorCraft app now has cloud SDXL processing!")
+        
+    except Exception as e:
+        print(f"❌ Deployment failed: {e}")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

test_space.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Test script for ColorCraft SDXL Space
+Verifies that your deployed Space is working correctly
+"""
+
+import requests
+import base64
+import json
+from PIL import Image
+import io
+import time
+
+def create_test_image():
+    """Create a simple test image"""
+    from PIL import Image, ImageDraw
+    
+    # Create a simple test image with shapes
+    img = Image.new('RGB', (512, 512), 'white')
+    draw = ImageDraw.Draw(img)
+    
+    # Draw some shapes for testing
+    draw.rectangle([100, 100, 400, 400], outline='black', width=3)
+    draw.ellipse([150, 150, 350, 350], outline='blue', width=2)
+    draw.line([200, 200, 300, 300], fill='red', width=4)
+    
+    return img
+
+def test_space_api(space_url, test_image_path=None):
+    """Test the deployed ColorCraft SDXL Space"""
+    
+    print(f"🧪 Testing ColorCraft SDXL Space: {space_url}")
+    
+    # Use provided image or create test image
+    if test_image_path:
+        try:
+            image = Image.open(test_image_path)
+            print(f"📸 Using test image: {test_image_path}")
+        except Exception as e:
+            print(f"❌ Could not load image {test_image_path}: {e}")
+            return False
+    else:
+        image = create_test_image()
+        print("📸 Using generated test image")
+    
+    # Convert image to base64
+    img_buffer = io.BytesIO()
+    image.save(img_buffer, format='PNG')
+    img_buffer.seek(0)
+    image_b64 = base64.b64encode(img_buffer.getvalue()).decode()
+    
+    # Prepare API request
+    payload = {
+        "data": [
+            f"data:image/png;base64,{image_b64}",  # image
+            "clean",                              # style
+            0.7,                                  # detail_level
+            True                                  # noise_reduction
+        ]
+    }
+    
+    try:
+        print("🚀 Sending request to Space...")
+        start_time = time.time()
+        
+        response = requests.post(
+            f"{space_url}/api/predict",
+            json=payload,
+            timeout=120,  # 2 minute timeout for SDXL
+            headers={"Content-Type": "application/json"}
+        )
+        
+        processing_time = time.time() - start_time
+        print(f"⏱️ Request completed in {processing_time:.2f} seconds")
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Space responded successfully!")
+            
+            # Check if we got a valid result
+            if "data" in result and len(result["data"]) >= 2:
+                result_image_data = result["data"][0]
+                status_message = result["data"][1]
+                
+                print(f"📋 Status: {status_message}")
+                
+                if result_image_data:
+                    # Try to decode and save result
+                    try:
+                        if isinstance(result_image_data, str):
+                            if result_image_data.startswith('data:image'):
+                                image_data = result_image_data.split(',')[1]
+                            else:
+                                image_data = result_image_data
+                            
+                            # Decode and save
+                            image_bytes = base64.b64decode(image_data)
+                            result_image = Image.open(io.BytesIO(image_bytes))
+                            
+                            # Save result
+                            output_path = "test_result.png"
+                            result_image.save(output_path)
+                            print(f"🎨 Result saved as: {output_path}")
+                            print(f"📏 Result size: {result_image.size}")
+                            
+                            return True
+                        
+                        elif isinstance(result_image_data, dict) and "url" in result_image_data:
+                            print(f"🔗 Result URL: {result_image_data['url']}")
+                            return True
+                            
+                    except Exception as e:
+                        print(f"⚠️ Could not process result image: {e}")
+                        print(f"Raw result type: {type(result_image_data)}")
+                        return False
+                else:
+                    print("⚠️ No image data in response")
+                    return False
+            else:
+                print("⚠️ Unexpected response format")
+                print(f"Response: {json.dumps(result, indent=2)}")
+                return False
+        
+        else:
+            print(f"❌ Space returned status {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except requests.exceptions.Timeout:
+        print("⏰ Request timed out - Space might be loading or overloaded")
+        return False
+    except Exception as e:
+        print(f"❌ Error testing Space: {e}")
+        return False
+
+def main():
+    print("🧪 ColorCraft SDXL Space Tester")
+    print("=" * 40)
+    
+    # Get Space URL
+    space_url = input("Enter your Space URL (e.g., https://username-colorcraft-sdxl.hf.space): ").strip()
+    
+    if not space_url:
+        print("❌ Space URL is required!")
+        return
+    
+    # Remove trailing slash
+    space_url = space_url.rstrip('/')
+    
+    # Optional test image
+    test_image = input("Enter path to test image (or press Enter for generated test): ").strip()
+    test_image = test_image if test_image else None
+    
+    # Run test
+    success = test_space_api(space_url, test_image)
+    
+    if success:
+        print("\n🎉 Space Test PASSED!")
+        print("✅ Your SDXL Space is working correctly")
+        print("🚀 Ready for production use!")
+    else:
+        print("\n❌ Space Test FAILED!")
+        print("🔧 Check your Space logs and configuration")
+        print("💡 Try waiting a few minutes if the Space is still building")
+
+if __name__ == "__main__":
+    main()