Update app.py

app.py

@@ -7,523 +7,430 @@ import os
 from PIL import Image
 from io import BytesIO
 from datetime import datetime
-from typing import Tuple, Dict, Optional, Any, List, Union
+from typing import Tuple, Dict, Optional, Any, List
 import logging
 
 from requests.adapters import HTTPAdapter
 from urllib3.util.retry import Retry
+from requests.exceptions import Timeout, RequestException
 
-# Setup logging
+# Configuración de Logging
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-
 class DanbooruAPI:
-    """Class to handle all Danbooru API interactions"""
-    # Load base URL from environment variable, fallback to default
     BASE_URL = os.environ.get('DANBOORU_API_URL', 'https://danbooru.donmai.us')
+    
+    HEADERS = {
+        'User-Agent': 'DanbooruTagExplorer/2.2 (Gradio; +http://github.com/yourusername)',
+        'Accept': 'application/json'
+    }
 
     def __init__(self, username: Optional[str] = None, api_key: Optional[str] = None):
-        self.username = username or os.environ.get('DANBOORU_USERNAME')
-        self.api_key = api_key or os.environ.get('DANBOORU_API_KEY')
+        self.username = username if username and username.strip() else os.environ.get('DANBOORU_USERNAME')
+        self.api_key = api_key if api_key and api_key.strip() else os.environ.get('DANBOORU_API_KEY')
         self.session = self._create_retrying_session()
 
     def _create_retrying_session(self) -> requests.Session:
         session = requests.Session()
+        session.headers.update(self.HEADERS)
         retries = Retry(
-            total=5,
-            backoff_factor=1,
-            status_forcelist=[429, 500, 502, 503, 504],
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[403, 429, 500, 502, 503, 504],
             allowed_methods={"GET"}
         )
         session.mount('https://', HTTPAdapter(max_retries=retries))
-        session.mount('http://', HTTPAdapter(max_retries=retries))
         return session
 
     def _get(self, url: str, params: Optional[Dict] = None) -> requests.Response:
         auth = (self.username, self.api_key) if self.username and self.api_key else None
-        return self.session.get(url, params=params, auth=auth)
+        return self.session.get(url, params=params, auth=auth, timeout=10)
 
     @staticmethod
     def ensure_https_url(url: str) -> str:
-        """Ensure URL starts with https"""
         if url and not (url.startswith("https") or url.startswith("http")):
             return f"https:{url}"
         return url
 
     def fetch_post_by_id(self, post_id: str) -> Tuple[dict, Optional[str]]:
-        """Fetch a post by its ID"""
         try:
             response = self._get(f'{self.BASE_URL}/posts/{post_id}.json')
             response.raise_for_status()
             return response.json(), None
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error fetching post {post_id}: {e}")
-            return {}, f"Error fetching post: {e}"
-        except json.JSONDecodeError as e:
-            logger.error(f"Error decoding JSON for post {post_id}: {e}")
-            return {}, f"Error decoding JSON: {e}"
-
-    def fetch_random_posts(self, keywords: Optional[str] = None, limit: int = 100) -> Tuple[List[dict], Optional[str]]:
-        """Fetch random posts based on keywords"""
+        except Timeout:
+            return {}, "Error: Timeout conectando a Danbooru."
+        except RequestException as e:
+            return {}, f"Error de red: {e}"
+        except json.JSONDecodeError:
+            return {}, "Error decodificando JSON."
+
+    def fetch_random_posts(self, keywords: Optional[str] = None, limit: int = 20) -> Tuple[List[dict], Optional[str]]:
         params = {'limit': limit}
         if keywords:
             params['tags'] = keywords
+            if 'order:' not in keywords:
+                 params['tags'] += ' order:random'
         else:
-            params['random'] = 'true' # True randomness when no keywords are provided
+            params['random'] = 'true' 
 
         try:
             response = self._get(f'{self.BASE_URL}/posts.json', params=params)
             response.raise_for_status()
-            return response.json(), None
-        except requests.exceptions.RequestException as e:
-            logger.error(f"Error fetching random posts with keywords '{keywords}': {e}")
-            return [], f"Error fetching random posts: {e}"
-        except json.JSONDecodeError as e:
-            logger.error(f"Error decoding JSON for random posts with keywords '{keywords}': {e}")
-            return [], f"Error decoding JSON: {e}"
-
-    @staticmethod
-    def fetch_image(image_url: str) -> Tuple[Optional[Image.Image], Optional[str]]:
-        """Fetch an image from URL"""
+            data = response.json()
+            if not isinstance(data, list):
+                return [], "Error API: La respuesta no es una lista."
+            return data, None
+        except Timeout:
+            return [], "Error: Búsqueda lenta (Timeout)."
+        except RequestException as e:
+            return [], f"Error fetching posts: {e}"
+
+    def fetch_image(self, image_url: str) -> Tuple[Optional[Image.Image], Optional[str]]:
+        """Descarga la imagen. Para preview usa timeout corto, para guardado uno más largo."""
         try:
