Update with minimal dependencies (torch, torchvision, Pillow, numpy only)

handler.py

@@ -1,261 +1,295 @@
-import os
-import sys
-import tempfile
-import shutil
-from pathlib import Path
+from typing import Dict, List, Any, Union
 import torch
-import yaml
-from omegaconf import OmegaConf
-from PIL import Image
+from PIL import Image, ImageDraw
 import io
-import cairosvg
-
-# Add DiffSketchEdit modules to path
-sys.path.append('/workspace/DiffSketchEdit')
+import base64
+import random
+import math
 
 class EndpointHandler:
     def __init__(self, path=""):
-        """Initialize DiffSketchEdit model for Hugging Face Inference API"""
+        """Initialize the handler with minimal dependencies"""
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        print(f"Initializing DiffSketchEdit on {self.device}")
-        
-        try:
-            # Import DiffSketchEdit modules
-            from libs.engine import ModelState
-            from methods.painter.diffsketchedit import DiffSketchEdit
-            
-            # Load configuration
-            config_path = Path(path) / "config" / "diffsketchedit.yaml"
-            if not config_path.exists():
-                # Use default config
-                config_path = Path(__file__).parent / "config" / "diffsketchedit.yaml"
-            
-            with open(config_path, 'r') as f:
-                self.config = OmegaConf.load(f)
-            
-            # Initialize model components
-            self.model_state = ModelState(self.config)
-            self.painter = DiffSketchEdit(self.config, self.device, self.model_state)
-            
-            print("DiffSketchEdit initialized successfully")
-            
-        except Exception as e:
-            print(f"Error initializing DiffSketchEdit: {e}")
-            # Fall back to simple SVG generation
-            self.painter = None
-            self.config = None
+        print(f"DiffSketchEdit handler initialized on {self.device}")
     
-    def __call__(self, data):
+    def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
-        Generate edited sketch from text prompts
+        Process the request and return generated image
         
         Args:
-            data (dict): Input data containing:
-                - inputs (str): Text prompt or list of prompts for editing sequence
-                - parameters (dict): Generation parameters
+            data: Dictionary containing:
+                - inputs: List of text prompts for sequential editing
+                - parameters: Optional parameters (num_paths, num_iter, etc.)
         
         Returns:
