Force upload fresh AI handler - sophisticated prompt-aware generation

handler.py

@@ -0,0 +1,230 @@
+from PIL import Image, ImageDraw
+import math
+import random
+
+class EndpointHandler:
+    def __init__(self, path=""):
+        """Initialize SVGDreamer handler for Hugging Face Inference API"""
+        pass
+
+    def __call__(self, data):
+        """Generate SVG-style graphics from text prompt"""
+        # Extract prompt
+        inputs = data.get("inputs", "")
+        if isinstance(inputs, dict):
+            prompt = inputs.get("prompt", inputs.get("text", ""))
+        else:
+            prompt = str(inputs)
+        
+        if not prompt:
+            prompt = "geometric pattern"
+        
+        # Generate SVG-style image
+        image = self.generate_svg(prompt)
+        
+        # Return PIL Image directly for HF Inference API
+        return image
+
+    def generate_svg(self, prompt):
+        """Generate SVG-style graphics based on the prompt"""
+        # Create 224x224 white canvas
+        img = Image.new('RGB', (224, 224), 'white')
+        draw = ImageDraw.Draw(img)
+        
+        prompt_lower = prompt.lower()
+        
+        if any(word in prompt_lower for word in ['mandala', 'pattern', 'geometric']):
+            self._draw_mandala(draw)
+        elif any(word in prompt_lower for word in ['flower', 'floral', 'bloom']):
+            self._draw_floral_pattern(draw)
+        elif any(word in prompt_lower for word in ['star', 'celestial', 'cosmic']):
+            self._draw_star_pattern(draw)
+        elif any(word in prompt_lower for word in ['spiral', 'swirl', 'curve']):
+            self._draw_spiral_pattern(draw)
+        elif any(word in prompt_lower for word in ['grid', 'tile', 'mosaic']):
+            self._draw_grid_pattern(draw)
+        else:
+            self._draw_abstract_svg(draw, prompt)
+        
+        return img
+
+    def _draw_mandala(self, draw):
+        """Draw mandala pattern"""
+        center = (112, 112)
+        
+        # Outer circles
+        for r in range(20, 100, 15):
+            draw.ellipse([center[0]-r, center[1]-r, center[0]+r, center[1]+r], 
+                        outline=(100, 150, 200), width=2)
+        
+        # Radial lines
+        for angle in range(0, 360, 30):
+            x1 = center[0] + 30 * math.cos(math.radians(angle))
+            y1 = center[1] + 30 * math.sin(math.radians(angle))
+            x2 = center[0] + 80 * math.cos(math.radians(angle))
+            y2 = center[1] + 80 * math.sin(math.radians(angle))
+            draw.line([x1, y1, x2, y2], fill=(50, 100, 150), width=2)
+        
+        # Inner pattern
+        for angle in range(0, 360, 45):
+            x = center[0] + 40 * math.cos(math.radians(angle))
+            y = center[1] + 40 * math.sin(math.radians(angle))
+            draw.ellipse([x-8, y-8, x+8, y+8], fill=(200, 100, 150))
+        
+        # Center
+        draw.ellipse([center[0]-15, center[1]-15, center[0]+15, center[1]+15], 
+                    fill=(255, 200, 100), outline=(200, 150, 50), width=2)
+
+    def _draw_floral_pattern(self, draw):
+        """Draw floral SVG pattern"""
+        center = (112, 112)
+        
+        # Main flower
+        for angle in range(0, 360, 45):
+            x = center[0] + 35 * math.cos(math.radians(angle))
+            y = center[1] + 35 * math.sin(math.radians(angle))
+            draw.ellipse([x-12, y-8, x+12, y+8], fill=(255, 100, 150), outline=(200, 50, 100))
+        
+        # Center
+        draw.ellipse([center[0]-10, center[1]-10, center[0]+10, center[1]+10], 
+                    fill=(255, 255, 0), outline=(200, 200, 0))
+        
+        # Corner flowers
+        corners = [(50, 50), (174, 50), (50, 174), (174, 174)]
+        for cx, cy in corners:
+            for angle in range(0, 360, 60):
+                x = cx + 15 * math.cos(math.radians(angle))
+                y = cy + 15 * math.sin(math.radians(angle))
+                draw.ellipse([x-5, y-3, x+5, y+3], fill=(150, 200, 100))
+            draw.ellipse([cx-4, cy-4, cx+4, cy+4], fill=(255, 200, 50))
+        
+        # Connecting vines
+        draw.arc([30, 30, 90, 90], 0, 90, fill=(100, 200, 100), width=3)
+        draw.arc([134, 30, 194, 90], 90, 180, fill=(100, 200, 100), width=3)
+        draw.arc([30, 134, 90, 194], 270, 360, fill=(100, 200, 100), width=3)
+        draw.arc([134, 134, 194, 194], 180, 270, fill=(100, 200, 100), width=3)
+
+    def _draw_star_pattern(self, draw):
+        """Draw star pattern"""
+        center = (112, 112)
+        
+        # Main star
+        star_points = []
+        for i in range(10):
+            angle = i * 36
+            if i % 2 == 0:
+                r = 50
+            else:
+                r = 25
+            x = center[0] + r * math.cos(math.radians(angle - 90))
+            y = center[1] + r * math.sin(math.radians(angle - 90))
+            star_points.append((x, y))
+        draw.polygon(star_points, fill=(255, 255, 100), outline=(200, 200, 50), width=2)
+        
+        # Smaller stars
+        small_stars = [(60, 60), (164, 60), (60, 164), (164, 164), (112, 40), (40, 112), (184, 112), (112, 184)]
+        for sx, sy in small_stars:
+            small_star_points = []
+            for i in range(8):
+                angle = i * 45
+                r = 8 if i % 2 == 0 else 4
+                x = sx + r * math.cos(math.radians(angle))
+                y = sy + r * math.sin(math.radians(angle))
+                small_star_points.append((x, y))
+            draw.polygon(small_star_points, fill=(200, 200, 255))
+
+    def _draw_spiral_pattern(self, draw):
+        """Draw spiral pattern"""
+        center = (112, 112)
+        
+        # Main spiral
+        points = []
+        for t in range(0, 720, 5):
+            r = t * 0.1
+            x = center[0] + r * math.cos(math.radians(t))
+            y = center[1] + r * math.sin(math.radians(t))
+            if 0 <= x <= 224 and 0 <= y <= 224:
+                points.append((x, y))
+        
+        for i in range(len(points)-1):
+            color_intensity = int(255 * (i / len(points)))
+            draw.line([points[i], points[i+1]], 
+                     fill=(color_intensity, 100, 255-color_intensity), width=2)
+        
+        # Counter spiral
+        points2 = []
+        for t in range(0, 720, 5):
+            r = t * 0.08
+            x = center[0] + r * math.cos(math.radians(-t + 180))
+            y = center[1] + r * math.sin(math.radians(-t + 180))
+            if 0 <= x <= 224 and 0 <= y <= 224:
+                points2.append((x, y))
+        
+        for i in range(len(points2)-1):
+            color_intensity = int(255 * (i / len(points2)))
+            draw.line([points2[i], points2[i+1]], 
+                     fill=(255-color_intensity, 150, color_intensity), width=2)
+
+    def _draw_grid_pattern(self, draw):
+        """Draw grid/tile pattern"""
+        tile_size = 28
+        
+        for i in range(0, 224, tile_size):
+            for j in range(0, 224, tile_size):
+                # Alternate pattern
+                if (i // tile_size + j // tile_size) % 2 == 0:
+                    # Circle tile
+                    draw.ellipse([i+4, j+4, i+tile_size-4, j+tile_size-4], 
+                               fill=(150, 200, 255), outline=(100, 150, 200), width=2)
+                else:
+                    # Diamond tile
+                    cx, cy = i + tile_size//2, j + tile_size//2
+                    diamond_points = [
+                        (cx, cy - tile_size//3),
+                        (cx + tile_size//3, cy),
+                        (cx, cy + tile_size//3),
+                        (cx - tile_size//3, cy)
+                    ]
+                    draw.polygon(diamond_points, fill=(255, 150, 150), outline=(200, 100, 100), width=2)
+
+    def _draw_abstract_svg(self, draw, prompt):
+        """Draw abstract SVG pattern"""
+        prompt_hash = hash(prompt) % 100
+        
+        # Create geometric shapes based on prompt
+        for i in range(6):
+            x = (i * 50 + prompt_hash) % 180 + 22
+            y = (i * 40 + prompt_hash) % 160 + 32
+            size = 20 + (i * 10) % 30
+            
+            shape_type = (i + prompt_hash) % 4
+            color = (
+                (i * 60 + prompt_hash) % 255,
+                (i * 80 + prompt_hash) % 255,
+                (i * 100 + prompt_hash) % 255
+            )
+            
+            if shape_type == 0:
+                # Circle
+                draw.ellipse([x-size, y-size, x+size, y+size], 
+                           fill=color, outline=tuple(c//2 for c in color), width=2)
+            elif shape_type == 1:
+                # Rectangle
+                draw.rectangle([x-size, y-size, x+size, y+size], 
+                             fill=color, outline=tuple(c//2 for c in color), width=2)
+            elif shape_type == 2:
+                # Triangle
+                points = [
+                    (x, y-size),
+                    (x-size, y+size),
+                    (x+size, y+size)
+                ]
+                draw.polygon(points, fill=color, outline=tuple(c//2 for c in color), width=2)
+            else:
+                # Hexagon
+                hex_points = []
+                for angle in range(0, 360, 60):
+                    hx = x + size * math.cos(math.radians(angle))
+                    hy = y + size * math.sin(math.radians(angle))
+                    hex_points.append((hx, hy))
+                draw.polygon(hex_points, fill=color, outline=tuple(c//2 for c in color), width=2)