-            # Using requests.get directly here as it's typically for public CDN URLs and doesn't need API auth/retries
-            response = requests.get(image_url, stream=True)
+            # Timeout de 15s para evitar bloqueos eternos
+            response = self.session.get(image_url, stream=True, timeout=20)
             response.raise_for_status()
-            return Image.open(BytesIO(response.content)), None
+            img = Image.open(BytesIO(response.content))
+            img.load() 
+            return img, None
         except Exception as e:
-            logger.error(f"Error loading image from {image_url}: {e}")
-            return None, f"Error loading image: {e}"
+            logger.error(f"Error cargando imagen {image_url}: {e}")
+            return None, str(e)
 
 
 class TagProcessor:
-    """Class to handle tag processing"""
-
-    DEFAULT_CENSOR_TAGS = {'mosaic_censoring', 'bar_censor', 'censored', 'artist_name', 'pixelated'}
+    DEFAULT_CENSOR_TAGS = {'mosaic_censoring', 'bar_censor', 'censored', 'artist_name', 'pixelated', 'censor'}
+    DEFAULT_BLACKLIST_TAGS = {
+        'highres', 'absurdres', 'commentary', 'translated', 'text_bubble', 
+        'speech_bubble', 'comic', 'monochrome', 'greyscale', 'bad_id', 'bad_pixiv_id'
+    }
 
     @staticmethod
-    def format_text(text: str) -> str:
-        """Format text by escaping parentheses"""
-        if not isinstance(text, str):
-            return ""
-        return re.sub(r'([()])', r'\\\1', text)
+    def format_tag(tag: str) -> str:
+        """Limpia una sola etiqueta: quita guiones bajos y escapa paréntesis"""
+        # 1. Reemplazar guión bajo por espacio
+        tag = tag.replace('_', ' ')
+        # 2. Escapar paréntesis para el prompt
+        tag = re.sub(r'([()])', r'\\\1', tag)
+        return tag
 
-    @staticmethod
-    def humanize_text(text: str) -> str:
-        """Convert underscores to spaces for human-readable output"""
-        if not isinstance(text, str):
+    @classmethod
+    def process_category(cls, raw_string: str, is_general: bool, censor: List[str], blacklist: List[str]) -> str:
+        """
+        Toma un string de tags (ej: 'tag1_a tag2_(b)'), los separa, filtra, formatea y une con comas.
+        """
+        if not raw_string or not isinstance(raw_string, str):
             return ""
-        return text.replace('_', ' ')
 
-    @staticmethod
-    def join_tags(tags: str) -> str:
-        """Join tags with commas"""
-        if not isinstance(tags, str):
-            return ""
-        # Filter out empty strings that might result from splitting or filtering
-        return ', '.join(filter(None, tags.split()))
+        tags_list = raw_string.split()
+        processed_tags = []
+        
+        banned = set(censor).union(set(blacklist))
 
-    @classmethod
-    def filter_censor_tags(cls, tags: str, censor_tags: Optional[List[str]] = None) -> str:
-        """Remove censorship-related tags"""
-        if not isinstance(tags, str):
-            return ""
-        tags_to_censor = set(censor_tags) if censor_tags else cls.DEFAULT_CENSOR_TAGS
-        return ' '.join([tag for tag in tags.split() if tag not in tags_to_censor])
+        for tag in tags_list:
+            # Filtrar si está en lista negra (solo para general tags normalmente, pero aplicamos a todo por seguridad)
+            if is_general and tag in banned:
+                continue
+            
+            # Formatear (humanizar + escapar)
+            formatted = cls.format_tag(tag)
+            processed_tags.append(formatted)
+
+        # Unir con coma y espacio
+        return ', '.join(processed_tags)
 
     @classmethod