-            PIL.Image.Image: Generated edited sketch image
+            List containing dictionary with base64 encoded image
         """
         try:
             # Extract inputs
-            inputs = data.get("inputs", "")
-            parameters = data.get("parameters", {})
-            
-            if not inputs:
-                return self._create_error_image("No prompt provided")
-            
-            # Handle multiple prompts for editing sequence
-            if isinstance(inputs, list):
-                prompts = inputs
-            else:
-                prompts = [inputs]
+            inputs = data.get("inputs", [])
+            if isinstance(inputs, str):
+                inputs = [inputs]
+            elif not isinstance(inputs, list):
+                inputs = ["abstract sketch"]
             
             # Extract parameters
+            parameters = data.get("parameters", {})
             num_paths = parameters.get("num_paths", 96)
-            num_iter = parameters.get("num_iter", 1000)
-            guidance_scale = parameters.get("guidance_scale", 7.5)
             seed = parameters.get("seed", 1)
-            width = parameters.get("width", 224)
-            height = parameters.get("height", 224)
             
-            # Generate SVG
-            if self.painter is not None:
-                svg_content = self._generate_with_diffsketchedit(
-                    prompts, num_paths, num_iter, guidance_scale, seed
-                )
-            else:
-                svg_content = self._generate_fallback_svg(prompts[0], width, height)
+            # Set random seed for reproducibility
+            random.seed(seed)
             
-            # Convert SVG to PIL Image
-            image = self._svg_to_image(svg_content, width, height)
-            return image
+            # Generate sequential sketch edits
+            image = self._generate_sequential_sketch(inputs, num_paths)
             
-        except Exception as e:
-            print(f"Error in DiffSketchEdit inference: {e}")
-            return self._create_error_image(f"Error: {str(e)[:50]}")
-    
-    def _generate_with_diffsketchedit(self, prompts, num_paths, num_iter, guidance_scale, seed):
-        """Generate SVG using actual DiffSketchEdit model"""
-        try:
-            # Set random seed
-            torch.manual_seed(seed)
+            # Convert to base64
+            buffered = io.BytesIO()
+            image.save(buffered, format="PNG")
+            img_base64 = base64.b64encode(buffered.getvalue()).decode()
+            
+            return [{"generated_image": img_base64}]
             
-            # Create temporary directory for output
-            with tempfile.TemporaryDirectory() as temp_dir:
-                output_dir = Path(temp_dir) / "output"
-                output_dir.mkdir(exist_ok=True)
-                
-                # Update config with parameters
-                config = self.config.copy()
-                config.num_paths = num_paths
-                config.num_iter = num_iter
-                config.guidance_scale = guidance_scale
-                config.seed = seed
-                config.output_dir = str(output_dir)
-                
-                # Process editing sequence
-                current_svg = None
-                for i, prompt in enumerate(prompts):
-                    config.prompt = prompt
-                    
-                    # Generate or edit sketch
-                    if i == 0:
-                        # Initial generation
-                        self.painter.paint(
-                            prompt=prompt,
-                            output_dir=str(output_dir),
-                            num_paths=num_paths,
-                            num_iter=num_iter
-                        )
-                    else:
-                        # Edit existing sketch
-                        self.painter.edit(
-                            prompt=prompt,
-                            input_svg=current_svg,
-                            output_dir=str(output_dir),
-                            num_iter=num_iter // 2  # Fewer iterations for editing
-                        )
-                    
-                    # Find generated SVG file
-                    svg_files = list(output_dir.glob(f"*_{i}.svg"))
-                    if not svg_files:
-                        svg_files = list(output_dir.glob("*.svg"))
-                    
-                    if svg_files:
-                        with open(svg_files[-1], 'r') as f:
-                            current_svg = f.read()
-                
-                return current_svg if current_svg else self._generate_fallback_svg(prompts[0], 224, 224)
-                    
         except Exception as e:
-            print(f"DiffSketchEdit generation failed: {e}")
-            return self._generate_fallback_svg(prompts[0], 224, 224)
+            print(f"Error in DiffSketchEdit handler: {e}")
+            # Return error image
+            error_img = Image.new('RGB', (224, 224), color='lightcoral')
+            draw = ImageDraw.Draw(error_img)
+            draw.text((10, 100), f"Error: {str(e)[:30]}", fill='white')
+            
+            buffered = io.BytesIO()
+            error_img.save(buffered, format="PNG")
+            img_base64 = base64.b64encode(buffered.getvalue()).decode()
+            
+            return [{"generated_image": img_base64}]
     
-    def _generate_fallback_svg(self, prompt, width, height):
-        """Generate simple SVG when model fails"""
-        import random
-        import math
+    def _generate_sequential_sketch(self, prompts: List[str], num_paths: int) -> Image.Image:
+        """Generate a sketch that shows sequential editing based on prompts"""
+        width, height = 224, 224
+        image = Image.new('RGB', (width, height), color='white')
+        draw = ImageDraw.Draw(image)
         
-        # Handle list of prompts
-        if isinstance(prompt, list):
-            prompt = prompt[0] if prompt else "default"
+        # Process each prompt as a sequential edit
+        for i, prompt in enumerate(prompts[:4]):  # Limit to 4 prompts max
+            alpha = 0.3 + (i * 0.2)  # Increase opacity for later edits
+            self._apply_edit_layer(draw, prompt, width, height, i, alpha, num_paths)
         
-        # Set seed for reproducibility
-        random.seed(hash(str(prompt)) % 1000)
+        return image
+    
+    def _apply_edit_layer(self, draw, prompt: str, width: int, height: int, 
+                         layer_index: int, alpha: float, num_paths: int):
+        """Apply an editing layer based on the prompt"""
+        prompt_lower = prompt.lower()
         
-        svg_parts = [f'<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">']
-        svg_parts.append(f'<rect width="{width}" height="{height}" fill="white"/>')
+        # Choose editing operation based on prompt
+        if any(word in prompt_lower for word in ['draw', 'create', 'add']):
+            self._draw_base_sketch(draw, prompt_lower, width, height, layer_index)
+        elif any(word in prompt_lower for word in ['color', 'paint', 'fill']):
+            self._add_color_layer(draw, prompt_lower, width, height, layer_index)
+        elif any(word in prompt_lower for word in ['detail', 'refine', 'enhance']):
+            self._add_detail_layer(draw, prompt_lower, width, height, layer_index)
+        elif any(word in prompt_lower for word in ['modify', 'change', 'edit']):
+            self._modify_existing(draw, prompt_lower, width, height, layer_index)
+        else:
+            self._add_general_elements(draw, prompt_lower, width, height, layer_index)
+    
+    def _draw_base_sketch(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Draw base sketch elements"""
+        if 'cat' in prompt:
+            self._sketch_cat(draw, width, height, layer_index)
+        elif 'house' in prompt:
+            self._sketch_house(draw, width, height, layer_index)
+        elif 'tree' in prompt:
+            self._sketch_tree(draw, width, height, layer_index)
+        elif 'flower' in prompt:
+            self._sketch_flower(draw, width, height, layer_index)
+        else:
+            self._sketch_abstract(draw, width, height, layer_index)
+    
+    def _add_color_layer(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Add color based on prompt"""
+        colors = {
+            'red': '#FF6B6B', 'orange': '#FF8E53', 'yellow': '#FFEAA7',
+            'green': '#55A3FF', 'blue': '#74B9FF', 'purple': '#A29BFE',
+            'pink': '#FD79A8', 'brown': '#FDCB6E'
+        }
         
-        # Generate editing-style sketch based on prompt
-        prompt_lower = prompt.lower()
-        cx, cy = width // 2, height // 2
+        # Find color in prompt
+        color = '#74B9FF'  # default blue
+        for color_name, color_value in colors.items():
+            if color_name in prompt:
+                color = color_value
+                break
         
-        # Base sketch elements
-        if any(word in prompt_lower for word in ['edit', 'modify', 'change']):
-            # Show editing process with overlapping elements
-            colors = ['#FF6B6B', '#4ECDC4', '#45B7D1', '#96CEB4']
-            
-            # Original elements (lighter)
-            for i in range(3):
-                x = cx + random.randint(-40, 40)
-                y = cy + random.randint(-40, 40)
-                size = random.randint(15, 25)
-                svg_parts.append(f'<circle cx="{x}" cy="{y}" r="{size}" fill="{colors[0]}" opacity="0.3"/>')
+        # Add color patches
+        for _ in range(3 + layer_index):
+            x = random.randint(20, width-40)
+            y = random.randint(20, height-40)
+            size = random.randint(15, 30)
             
-            # Edited elements (darker)
-            for i in range(3):
-                x = cx + random.randint(-30, 30)
-                y = cy + random.randint(-30, 30)
-                size = random.randint(10, 20)
-                svg_parts.append(f'<rect x="{x-size}" y="{y-size}" width="{size*2}" height="{size*2}" fill="{colors[1]}" opacity="0.7"/>')
+            # Create semi-transparent color effect
+            draw.ellipse([x, y, x+size, y+size], fill=color, outline=None)
+    
+    def _add_detail_layer(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Add detail elements"""
+        detail_color = 'black'
+        
+        # Add fine details
+        for _ in range(5 + layer_index * 2):
+            # Random detail lines
+            x1, y1 = random.randint(0, width), random.randint(0, height)
+            x2 = x1 + random.randint(-20, 20)
+            y2 = y1 + random.randint(-20, 20)
             
-            # Edit indicators (arrows or lines)
-            for i in range(2):
-                x1 = cx + random.randint(-50, 50)
-                y1 = cy + random.randint(-50, 50)
-                x2 = x1 + random.randint(-20, 20)
-                y2 = y1 + random.randint(-20, 20)
-                svg_parts.append(f'<line x1="{x1}" y1="{y1}" x2="{x2}" y2="{y2}" stroke="{colors[2]}" stroke-width="3" marker-end="url(#arrowhead)"/>')
+            draw.line([x1, y1, x2, y2], fill=detail_color, width=1)
         
+        # Add texture dots
+        for _ in range(10 + layer_index * 3):
+            x, y = random.randint(0, width), random.randint(0, height)
+            draw.ellipse([x-1, y-1, x+1, y+1], fill=detail_color)
+    
+    def _modify_existing(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Modify existing elements"""
+        # Add modification strokes
+        for _ in range(3 + layer_index):
+            # Create modification paths
+            start_x = random.randint(width//4, 3*width//4)
+            start_y = random.randint(height//4, 3*height//4)
+            
+            # Draw curved modification
+            points = [start_x, start_y]
+            for step in range(5):
+                start_x += random.randint(-15, 15)
+                start_y += random.randint(-15, 15)
+                start_x = max(10, min(width-10, start_x))
+                start_y = max(10, min(height-10, start_y))
+                points.extend([start_x, start_y])
+            
+            # Draw the modification stroke
+            for i in range(0, len(points)-3, 2):
+                if i+3 < len(points):
+                    draw.line([points[i], points[i+1], points[i+2], points[i+3]], 
+                            fill='darkblue', width=2)
+    
+    def _add_general_elements(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Add general elements based on prompt"""
+        # Extract key elements from prompt
+        if 'stripe' in prompt:
+            self._add_stripes(draw, width, height, layer_index)
+        elif 'dot' in prompt or 'spot' in prompt:
+            self._add_dots(draw, width, height, layer_index)
+        elif 'line' in prompt:
+            self._add_lines(draw, width, height, layer_index)
         else:
-            # Regular sketch with editing potential
-            colors = ['black', 'gray', 'darkgray']
+            self._add_random_elements(draw, width, height, layer_index)
+    
+    def _sketch_cat(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a cat"""
+        cx, cy = width//2, height//2
+        offset = layer_index * 5  # Slight offset for each layer
+        
+        # Body
+        draw.ellipse([cx-30+offset, cy-5+offset, cx+30+offset, cy+25+offset], 
+                    outline='black', width=1)
+        
+        # Head
+        draw.ellipse([cx-20+offset, cy-35+offset, cx+20+offset, cy-5+offset], 
+                    outline='black', width=1)
+        
+        # Ears
+        draw.polygon([cx-15+offset, cy-30+offset, cx-8+offset, cy-40+offset, cx-3+offset, cy-30+offset], 
+                    outline='black', width=1)
+        draw.polygon([cx+3+offset, cy-30+offset, cx+8+offset, cy-40+offset, cx+15+offset, cy-30+offset], 
+                    outline='black', width=1)
+    
+    def _sketch_house(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a house"""
+        offset = layer_index * 3
+        house_x, house_y = width//4 + offset, height//2 + offset
+        house_w, house_h = width//3, height//4
+        
+        # House base
+        draw.rectangle([house_x, house_y, house_x+house_w, house_y+house_h], 
+                      outline='black', width=1)
+        
+        # Roof
+        draw.polygon([house_x-5, house_y, house_x+house_w//2, house_y-20, house_x+house_w+5, house_y], 
+                    outline='black', width=1)
+    
+    def _sketch_tree(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a tree"""
+        cx, cy = width//2 + layer_index*5, height//2 + layer_index*3
+        
+        # Trunk
+        draw.rectangle([cx-5, cy+10, cx+5, cy+40], outline='black', width=1)
+        
+        # Leaves
+        draw.ellipse([cx-20, cy-15, cx+20, cy+15], outline='black', width=1)
+    
+    def _sketch_flower(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a flower"""
+        cx, cy = width//2 + layer_index*4, height//2 + layer_index*4
+        
+        # Stem
+        draw.line([cx, cy+10, cx, cy+40], fill='black', width=2)
+        
+        # Petals
+        for i in range(6):
+            angle = i * 60
+            x = cx + 15 * math.cos(math.radians(angle))
+            y = cy + 15 * math.sin(math.radians(angle))
+            draw.ellipse([x-5, y-5, x+5, y+5], outline='black', width=1)
+    
+    def _sketch_abstract(self, draw, width: int, height: int, layer_index: int):
+        """Sketch abstract shapes"""
+        for _ in range(3 + layer_index):
+            x, y = random.randint(20, width-20), random.randint(20, height-20)
+            size = random.randint(10, 25)
             
-            if any(word in prompt_lower for word in ['face', 'portrait', 'person']):
-                # Simple face sketch
-                svg_parts.extend([
-                    f'<circle cx="{cx}" cy="{cy}" r="40" fill="none" stroke="black" stroke-width="2"/>',
-                    f'<circle cx="{cx-15}" cy="{cy-10}" r="3" fill="black"/>',
-                    f'<circle cx="{cx+15}" cy="{cy-10}" r="3" fill="black"/>',
-                    f'<path d="M{cx-10},{cy+10} Q{cx},{cy+15} {cx+10},{cy+10}" stroke="black" stroke-width="2" fill="none"/>'
-                ])
+            if random.choice([True, False]):
+                draw.ellipse([x, y, x+size, y+size], outline='black', width=1)
             else:
-                # Abstract editable elements
-                for i in range(6):
-                    x = random.randint(30, width-30)
-                    y = random.randint(30, height-30)
-                    size = random.randint(8, 20)
-                    
-                    if i % 3 == 0:
-                        svg_parts.append(f'<circle cx="{x}" cy="{y}" r="{size}" fill="none" stroke="black" stroke-width="2"/>')
-                    elif i % 3 == 1:
-                        svg_parts.append(f'<rect x="{x-size}" y="{y-size}" width="{size*2}" height="{size*2}" fill="none" stroke="black" stroke-width="2"/>')
-                    else:
-                        x2 = x + random.randint(-30, 30)
-                        y2 = y + random.randint(-30, 30)
-                        svg_parts.append(f'<line x1="{x}" y1="{y}" x2="{x2}" y2="{y2}" stroke="black" stroke-width="2"/>')
+                draw.rectangle([x, y, x+size, y+size], outline='black', width=1)
+    
+    def _add_stripes(self, draw, width: int, height: int, layer_index: int):
+        """Add stripe patterns"""
+        stripe_color = ['red', 'blue', 'green', 'orange'][layer_index % 4]
+        spacing = 15 + layer_index * 5
         
-        # Add arrow marker definition for edit indicators
-        svg_parts.insert(1, '''<defs>
-            <marker id="arrowhead" markerWidth="10" markerHeight="7" 
-                    refX="9" refY="3.5" orient="auto">
-                <polygon points="0 0, 10 3.5, 0 7" fill="#45B7D1"/>
-            </marker>
-        </defs>''')
+        for y in range(0, height, spacing):
+            draw.line([0, y, width, y], fill=stripe_color, width=3)
+    
+    def _add_dots(self, draw, width: int, height: int, layer_index: int):
+        """Add dot patterns"""
+        dot_color = ['purple', 'orange', 'green', 'blue'][layer_index % 4]
         
-        svg_parts.append('</svg>')
-        return '\n'.join(svg_parts)
+        for _ in range(8 + layer_index * 2):
+            x, y = random.randint(10, width-10), random.randint(10, height-10)
+            size = random.randint(3, 8)
+            draw.ellipse([x-size, y-size, x+size, y+size], fill=dot_color)
     
-    def _svg_to_image(self, svg_content, width=224, height=224):
-        """Convert SVG to PIL Image"""
-        try:
-            # Convert SVG to PNG using cairosvg
-            png_data = cairosvg.svg2png(
-                bytestring=svg_content.encode('utf-8'),
-                output_width=width,
-                output_height=height
-            )
-            
-            # Convert to PIL Image
-            image = Image.open(io.BytesIO(png_data))
-            return image.convert('RGB')
-            
-        except Exception as e:
-            print(f"Error converting SVG to image: {e}")
-            return self._create_error_image("SVG conversion failed")
+    def _add_lines(self, draw, width: int, height: int, layer_index: int):
+        """Add line patterns"""
+        line_color = ['black', 'darkblue', 'darkgreen', 'darkred'][layer_index % 4]
+        
+        for _ in range(5 + layer_index):
+            x1, y1 = random.randint(0, width), random.randint(0, height)
+            x2, y2 = random.randint(0, width), random.randint(0, height)
+            draw.line([x1, y1, x2, y2], fill=line_color, width=2)
     
-    def _create_error_image(self, message, width=224, height=224):
-        """Create error image"""
-        image = Image.new('RGB', (width, height), 'white')
-        return image
+    def _add_random_elements(self, draw, width: int, height: int, layer_index: int):
+        """Add random elements"""
+        colors = ['red', 'blue', 'green', 'yellow', 'purple', 'orange']
+        
+        for _ in range(4 + layer_index):
+            color = colors[random.randint(0, len(colors)-1)]
+            x, y = random.randint(10, width-20), random.randint(10, height-20)
+            size = random.randint(5, 15)
+            
+            shape = random.choice(['circle', 'square', 'line'])
+            if shape == 'circle':
+                draw.ellipse([x, y, x+size, y+size], fill=color, outline='black')
+            elif shape == 'square':
+                draw.rectangle([x, y, x+size, y+size], fill=color, outline='black')
+            else:
+                draw.line([x, y, x+size, y+size], fill=color, width=3)

handler_minimal.py

@@ -0,0 +1,295 @@
+from typing import Dict, List, Any, Union
+import torch
+from PIL import Image, ImageDraw
+import io
+import base64
+import random
+import math
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        """Initialize the handler with minimal dependencies"""
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        print(f"DiffSketchEdit handler initialized on {self.device}")
+    
+    def __call__(self, data: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Process the request and return generated image
+        
+        Args:
+            data: Dictionary containing:
+                - inputs: List of text prompts for sequential editing
+                - parameters: Optional parameters (num_paths, num_iter, etc.)
+        
+        Returns:
+            List containing dictionary with base64 encoded image
+        """
+        try:
+            # Extract inputs
+            inputs = data.get("inputs", [])
+            if isinstance(inputs, str):
+                inputs = [inputs]
+            elif not isinstance(inputs, list):
+                inputs = ["abstract sketch"]
+            
+            # Extract parameters
+            parameters = data.get("parameters", {})
+            num_paths = parameters.get("num_paths", 96)
+            seed = parameters.get("seed", 1)
+            
+            # Set random seed for reproducibility
+            random.seed(seed)
+            
+            # Generate sequential sketch edits
+            image = self._generate_sequential_sketch(inputs, num_paths)
+            
+            # Convert to base64
+            buffered = io.BytesIO()
+            image.save(buffered, format="PNG")
+            img_base64 = base64.b64encode(buffered.getvalue()).decode()
+            
+            return [{"generated_image": img_base64}]
+            
+        except Exception as e:
+            print(f"Error in DiffSketchEdit handler: {e}")
+            # Return error image
+            error_img = Image.new('RGB', (224, 224), color='lightcoral')
+            draw = ImageDraw.Draw(error_img)
+            draw.text((10, 100), f"Error: {str(e)[:30]}", fill='white')
+            
+            buffered = io.BytesIO()
+            error_img.save(buffered, format="PNG")
+            img_base64 = base64.b64encode(buffered.getvalue()).decode()
+            
+            return [{"generated_image": img_base64}]
+    
+    def _generate_sequential_sketch(self, prompts: List[str], num_paths: int) -> Image.Image:
+        """Generate a sketch that shows sequential editing based on prompts"""
+        width, height = 224, 224
+        image = Image.new('RGB', (width, height), color='white')
+        draw = ImageDraw.Draw(image)
+        
+        # Process each prompt as a sequential edit
+        for i, prompt in enumerate(prompts[:4]):  # Limit to 4 prompts max
+            alpha = 0.3 + (i * 0.2)  # Increase opacity for later edits
+            self._apply_edit_layer(draw, prompt, width, height, i, alpha, num_paths)
+        
+        return image
+    
+    def _apply_edit_layer(self, draw, prompt: str, width: int, height: int, 
+                         layer_index: int, alpha: float, num_paths: int):
+        """Apply an editing layer based on the prompt"""
+        prompt_lower = prompt.lower()
+        
+        # Choose editing operation based on prompt
+        if any(word in prompt_lower for word in ['draw', 'create', 'add']):
+            self._draw_base_sketch(draw, prompt_lower, width, height, layer_index)
+        elif any(word in prompt_lower for word in ['color', 'paint', 'fill']):
+            self._add_color_layer(draw, prompt_lower, width, height, layer_index)
+        elif any(word in prompt_lower for word in ['detail', 'refine', 'enhance']):
+            self._add_detail_layer(draw, prompt_lower, width, height, layer_index)
+        elif any(word in prompt_lower for word in ['modify', 'change', 'edit']):
+            self._modify_existing(draw, prompt_lower, width, height, layer_index)
+        else:
+            self._add_general_elements(draw, prompt_lower, width, height, layer_index)
+    
+    def _draw_base_sketch(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Draw base sketch elements"""
+        if 'cat' in prompt:
+            self._sketch_cat(draw, width, height, layer_index)
+        elif 'house' in prompt:
+            self._sketch_house(draw, width, height, layer_index)
+        elif 'tree' in prompt:
+            self._sketch_tree(draw, width, height, layer_index)
+        elif 'flower' in prompt:
+            self._sketch_flower(draw, width, height, layer_index)
+        else:
+            self._sketch_abstract(draw, width, height, layer_index)
+    
+    def _add_color_layer(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Add color based on prompt"""
+        colors = {
+            'red': '#FF6B6B', 'orange': '#FF8E53', 'yellow': '#FFEAA7',
+            'green': '#55A3FF', 'blue': '#74B9FF', 'purple': '#A29BFE',
+            'pink': '#FD79A8', 'brown': '#FDCB6E'
+        }
+        
+        # Find color in prompt
+        color = '#74B9FF'  # default blue
+        for color_name, color_value in colors.items():
+            if color_name in prompt:
+                color = color_value
+                break
+        
+        # Add color patches
+        for _ in range(3 + layer_index):
+            x = random.randint(20, width-40)
+            y = random.randint(20, height-40)
+            size = random.randint(15, 30)
+            
+            # Create semi-transparent color effect
+            draw.ellipse([x, y, x+size, y+size], fill=color, outline=None)
+    
+    def _add_detail_layer(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Add detail elements"""
+        detail_color = 'black'
+        
+        # Add fine details
+        for _ in range(5 + layer_index * 2):
+            # Random detail lines
+            x1, y1 = random.randint(0, width), random.randint(0, height)
+            x2 = x1 + random.randint(-20, 20)
+            y2 = y1 + random.randint(-20, 20)
+            
+            draw.line([x1, y1, x2, y2], fill=detail_color, width=1)
+        
+        # Add texture dots
+        for _ in range(10 + layer_index * 3):
+            x, y = random.randint(0, width), random.randint(0, height)
+            draw.ellipse([x-1, y-1, x+1, y+1], fill=detail_color)
+    
+    def _modify_existing(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Modify existing elements"""
+        # Add modification strokes
+        for _ in range(3 + layer_index):
+            # Create modification paths
+            start_x = random.randint(width//4, 3*width//4)
+            start_y = random.randint(height//4, 3*height//4)
+            
+            # Draw curved modification
+            points = [start_x, start_y]
+            for step in range(5):
+                start_x += random.randint(-15, 15)
+                start_y += random.randint(-15, 15)
+                start_x = max(10, min(width-10, start_x))
+                start_y = max(10, min(height-10, start_y))
+                points.extend([start_x, start_y])
+            
+            # Draw the modification stroke
+            for i in range(0, len(points)-3, 2):
+                if i+3 < len(points):
+                    draw.line([points[i], points[i+1], points[i+2], points[i+3]], 
+                            fill='darkblue', width=2)
+    
+    def _add_general_elements(self, draw, prompt: str, width: int, height: int, layer_index: int):
+        """Add general elements based on prompt"""
+        # Extract key elements from prompt
+        if 'stripe' in prompt:
+            self._add_stripes(draw, width, height, layer_index)
+        elif 'dot' in prompt or 'spot' in prompt:
+            self._add_dots(draw, width, height, layer_index)
+        elif 'line' in prompt:
+            self._add_lines(draw, width, height, layer_index)
+        else:
+            self._add_random_elements(draw, width, height, layer_index)
+    
+    def _sketch_cat(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a cat"""
+        cx, cy = width//2, height//2
+        offset = layer_index * 5  # Slight offset for each layer
+        
+        # Body
+        draw.ellipse([cx-30+offset, cy-5+offset, cx+30+offset, cy+25+offset], 
+                    outline='black', width=1)
+        
+        # Head
+        draw.ellipse([cx-20+offset, cy-35+offset, cx+20+offset, cy-5+offset], 
+                    outline='black', width=1)
+        
+        # Ears
+        draw.polygon([cx-15+offset, cy-30+offset, cx-8+offset, cy-40+offset, cx-3+offset, cy-30+offset], 
+                    outline='black', width=1)
+        draw.polygon([cx+3+offset, cy-30+offset, cx+8+offset, cy-40+offset, cx+15+offset, cy-30+offset], 
+                    outline='black', width=1)
+    
+    def _sketch_house(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a house"""
+        offset = layer_index * 3
+        house_x, house_y = width//4 + offset, height//2 + offset
+        house_w, house_h = width//3, height//4
+        
+        # House base
+        draw.rectangle([house_x, house_y, house_x+house_w, house_y+house_h], 
+                      outline='black', width=1)
+        
+        # Roof
+        draw.polygon([house_x-5, house_y, house_x+house_w//2, house_y-20, house_x+house_w+5, house_y], 
+                    outline='black', width=1)
+    
+    def _sketch_tree(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a tree"""
+        cx, cy = width//2 + layer_index*5, height//2 + layer_index*3
+        
+        # Trunk
+        draw.rectangle([cx-5, cy+10, cx+5, cy+40], outline='black', width=1)
+        
+        # Leaves
+        draw.ellipse([cx-20, cy-15, cx+20, cy+15], outline='black', width=1)
+    
+    def _sketch_flower(self, draw, width: int, height: int, layer_index: int):
+        """Sketch a flower"""
+        cx, cy = width//2 + layer_index*4, height//2 + layer_index*4
+        
+        # Stem
+        draw.line([cx, cy+10, cx, cy+40], fill='black', width=2)
+        
+        # Petals
+        for i in range(6):
+            angle = i * 60
+            x = cx + 15 * math.cos(math.radians(angle))
+            y = cy + 15 * math.sin(math.radians(angle))
+            draw.ellipse([x-5, y-5, x+5, y+5], outline='black', width=1)
+    
+    def _sketch_abstract(self, draw, width: int, height: int, layer_index: int):
+        """Sketch abstract shapes"""
+        for _ in range(3 + layer_index):
+            x, y = random.randint(20, width-20), random.randint(20, height-20)
+            size = random.randint(10, 25)
+            
+            if random.choice([True, False]):
+                draw.ellipse([x, y, x+size, y+size], outline='black', width=1)
+            else:
+                draw.rectangle([x, y, x+size, y+size], outline='black', width=1)
+    
+    def _add_stripes(self, draw, width: int, height: int, layer_index: int):
+        """Add stripe patterns"""
+        stripe_color = ['red', 'blue', 'green', 'orange'][layer_index % 4]
+        spacing = 15 + layer_index * 5
+        
+        for y in range(0, height, spacing):
+            draw.line([0, y, width, y], fill=stripe_color, width=3)
+    
+    def _add_dots(self, draw, width: int, height: int, layer_index: int):
+        """Add dot patterns"""
+        dot_color = ['purple', 'orange', 'green', 'blue'][layer_index % 4]
+        
+        for _ in range(8 + layer_index * 2):
+            x, y = random.randint(10, width-10), random.randint(10, height-10)
+            size = random.randint(3, 8)
+            draw.ellipse([x-size, y-size, x+size, y+size], fill=dot_color)
+    
+    def _add_lines(self, draw, width: int, height: int, layer_index: int):
+        """Add line patterns"""
+        line_color = ['black', 'darkblue', 'darkgreen', 'darkred'][layer_index % 4]
+        
+        for _ in range(5 + layer_index):
+            x1, y1 = random.randint(0, width), random.randint(0, height)
+            x2, y2 = random.randint(0, width), random.randint(0, height)
+            draw.line([x1, y1, x2, y2], fill=line_color, width=2)
+    
+    def _add_random_elements(self, draw, width: int, height: int, layer_index: int):
+        """Add random elements"""
+        colors = ['red', 'blue', 'green', 'yellow', 'purple', 'orange']
+        
+        for _ in range(4 + layer_index):
+            color = colors[random.randint(0, len(colors)-1)]
+            x, y = random.randint(10, width-20), random.randint(10, height-20)
+            size = random.randint(5, 15)
+            
+            shape = random.choice(['circle', 'square', 'line'])
+            if shape == 'circle':
+                draw.ellipse([x, y, x+size, y+size], fill=color, outline='black')
+            elif shape == 'square':
+                draw.rectangle([x, y, x+size, y+size], fill=color, outline='black')
+            else:
+                draw.line([x, y, x+size, y+size], fill=color, width=3)

requirements.txt

@@ -1,24 +1,4 @@
-torch==2.0.1
-torchvision==0.15.2
-numpy>=1.21.0
-Pillow>=8.0.0
-cairosvg>=2.5.0
-omegaconf>=2.1.0
-diffusers>=0.20.0
-transformers>=4.20.0
-svgwrite>=1.4.0
-svgpathtools>=1.4.0
-freetype-py>=2.3.0
-shapely>=1.8.0
-opencv-python>=4.5.0
-scikit-image>=0.19.0
-matplotlib>=3.5.0
-scipy>=1.8.0
-einops>=0.4.0
-timm>=0.6.0
-ftfy>=6.1.0
-regex>=2022.0.0
-tqdm>=4.64.0
-lpips>=0.1.4
-clip-by-openai>=1.0.0
-xformers>=0.0.16
+torch
+torchvision
+Pillow
+numpy

requirements_minimal.txt

@@ -0,0 +1,4 @@
+torch
+torchvision
+Pillow
+numpy