@danhachuel/thunderbolt 0.5.60 → 0.5.62

package/app/main.py

@@ -1332,6 +1332,9 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
             edited_style = st.selectbox("Fonte do vídeo", WIDE_STYLE_OPTIONS, index=WIDE_STYLE_OPTIONS.index(channel_video_source_value(channel.get("style_wide"))) if channel_video_source_value(channel.get("style_wide")) in WIDE_STYLE_OPTIONS else 0)
             edited_aspect = st.selectbox("Proporção do vídeo", CHANNEL_ASPECT_RATIO_OPTIONS, index=CHANNEL_ASPECT_RATIO_OPTIONS.index(str(channel.get("video_aspect_ratio") or "Landscape 16:9")) if str(channel.get("video_aspect_ratio") or "Landscape 16:9") in CHANNEL_ASPECT_RATIO_OPTIONS else 0)
             edited_niche = st.text_input("Nicho", value=str(channel.get("niche") or channel_niche_label(channel) if channel_niche_label(channel) != "SEM NICHO CONFIGURADO" else "") )
+            edited_subscribers = st.number_input("Inscritos", min_value=0, value=int(str(channel.get("subscriber_count") or 0).replace(".", "").replace(",", "")), step=1)
+            edited_videos = st.number_input("Vídeos", min_value=0, value=int(str(channel.get("video_count") or 0).replace(".", "").replace(",", "")), step=1)
+            edited_views = st.number_input("Visualizações", min_value=0, value=int(str(channel.get("view_count") or 0).replace(".", "").replace(",", "")), step=1)
         with edit_cols[1]:
             edited_blueprint = st.selectbox("Blueprint Padrão", blueprint_ids, index=blueprint_ids.index(current_blueprint) if current_blueprint in blueprint_ids else 0, format_func=lambda item: blueprint_labels.get(item, item or "Sem Blueprint padrão"))
             edited_voice = st.selectbox("Narrador/Voz Padrão", voice_options, index=voice_options.index(current_voice) if current_voice in voice_options else 0, format_func=lambda item: item or "Sem voz padrão")
@@ -1358,6 +1361,7 @@ def render_channel_edit_form(channel: dict, youtube_account_ids: list[str], yout
                 "default_voice": edited_voice.strip(), "voice": edited_voice.strip(),
                 "google_account_id": edited_account.strip(), "google_account_email": str(youtube_accounts_by_id.get(edited_account, {}).get("email", "")),
                 "description": edited_description.strip(), "automation_on": bool(edited_automation), "automation_time": edited_time.strip(),
+                "subscriber_count": int(edited_subscribers) or None, "video_count": int(edited_videos) or None, "view_count": int(edited_views) or None,
             })
             st.session_state.pop(f"edit_channel_{channel_id}", None)
             st.success("Canal actualizado.")