-    def process_post_data(cls, data: dict, prompt_template: str = "{character}, {artist}, {origin}, {tags}", user_censor_tags: Optional[List[str]] = None) -> Dict[str, Any]:
-        """Process post data to extract and format tags and metadata"""
-        character = data.get('tag_string_character', "")
-        origin = data.get('tag_string_copyright', "")
-        general_tags = data.get('tag_string_general', "")
-        artist_tags = data.get('tag_string_artist', "")
-        meta_tags = data.get('tag_string_meta', "")
-
-        # Filter and format general tags using configurable censor tags
-        filtered_general_tags = cls.filter_censor_tags(general_tags, user_censor_tags)
-
-        # Format other tag categories for prompt creation
-        formatted_character = cls.format_text(character)
-        formatted_origin = cls.format_text(origin)
-        formatted_artist = cls.format_text(artist_tags)
-        formatted_meta = cls.format_text(meta_tags)
-
-        # Join tags for display and prompt
-        tags_with_commas = cls.join_tags(filtered_general_tags)
-        artist_tags_with_commas = cls.join_tags(artist_tags)
-        meta_tags_with_commas = cls.join_tags(meta_tags)
-
-        # Prepare context for prompt template
+    def process_post_data(cls, data: dict, prompt_template: str, user_censor_tags: List[str], user_blacklist_tags: List[str]) -> Dict[str, Any]:
+        # Obtener strings crudos (separados por espacios)
+        raw_char = data.get('tag_string_character', "")
+        raw_copy = data.get('tag_string_copyright', "")
+        raw_artist = data.get('tag_string_artist', "")
+        raw_meta = data.get('tag_string_meta', "")
+        raw_general = data.get('tag_string_general', "")
+
+        # Procesar cada categoría: Separa -> Limpia -> Une con comas
+        p_char = cls.process_category(raw_char, False, user_censor_tags, user_blacklist_tags)
+        p_origin = cls.process_category(raw_copy, False, user_censor_tags, user_blacklist_tags)
+        p_artist = cls.process_category(raw_artist, False, user_censor_tags, user_blacklist_tags)
+        p_meta = cls.process_category(raw_meta, False, user_censor_tags, user_blacklist_tags)
+        p_tags = cls.process_category(raw_general, True, user_censor_tags, user_blacklist_tags)
+
         prompt_context = {
-            'character': formatted_character,
-            'artist': formatted_artist,
-            'origin': formatted_origin,
-            'meta': formatted_meta,
-            'tags': tags_with_commas,
+            'character': p_char,
+            'artist': p_artist,
+            'origin': p_origin,
+            'meta': p_meta,
+            'tags': p_tags,
         }
 
-        # Create prompt using the template and available data
-        prompt = ""
+        # Generar Prompt
         try:
             prompt = prompt_template.format(**prompt_context)
-            # Remove any leading/trailing commas or spaces that might result from empty fields
-            prompt = re.sub(r'(, )+', ', ', prompt).strip(', ').strip()
-        except KeyError as e:
-            logger.warning(f"Prompt template contains invalid key: {e}. Falling back to default prompt.")
-            # Fallback prompt, similar to original but including artist
-            default_fallback_prompt = f'{formatted_character}, {formatted_artist}, {formatted_origin}, {tags_with_commas}'
-            prompt = re.sub(r'(, )+', ', ', default_fallback_prompt).strip(', ').strip()
-        except Exception as e:
-            logger.warning(f"Error formatting prompt with template '{prompt_template}': {e}. Falling back to default.")
-            default_fallback_prompt = f'{formatted_character}, {formatted_artist}, {formatted_origin}, {tags_with_commas}'
-            prompt = re.sub(r'(, )+', ', ', default_fallback_prompt).strip(', ').strip()
+            # Limpieza final de comas fantasmas generadas por campos vacíos
+            prompt = re.sub(r',\s*,', ',', prompt)      # ", ," -> ","
+            prompt = re.sub(r'\s+,', ',', prompt)       # " ,"  -> ","
+            prompt = re.sub(r'^,\s*', '', prompt)       # Inicio sucio
+            prompt = re.sub(r',\s*$', '', prompt)       # Final sucio
+            prompt = re.sub(r',\s+', ', ', prompt)      # Asegurar espacio tras coma
+            prompt = prompt.strip()
+        except Exception:
+            # Fallback simple
+            parts = [p_char, p_origin, p_artist, p_tags]
+            prompt = ', '.join([p for p in parts if p])
+
+        # URLs
+        file_url = data.get('file_url') or data.get('large_file_url')
+        preview_url = data.get('preview_file_url') or file_url # Fallback al grande si no hay pequeño
 
-
-        # Humanize for display
         return {
-            'character': cls.humanize_text(formatted_character),
-            'origin': cls.humanize_text(formatted_origin),
-            'artist': cls.humanize_text(artist_tags_with_commas),
-            'meta': cls.humanize_text(meta_tags_with_commas),
-            'tags': cls.humanize_text(tags_with_commas),
-            'prompt': cls.humanize_text(prompt),
+            'character': p_char.replace('\\', ''), # Sin escapes para display
+            'origin': p_origin.replace('\\', ''),
+            'artist': p_artist.replace('\\', ''),
+            'meta': p_meta.replace('\\', ''),
+            'tags': p_tags.replace('\\', ''),
+            'prompt': prompt,
             'rating': data.get('rating', 'unknown'),
             'score': str(data.get('score', 0)),
             'created_at': data.get('created_at', 'unknown'),
-            # Include various image URLs for the processor to pick from
-            'file_url': data.get('file_url', ''),
-            'large_file_url': data.get('large_file_url', ''),
-            'preview_file_url': data.get('preview_file_url', '')
+            'full_file_url': cls.ensure_https(data.get('large_file_url') or data.get('file_url')),
+            'preview_file_url': cls.ensure_https(preview_url)
         }
 
