new file: configs/frame_templates.yaml

new file: image_processor/analyzer.py
new file: image_processor/framer.py

configs/frame_templates.yaml

@@ -0,0 +1,18 @@
+styles:
+  baroque:
+    prompt: "Ornate gold leaf frame with floral motifs, intricate carvings, classical Baroque style"
+    colors: ["#FFD700", "#FFFFFF", "#704214"]
+    mask_size: 760
+    elements: ["curves", "scrollwork", "acanthus leaves"]
+    
+  minimalista:
+    prompt: "Slim matte black metal frame with clean lines, modern minimalist design"
+    colors: ["#000000", "#E0E0E0"]
+    mask_size: 900
+    elements: ["straight edges", "sharp corners", "flat profile"]
+    
+  abstracto:
+    prompt: "Geometric asymmetric frame with bold color blocks, contemporary art style"
+    colors: ["#FF0000", "#00FF00", "#0000FF"]
+    mask_size: 800
+    elements: ["triangles", "circles", "irregular shapes"]

image_processor/analyzer.py

@@ -0,0 +1,94 @@
+from transformers import pipeline
+import torch
+from PIL import Image
+import numpy as np
+import logging
+
+class ImageAnalyzer:
+    def __init__(self, device="cuda" if torch.cuda.is_available() else "cpu"):
+        self.device = device
+        self.logger = logging.getLogger(__name__)
+        self.models = self._load_models()
+        
+    def _load_models(self):
+        try:
+            return {
+                'captioning': pipeline(
+                    "image-to-text",
+                    model="Salesforce/blip2-opt-2.7b",
+                    device=self.device,
+                    torch_dtype=torch.float16 if 'cuda' in self.device else torch.float32
+                ),
+                'art_analysis': pipeline(
+                    "text-generation",
+                    model="ArtGAN/art-critique-generator",
+                    device=self.device
+                ),
+                'color_detector': pipeline(
+                    "image-classification",
+                    model="google/color-detector",
+                    device=self.device
+                ),
+                'style_classifier': pipeline(
+                    "image-classification",
+                    model="dima806/art_painting_style_detection",
+                    device=self.device
+                )
+            }
+        except Exception as e:
+            self.logger.error(f"Error loading models: {str(e)}")
+            raise
+
+    def analyze_image(self, image):
+        try:
+            if isinstance(image, (str, bytes)):
+                image = Image.open(image)
+            
+            results = {}
+            
+            # Captioning
+            caption = self.models['captioning'](
+                image,
+                max_new_tokens=100,
+                generate_kwargs={"do_sample": False}
+            )
+            results.update(self._parse_caption(caption))
+            
+            # Color detection
+            results['colors'] = self._get_colors(image)
+            
+            # Style classification
+            style = self.models['style_classifier'](image)[0]
+            results['style'] = style['label']
+            results['style_confidence'] = style['score']
+            
+            # Art analysis
+            art_prompt = f"Analyze this {results['style']} artwork: {results['description']}"
+            results['art_commentary'] = self.models['art_analysis'](
+                art_prompt,
+                max_new_tokens=200
+            )[0]['generated_text']
+            
+            return results
+            
+        except Exception as e:
+            self.logger.error(f"Analysis failed: {str(e)}")
+            return None
+
+    def _parse_caption(self, caption_output):
+        full_text = caption_output[0]['generated_text']
+        parts = full_text.split('.', 1)
+        return {
+            'title': parts[0].strip(),
+            'description': parts[1].strip() if len(parts) > 1 else full_text
+        }
+        
+    def _get_colors(self, image):
+        colors = self.models['color_detector'](
+            image.resize((256, 256)),
+            top_k=5
+        )
+        return [{
+            'hex': c['label'],
+            'score': round(float(c['score']), 3)
+        } for c in colors]

image_processor/framer.py

@@ -0,0 +1,92 @@
+import openai
+import time
+import logging
+from tenacity import retry, wait_exponential, stop_after_attempt
+from PIL import Image
+import requests
+from io import BytesIO
+import yaml
+
+class FrameGenerator:
+    def __init__(self, api_key, config_path='configs/frame_templates.yaml'):
+        openai.api_key = api_key
+        self.logger = logging.getLogger(__name__)
+        self.templates = self._load_templates(config_path)
+        self.rate_limit = 5  # Llamadas por minuto
+        self.last_call = 0
+        
+    def _load_templates(self, config_path):
+        try:
+            with open(config_path) as f:
+                return yaml.safe_load(f)['styles']
+        except Exception as e:
+            self.logger.error(f"Error loading templates: {str(e)}")
+            return {}
+            
+    @retry(
+        wait=wait_exponential(multiplier=1, min=4, max=60),
+        stop=stop_after_attempt(3),
+        reraise=True
+    )
+    def generate_frame(self, image_url, metadata):
+        self._throttle_requests()
+        style = metadata.get('style', 'minimalista')
+        
+        template = self.templates.get(style, self.templates['minimalista'])
+        prompt = self._build_prompt(template, metadata)
+        
+        try:
+            response = openai.images.generate(
+                model="dall-e-3",
+                prompt=prompt,
+                size="1024x1024",
+                quality="hd",
+                n=1,
+                response_format="url"
+            )
+            
+            return self._composite_frame(
+                image_url,
+                response.data[0].url,
+                template['mask_size']
+            )
+            
+        except openai.RateLimitError:
+            self.logger.warning("Rate limit exceeded, retrying...")
+            time.sleep(60)
+            raise
+        except Exception as e:
+            self.logger.error(f"Generation failed: {str(e)}")
+            return None
+            
+    def _build_prompt(self, template, metadata):
+        color_str = ", ".join(metadata['colors'][:3])
+        return (
+            f"High-quality frame for {metadata['style']} painting, "
+            f"main colors: {color_str}. {template['prompt']} "
+            "No text, no signatures, pure decorative frame."
+        )
+        
+    def _throttle_requests(self):
+        elapsed = time.time() - self.last_call
+        if elapsed < 60 / self.rate_limit:
+            time.sleep(60 / self.rate_limit - elapsed)
+        self.last_call = time.time()
+        
+    def _composite_frame(self, original_url, frame_url, mask_size=800):
+        try:
+            original = Image.open(requests.get(original_url, stream=True).raw)
+            frame = Image.open(requests.get(frame_url, stream=True).raw)
+            
+            original = original.resize((mask_size, mask_size))
+            position = ((frame.width - original.width) // 2,
+                       (frame.height - original.height) // 2)
+            
+            composite = frame.copy()
+            composite.paste(original, position)
+            
+            return composite
+            
+        except Exception as e:
+            self.logger.error(f"Compositing failed: {str(e)}")
+            return None