@@ -7281,6 +7285,9 @@ def _persist_media_cards(settings: dict[str, Any], cards: list[dict[str, Any]],
 def _fetch_media_models(card: dict[str, Any]) -> list[str]:
     """Consultar modelos do provider, incluindo o catálogo nativo Gemini."""
     provider = str(card.get("provider") or "").strip().lower()
+    if provider == "huggingface":
+        from integrations.openai_model_discovery import fetch_huggingface_text_to_image_models
+        return fetch_huggingface_text_to_image_models(str(card.get("api_key") or ""))
     if provider == "replicate":
         from integrations.openai_model_discovery import fetch_replicate_models
         return fetch_replicate_models(str(card.get("api_key") or ""), str(card.get("base_url") or ""))

package/hermes_ui/api_key_tests.py

@@ -169,6 +169,14 @@ def test_media_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
     api_style = str(source.get("api_style") or "").strip().lower()
     if provider == "nano_banana":
         return test_nano_banana_credentials(api_key, model)
+    if provider == "huggingface":
+        if not api_key:
+            return _missing("Introduza o token Hugging Face antes de testar.")
+        return _get(
+            "https://huggingface.co/api/models",
+            headers={"Authorization": f"Bearer {api_key}"},
+            params={"pipeline_tag": "text-to-image", "limit": 1},
+        )
     if not base_url:
         return _result("missing", "Complete a Base URL antes de testar.")
     if provider not in {"inferenceport", "ollama", "lmstudio"} and not api_key:

package/hermes_ui/media_generation.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 import base64
 import binascii
+import io
 import json
 import mimetypes
 import os
@@ -453,6 +454,35 @@ def generate_image_for_card(
     ensure_storage()
     destination = STORAGE / "thumbnails" / f"media-{provider}-{abs(hash((topic, prompt, variant_index))) & 0xffffffffffffffff:x}.jpg"
 
+    if provider == "huggingface":
+        model = _model(card)
+        token = _api_key(card)
+        if not model:
+            raise MediaGenerationError("Hugging Face requer a selecção de um modelo text-to-image.")
+        try:
+            image_prompt, _headline = _compose_thumbnail_prompt(
+                prompt,
+                topic=topic,
+                lettering_text=lettering_text,
+                lettering_prompt=lettering_prompt,
+            )
+            constrained_prompt = _append_generation_constraints(
+                image_prompt,
+                kind="image",
+                aspect_ratio="16:9",
+                size="1280x720 minimum",
+            )
+            from huggingface_hub import InferenceClient
+            image = InferenceClient(token=token or None, provider="hf-inference").text_to_image(
+                prompt=constrained_prompt,
+                model=model,
+            )
+            buffer = io.BytesIO()
+            image.save(buffer, format="PNG")
+            return _download_or_write(buffer.getvalue(), "", destination, card)
+        except Exception as exc:
+            raise MediaGenerationError(f"Hugging Face text-to-image falhou: {str(exc)[:240]}") from exc
+
     def request(current: dict[str, Any]) -> Any:
         return _image_request(current, prompt, topic=topic, lettering_text=lettering_text, lettering_prompt=lettering_prompt)
 

package/hermes_ui/media_providers.py

@@ -113,11 +113,11 @@ MEDIA_PROVIDER_CATALOG: tuple[MediaProviderDefinition, ...] = (
     MediaProviderDefinition(
         "huggingface",
         "Hugging Face Inference API",
-        default_base_url="https://router.huggingface.co/v1",
+        default_base_url="https://huggingface.co",
         supports_image=True,
-        supports_text=True,
+        supports_text=False,
         api_style="huggingface",
-        description="Inference Providers; a capacidade depende do modelo seleccionado.",
+        description="Hugging Face Inference API para imagens via InferenceClient com provider hf-inference; não usa endpoint OpenAI-compatible.",
     ),
     MediaProviderDefinition(
         "cloudflare_workers_ai",
@@ -230,7 +230,7 @@ def normalize_media_card(card: Any, index: int = 0) -> dict[str, Any]:
         "provider": provider,
         "api_key": str(source.get("api_key") or source.get("key") or "").strip(),
         "model": str(source.get("model") or source.get("model_name") or "").strip(),
-        "base_url": str(source.get("base_url") or "").strip() or definition.default_base_url,
+        "base_url": definition.default_base_url if provider == "huggingface" else (str(source.get("base_url") or "").strip() or definition.default_base_url),
         "enabled": bool(source.get("enabled", True)),
         "priority": max(0, int(source.get("priority", index)) if str(source.get("priority", index)).strip().lstrip("-").isdigit() else index),
         "supports_image": bool(source.get("supports_image", definition.supports_image)),

package/integrations/openai_model_discovery.py

@@ -210,6 +210,40 @@ def fetch_openai_compatible_models(
     return normalize_model_ids(payload)
 
 
+def fetch_huggingface_text_to_image_models(
+    api_key: str,
+    *,
+    timeout: float = DEFAULT_TIMEOUT_SECONDS,
+    limit: int = 2000,
+) -> list[str]:
+    """List only public Hugging Face models tagged with ``text-to-image``."""
+    token = str(api_key or "").strip()
+    headers = {"Accept": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    try:
+        response = requests.get(
+            "https://huggingface.co/api/models",
+            params={"pipeline_tag": "text-to-image", "limit": min(max(int(limit), 1), MAX_MODEL_IDS), "sort": "downloads", "direction": -1},
+            headers=headers,
+            timeout=timeout,
+        )
+    except requests.RequestException as exc:
+        raise ModelDiscoveryError(f"Não foi possível consultar o catálogo text-to-image da Hugging Face: {exc}") from exc
+    if response.status_code >= 400:
+        raise ModelDiscoveryError(f"O catálogo text-to-image da Hugging Face devolveu HTTP {response.status_code}.")
+    try:
+        payload = response.json()
+    except ValueError as exc:
+        raise ModelDiscoveryError("O catálogo Hugging Face devolveu uma resposta que não é JSON.") from exc
+    if not isinstance(payload, list):
+        raise ModelDiscoveryError("O catálogo Hugging Face não devolveu uma lista de modelos.")
+    models = sorted({str(item.get("id") or "").strip() for item in payload if isinstance(item, dict) and str(item.get("id") or "").strip()}, key=str.casefold)
+    if not models:
+        raise ModelDiscoveryError("A Hugging Face não devolveu modelos com pipeline text-to-image.")
+    return models[:MAX_MODEL_IDS]
+
+
 def fetch_replicate_models(
     api_key: str,
     base_url: str,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danhachuel/thunderbolt",
-  "version": "0.5.60",
+  "version": "0.5.62",
   "description": "Thunderbolt — interface local para operação de canais faceless e motor MoneyPrinterTurbo",
   "license": "MIT",
   "main": "scripts/cli.mjs",

package/requirements.txt

@@ -1,6 +1,7 @@
 streamlit>=1.37,<2
 requests[socks]>=2.31,<3
 Pillow>=10,<12
+huggingface_hub>=0.30,<1
 pandas>=2.0,<3
 openpyxl>=3.1,<4
 xlrd>=2.0,<3