+    @staticmethod
+    def ensure_https(url):
+        if url and not url.startswith(('http', 'https')):
+            return f"https:{url}"
+        return url
+
 
 class FileManager:
-    """Class to handle file operations"""
+    @staticmethod
+    def get_filename(output_dir: str, prefix: str, ext: str) -> str:
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        return os.path.join(output_dir, f"{prefix}_{timestamp}.{ext}")
 
     @staticmethod
-    def save_to_file(data: Dict[str, str], output_dir: str = ".", filename_prefix: str = "danbooru_output", image_url: Optional[str] = None) -> str:
-        """Save processed data to a file"""
+    def save_data_file(data: Dict[str, str], output_dir: str, filename_prefix: str) -> str:
         try:
-            # Create directory if it doesn't exist
             os.makedirs(output_dir, exist_ok=True)
+            filename = FileManager.get_filename(output_dir, filename_prefix, "txt")
+            
+            with open(filename, "w", encoding="utf-8") as file:
+                file.write(f"--- Danbooru Data {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ---\n")
+                file.write(f"Post URL: {data.get('post_page_url', 'N/A')}\n")
+                file.write(f"Prompt: {data.get('prompt', '')}\n\n")
+                file.write(f"Tags: {data.get('tags', '')}\n")
+                file.write(f"Character: {data.get('character', '')}\n")
+            return f"📝 Texto guardado en '{filename}'"
+        except Exception as e:
+            return f"❌ Error texto: {e}"
 
-            # Generate filename with current timestamp
-            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
-            filename = os.path.join(output_dir, f"{filename_prefix}_{timestamp}.txt")
-
-            with open(filename, "a", encoding="utf-8") as file:
-                file.write(f"--- Entry from {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} ---\n")
-                if image_url:
-                    file.write(f"Image Post URL: {image_url}\n")
-                file.write(f"Character: {data.get('character', 'N/A')}\n")
-                file.write(f"Origin: {data.get('origin', 'N/A')}\n")
-                file.write(f"Artist: {data.get('artist', 'N/A')}\n")
-                file.write(f"Meta Tags: {data.get('meta', 'N/A')}\n")
-                file.write(f"General Tags: {data.get('tags', 'N/A')}\n")
-                file.write(f"Rating: {data.get('rating', 'N/A')}\n")
-                file.write(f"Score: {data.get('score', 'N/A')}\n")
-                file.write(f"Created At: {data.get('created_at', 'N/A')}\n")
-                file.write(f"Generated Prompt: {data.get('prompt', 'N/A')}\n\n")
-            return f"✅ Data saved to '{filename}'"
+    @staticmethod
+    def save_image_locally(api: DanbooruAPI, image_url: str, output_dir: str, filename_prefix: str) -> str:
+        """Descarga la imagen HD en el momento del guardado"""
+        if not image_url: return "❌ No hay URL de imagen HD para descargar."
+        
+        try:
+            os.makedirs(output_dir, exist_ok=True)
+            filename = FileManager.get_filename(output_dir, filename_prefix, "png") # O jpg según corresponda
+            
+            # Usamos la API para descargar (reutiliza sesión y headers)
+            img, err = api.fetch_image(image_url)
+            if err or not img:
+                return f"❌ Falló descarga HD: {err}"
+            
+            img.save(filename)
+            return f"🖼️ Imagen HD guardada en '{filename}'"
         except Exception as e:
-            logger.error(f"Error saving to file '{filename}': {e}")
-            return f"❌ Error saving to file: {e}"
+            return f"❌ Error guardando imagen: {e}"
 
 
 class DanbooruProcessor:
-    """Main class to handle the entire process"""
-
-    def __init__(self):
-        # API keys are loaded from environment variables in DanbooruAPI.__init__
-        self.api = DanbooruAPI()
+    def __init__(self, username: str, api_key: str):
+        self.api = DanbooruAPI(username, api_key)
         self.tag_processor = TagProcessor()
         self.file_manager = FileManager()
 
-    def process_by_id(self, image_id: str, prompt_template: str, user_censor_tags: Optional[List[str]]) -> Tuple[Dict[str, Any], Optional[str]]:
-        """Process a post by ID"""
+    def process_by_id(self, image_id: str, template: str, censor: List[str], blacklist: List[str]) -> Tuple[Dict[str, Any], Optional[str]]:
         post_data, error = self.api.fetch_post_by_id(image_id)
-        if error:
-            return {}, error
-
-        # Prioritize large_file_url for display, fallback to file_url, then preview
-        display_image_url_cdn = self.api.ensure_https_url(
-            post_data.get('large_file_url') or
-            post_data.get('file_url') or
-            post_data.get('preview_file_url', '')
-        )
-
-        post_page_url = f"{DanbooruAPI.BASE_URL}/posts/{image_id}" # Link to the Danbooru post page
+        if error: return {}, error
+        if 'id' not in post_data: return {}, "Post no encontrado."
+        return self._finalize(post_data, template, censor, blacklist)
 
-        image, img_error = (None, "No image URL found")
-        if display_image_url_cdn:
-             image, img_error = self.api.fetch_image(display_image_url_cdn)
-        else:
-            logger.warning(f"No displayable image URL found for post ID {image_id}")
-
-        # Log image fetching errors but don't halt the entire process
-        if img_error and not image:
-            logger.warning(f"Could not fetch image for post ID {image_id}: {img_error}")
-
-        processed_data = self.tag_processor.process_post_data(
-            post_data,
-            prompt_template=prompt_template,
-            user_censor_tags=user_censor_tags
-        )
+    def process_random(self, keywords: str, template: str, censor: List[str], blacklist: List[str]) -> Tuple[Dict[str, Any], Optional[str]]:
+        posts, error = self.api.fetch_random_posts(keywords)
+        if error: return {}, error
+        if not posts: return {}, "No se encontraron posts."
+
+        # Intentar buscar uno que tenga imagen válida
+        valid_posts = [p for p in posts if 'preview_file_url' in p or 'file_url' in p]
+        if not valid_posts: return {}, "Posts encontrados pero sin URLs de imagen válidas."
+
+        random_post = random.choice(valid_posts)
+        return self._finalize(random_post, template, censor, blacklist)
+
+    def _finalize(self, post_data: dict, template: str, censor: List[str], blacklist: List[str]) -> Tuple[Dict[str, Any], Optional[str]]:
+        # Procesar texto (Rápido)
+        processed_data = self.tag_processor.process_post_data(post_data, template, censor, blacklist)
+        
+        post_id = post_data.get('id')
+        post_page_url = f"{DanbooruAPI.BASE_URL}/posts/{post_id}"
+        
+        # OPTIMIZACIÓN: Usar preview para la UI (Rápido)
+        ui_image_url = processed_data.get('preview_file_url')
+        image = None
+        
+        if ui_image_url:
+            # Descargar solo la miniatura para mostrar en pantalla
+            image, err = self.api.fetch_image(ui_image_url)
+            if err: logger.warning(f"Fallo preview: {err}")
 
         return {
             **processed_data,
-            'image': image,
-            'post_page_url': post_page_url, # Link to the Danbooru post page
-            'display_image_cdn_url': display_image_url_cdn, # Direct CDN URL for the displayed image
+            'image': image, # Objeto PIL pequeño
+            'post_page_url': post_page_url,
         }, None
 
-    def process_random(self, keywords: Optional[str] = None, prompt_template: str = "{character}, {artist}, {origin}, {tags}", user_censor_tags: Optional[List[str]] = None) -> Tuple[Dict[str, Any], Optional[str]]:
-        """Process a random post based on keywords"""
-        posts, error = self.api.fetch_random_posts(keywords)
-        if error:
-            return {}, error
-
-        if not posts:
-            return {}, "No posts found with provided keywords."
-
-        random_post = random.choice(posts)
-        post_id = str(random_post.get('id', ''))
-        if not post_id:
-            return {}, "Selected random post has no ID."
-
-        # Now use the process_by_id function to get all details
-        return self.process_by_id(post_id, prompt_template, user_censor_tags)
-
-    def save_results(self, data: Dict[str, Any], output_dir: str = ".", filename_prefix: str = "danbooru_output") -> str:
-        """Save results to file"""
-        save_data = {
-            k: data.get(k, 'N/A') for k in [
-                'character', 'origin', 'artist', 'meta', 'tags', 'prompt',
-                'rating', 'score', 'created_at'
-            ]
-        }
-        # Use post_page_url for the saved record, as it's the stable link to the post
-        return self.file_manager.save_to_file(
-            save_data,
-            output_dir=output_dir,
-            filename_prefix=filename_prefix,
-            image_url=data.get('post_page_url')
-        )
+    def save_results(self, data: Dict[str, Any], out_dir: str, prefix: str, save_img_bool: bool) -> str:
+        # Guardar Texto
+        msg_text = self.file_manager.save_data_file(data, out_dir, prefix)
+        
+        msg_img = ""
+        if save_img_bool:
+            # AQUÍ descargamos la imagen GRANDE solo si el usuario quiere guardarla
+            full_url = data.get('full_file_url')
+            if full_url:
+                msg_img = self.file_manager.save_image_locally(self.api, full_url, out_dir, prefix)
+            else:
+                msg_img = "⚠️ No se encontró URL de alta calidad para descargar."
+            
+        return f"{msg_text}\n{msg_img}".strip()
 
 
 def process_danbooru(
     choice: str,
     image_id_input: str,
     keywords_input: str,
+    api_username: str,
+    api_key: str,
     prompt_template_input: str,
     censor_tags_input: str,
+    blacklist_tags_input: str,
     output_directory_input: str,
-    output_filename_prefix_input: str
-) -> Tuple[
-    Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], Optional[str], # character, origin, artist, meta, tags, prompt
-    Optional[str], Optional[str], Optional[str], # rating, score, created_at
-    Optional[str], Optional[str], # post_page_url, message
-    Optional[Image.Image]
-]:
-    """Main function to process Danbooru requests for the Gradio interface"""
-    # Parse censor tags from input string
-    user_censor_tags = [tag.strip() for tag in censor_tags_input.split(',') if tag.strip()] if censor_tags_input else None
-
-    # Initialize processor. API keys are loaded from environment variables in DanbooruAPI.__init__
-    processor = DanbooruProcessor()
-
-    # Helper for returning a consistent error state across all 12 outputs
+    output_filename_prefix_input: str,
+    save_image_toggle: bool
+):
+    def parse_csv(text):
+        return [t.strip() for t in text.split(',') if t.strip()] if text else []
+
+    user_censor = parse_csv(censor_tags_input)
+    user_blacklist = parse_csv(blacklist_tags_input)
+    
+    processor = DanbooruProcessor(api_username, api_key)
+
+    # 13 salidas
     def default_error_return(msg: str):
-        return (
-            None, None, None, None, None, None, # character, origin, artist, meta, tags, prompt (6)
-            None, None, None, # rating, score, created_at (3)
-            None, msg, # post_page_url, message (2)
-            None # image_out (1)
-        ) # Total 12
+        return (None,) * 11 + (msg, None)
 
     try:
         if choice == 'Enter Image ID':
-            if not image_id_input:
-                return default_error_return("❌ Image ID cannot be empty!")
-            try:
-                image_id = str(int(image_id_input)) # Validate it's an integer
-            except ValueError:
-                return default_error_return("❌ Image ID must be a valid number!")
-
-            result, error = processor.process_by_id(image_id, prompt_template_input, user_censor_tags)
-        elif choice == 'Find Random Image':
-            result, error = processor.process_random(keywords_input, prompt_template_input, user_censor_tags)
+            if not image_id_input: return default_error_return("❌ ID vacío")
+            result, error = processor.process_by_id(str(int(image_id_input)), prompt_template_input, user_censor, user_blacklist)
         else:
-            return default_error_return("❌ Invalid choice")
-
-        if error:
-            return default_error_return(f"❌ {error}")
-
-        # Extract results for UI display
-        character_out = result.get('character', '')
-        origin_out = result.get('origin', '')
-        artist_out = result.get('artist', '')
-        meta_out = result.get('meta', '')
-        tags_out = result.get('tags', '')
-        prompt_out = result.get('prompt', '')
-
-        rating_out = result.get('rating', '')
-        score_out = result.get('score', '')
-        created_at_out = result.get('created_at', '')
-
-        post_page_url_out = result.get('post_page_url', '')
-        display_image_cdn_url_out = result.get('display_image_cdn_url', '')
-        image_out = result.get('image')
-
-        # Save results to file
-        save_message = processor.save_results(
-            result,
-            output_dir=output_directory_input,
-            filename_prefix=output_filename_prefix_input
-        )
-        message_out = save_message
+            result, error = processor.process_random(keywords_input, prompt_template_input, user_censor, user_blacklist)
 
-    except Exception as e:
-        logger.exception("Unexpected error in process_danbooru") # Log exception details
-        return default_error_return(f"❌ Unexpected error: {e}")
+        if error: return default_error_return(f"❌ {error}")
 
-    return (
-        character_out, origin_out, artist_out, meta_out, tags_out, prompt_out,
-        rating_out, score_out, created_at_out,
-        post_page_url_out, message_out,
-        image_out
-    )
+        # Guardar (Esto puede tardar un poco más si "Guardar Imagen" está activo, pero la búsqueda ya terminó)
+        save_msg = processor.save_results(
+            result, output_directory_input, output_filename_prefix_input, save_image_toggle
+        )
 
+        return (
+            result.get('character', ''),
+            result.get('origin', ''),
+            result.get('artist', ''),
+            result.get('meta', ''),
+            result.get('tags', ''),
+            result.get('prompt', ''),
+            result.get('rating', ''),
+            result.get('score', ''),
+            result.get('created_at', ''),
+            result.get('post_page_url', ''),
+            result.get('full_file_url', ''), # Mostramos link a la full
+            save_msg,
+            result.get('image') # Preview para UI
+        )
 
-def create_interface():
-    """Creates the Gradio interface for the Danbooru Tag Explorer."""
-    # Initial values for advanced settings
-    default_prompt_template = "{character}, {artist}, {origin}, {tags}"
-    default_censor_tags_str = ", ".join(TagProcessor.DEFAULT_CENSOR_TAGS)
-    default_output_dir = "danbooru_outputs"
-    default_output_filename_prefix = "danbooru_tags"
+    except Exception as e:
+        logger.exception("Error")
+        return default_error_return(f"❌ Error Inesperado: {e}")
 
-    with gr.Blocks(theme=gr.themes.Soft(), title="Danbooru Tag Explorer") as iface:
-        gr.Markdown("""
-        # 🏷️ Danbooru Tag Explorer
 
-        Extract tags from Danbooru posts by ID or find random images with keywords.
-        Results will be saved to a text file for your reference.
-        """)
+def create_interface():
+    default_template = "{character}, {artist}, {origin}, {tags}"
+    default_censor = ", ".join(TagProcessor.DEFAULT_CENSOR_TAGS)
+    default_blacklist = ", ".join(TagProcessor.DEFAULT_BLACKLIST_TAGS)
+    
+    with gr.Blocks(theme=gr.themes.Soft(), title="Danbooru Tag Explorer V2.2") as iface:
+        gr.Markdown("# 🏷️ Danbooru Tag Explorer V2.2 (Optimized)")
 
         with gr.Row():
             with gr.Column(scale=1):
-                choice = gr.Radio(
-                    ["Enter Image ID", "Find Random Image"],
-                    label="Choose an option",
-                    value="Find Random Image"
-                )
-
+                choice = gr.Radio(["Enter Image ID", "Find Random Image"], label="Modo", value="Find Random Image")
+                
                 with gr.Group():
-                    image_id = gr.Number(
-                        label="Enter Image ID",
-                        precision=0,
-                        interactive=True,
-                        visible=False # Initially hidden as "Find Random Image" is default
-                    )
-
-                    keywords = gr.Textbox(
-                        label="Enter keywords (space-separated; use underscores for multi-word tags; leave blank for any random)",
-                        placeholder="Example: landscape blue_sky 1girl",
-                        visible=True # Initially visible
-                    )
-
-                with gr.Accordion("⚙️ Advanced Settings", open=False):
-                    prompt_template = gr.Textbox(
-                        label="Prompt Template",
-                        value=default_prompt_template,
-                        placeholder="Example: {character}, {artist}, {origin}, {tags}",
-                        info="Available placeholders: {character}, {artist}, {origin}, {meta}, {tags}"
-                    )
-                    censor_tags = gr.Textbox(
-                        label="Censor Tags (comma-separated)",
-                        value=default_censor_tags_str,
-                        placeholder="Example: mosaic_censoring, bar_censor",
-                        info="Tags to be removed from the 'General Tags' section."
-                    )
-                    output_directory = gr.Textbox(
-                        label="Output Directory",
-                        value=default_output_dir,
-                        placeholder="e.g., danbooru_outputs"
-                    )
-                    output_filename_prefix = gr.Textbox(
-                        label="Output Filename Prefix",
-                        value=default_output_filename_prefix,
-                        placeholder="e.g., danbooru_tags"
-                    )
-
-                submit_btn = gr.Button("🔍 Search", variant="primary")
+                    image_id = gr.Number(label="ID Imagen", precision=0, visible=False)
+                    keywords = gr.Textbox(label="Keywords", placeholder="Ej: 1girl blue_hair")
+
+                with gr.Accordion("🔑 Credenciales", open=False):
+                    api_user = gr.Textbox(label="Usuario", placeholder="Opcional")
+                    api_key = gr.Textbox(label="API Key", type="password", placeholder="Opcional")
+
+                with gr.Accordion("🛡️ Filtros", open=True):
+                    censor_tags = gr.Textbox(label="Censura", value=default_censor)
+                    blacklist_tags = gr.Textbox(label="Blacklist", value=default_blacklist)
+
+                with gr.Accordion("💾 Guardado", open=True):
+                    save_image_chk = gr.Checkbox(label="Descargar Imagen Original (Lento)", value=False)
+                    out_dir = gr.Textbox(label="Carpeta", value="danbooru_outputs")
+                    out_prefix = gr.Textbox(label="Prefijo", value="img")
+                    prompt_template = gr.Textbox(label="Template", value=default_template)
+
+                btn = gr.Button("🔍 Buscar", variant="primary", size="lg")
 
             with gr.Column(scale=2):
-                with gr.Tab("Results"):
+                with gr.Tab("Vista Previa"):
+                    img_display = gr.Image(label="Preview (Baja Resolución)", height=500, type="pil")
+                    status_msg = gr.Textbox(label="Log", lines=2)
+                    
+                with gr.Tab("Datos"):
+                    prompt = gr.Textbox(label="Prompt Final", show_copy_button=True, lines=3)
+                    tags = gr.Textbox(label="Tags", show_copy_button=True, lines=4)
                     with gr.Row():
-                        image_display = gr.Image(label="Image Preview", type="pil", height=400)
-
-                    with gr.Group():
-                        post_page_url_display = gr.Textbox(label="🔗 Danbooru Post URL", show_copy_button=True)
-                        display_image_cdn_url_display = gr.Textbox(label="🖼️ Displayed Image CDN URL", show_copy_button=True)
-                        character = gr.Textbox(label="👤 Character", show_copy_button=True)
-                        origin = gr.Textbox(label="🌍 Origin", show_copy_button=True)
-                        artist = gr.Textbox(label="🎨 Artist", show_copy_button=True)
-                        meta_tags = gr.Textbox(label="⚙️ Meta Tags", show_copy_button=True)
-
-                    with gr.Accordion("General Tags", open=False):
-                        tags = gr.Textbox(label="🏷️ General Tags", show_copy_button=True, lines=5)
-
-                    prompt = gr.Textbox(
-                        label="✨ Generated Prompt",
-                        show_copy_button=True,
-                        lines=3
-                    )
-
-                    with gr.Accordion("Additional Metadata", open=False):
-                        rating = gr.Textbox(label="🔞 Rating", show_copy_button=True)
-                        score = gr.Textbox(label="👍 Score", show_copy_button=True)
-                        created_at = gr.Textbox(label="🗓️ Created At", show_copy_button=True)
-
-                with gr.Tab("Status"):
-                    message = gr.Textbox(label="Status Messages")
-
-        # Logic for showing/hiding input fields based on choice
-        def update_visibility(selected_choice):
-            return [
-                gr.update(visible=(selected_choice == "Enter Image ID")),
-                gr.update(visible=(selected_choice == "Find Random Image"))
-            ]
-
-        choice.change(
-            update_visibility,
-            inputs=[choice],
-            outputs=[image_id, keywords]
-        )
+                        char = gr.Textbox(label="Personaje")
+                        origin = gr.Textbox(label="Origen")
+                    with gr.Row():
+                        artist = gr.Textbox(label="Artista")
+                        meta = gr.Textbox(label="Meta")
+                    with gr.Row():
+                        rating = gr.Textbox(label="Rating")
+                        score = gr.Textbox(label="Score")
+                        created = gr.Textbox(label="Fecha")
+                    post_url = gr.Textbox(label="Link Post", show_copy_button=True)
+                    full_url = gr.Textbox(label="Link HD", show_copy_button=True)
 
-        # Connect submit button to processing function
-        submit_btn.click(
-            process_danbooru,
-            inputs=[
-                choice, image_id, keywords,
-                prompt_template, censor_tags, output_directory, output_filename_prefix
-            ],
-            outputs=[
-                character, origin, artist, meta_tags, tags, prompt,
-                rating, score, created_at,
-                post_page_url_display, message,
-                image_display
-            ]
-        )
+        def update_vis(val):
+            return [gr.update(visible=(val == "Enter Image ID")), gr.update(visible=(val == "Find Random Image"))]
+
+        choice.change(update_vis, inputs=choice, outputs=[image_id, keywords])
 
-        # Set initial visibility when the interface loads
-        iface.load(
-            update_visibility,
-            inputs=[choice], # Use the default value of the choice radio button
-            outputs=[image_id, keywords],
-            queue=False # Not strictly necessary to queue this initial setup
+        btn.click(
+            process_danbooru,
+            inputs=[choice, image_id, keywords, api_user, api_key, prompt_template, censor_tags, blacklist_tags, out_dir, out_prefix, save_image_chk],
+            outputs=[char, origin, artist, meta, tags, prompt, rating, score, created, post_url, full_url, status_msg, img_display]
         )
 
     return iface