@danhachuel/thunderbolt 0.3.98 → 0.3.100

package/app/influencers_ui.py

@@ -6,6 +6,7 @@ import base64
 import hashlib
 import io
 import json
+import mimetypes
 from pathlib import Path
 from typing import Any, Mapping
 
@@ -294,24 +295,38 @@ def _render_content_history(repository: Any, influencer_id: str = "") -> None:
     if not records:
         return
     st.subheader("Conteúdos gerados")
-    rows = []
     for item in records:
-        rows.append({
-            "Tipo": str(item.get("content_type") or "").capitalize(),
-            "Estado": CONTENT_STATES.get(str(item.get("state") or ""), str(item.get("state") or "—")),
-            "Provider": f"{item.get('provider') or '—'} · {item.get('model') or '—'}",
-            "Plataforma": item.get("platform") or "—",
-            "Artefacto": item.get("artifact_path") or item.get("error") or "—",
-            "Criado": item.get("created_at") or "—",
-        })
-    st.dataframe(rows, use_container_width=True, hide_index=True)
-    latest = records[0]
-    artifact = Path(str(latest.get("artifact_path") or ""))
-    if artifact.is_file() and latest.get("state") == "completed":
-        if latest.get("content_type") == "image":
-            st.image(str(artifact), caption="Última imagem gerada", use_container_width=True)
-        elif latest.get("content_type") == "video":
-            st.video(str(artifact))
+        content_id = str(item.get("id") or "content")
+        content_type = str(item.get("content_type") or "").strip().lower()
+        artifact = Path(str(item.get("artifact_path") or ""))
+        state = str(item.get("state") or "")
+        type_label = "Imagem" if content_type == "image" else "Vídeo" if content_type == "video" else "Conteúdo"
+        with st.container(border=True):
+            preview_col, detail_col = st.columns([1.25, 2.75])
+            with preview_col:
+                if artifact.is_file() and content_type == "image":
+                    st.image(str(artifact), caption=f"{type_label} gerada", use_container_width=True)
+                elif artifact.is_file() and content_type == "video":
+                    st.video(str(artifact))
+                else:
+                    st.caption("Artefacto indisponível")
+            with detail_col:
+                st.write(f"**{type_label} · {CONTENT_STATES.get(state, state or '—')}**")
+                st.caption(f"Provider: {item.get('provider') or '—'} · {item.get('model') or '—'}")
+                st.caption(f"Plataforma: {item.get('platform') or '—'} · Criado: {item.get('created_at') or '—'}")
+                if item.get("error"):
+                    st.error(str(item.get("error") or "")[:700])
+                if artifact.is_file() and state == "completed" and content_type in {"image", "video"}:
+                    fallback_mime = "image/png" if content_type == "image" else "video/mp4"
+                    mime = mimetypes.guess_type(artifact.name)[0] or fallback_mime
+                    st.download_button(
+                        f"Descarregar {type_label.casefold()}",
+                        data=artifact.read_bytes(),
+                        file_name=artifact.name,
+                        mime=mime,
+                        key=f"influencer_content_download_{content_type}_{content_id}",
+                        use_container_width=True,
+                    )
 
 
 def _store_uploaded_file(uploaded: Any, folder: str) -> Path:

package/app/main.py

@@ -2726,6 +2726,11 @@ def render_music_creation():
             st.error(str(exc))
 
 
+def render_custom_music_voices() -> None:
+    """Reserved view for future reusable custom music-voice blueprints."""
+    st.title("Vozes Personalizadas, Funcionará como um Blueprint")
+
+
 def render_scripts():
     st.title("Roteiros")
     st.caption("Produza e guarde roteiros de vídeos ou letras de músicas a partir dos Blueprints do Thunderbolt.")
@@ -3844,7 +3849,7 @@ def render_music_backlog() -> None:
                     music_file = Path(music_path)
                     st.success("Música pronta; pode continuar para o destino configurado.")
                     st.download_button(
-                        "Descarregar música pronta",
+                        "Descarregar música",
                         data=music_file.read_bytes(),
                         file_name=music_file.name,
                         mime="audio/mpeg",
@@ -3921,6 +3926,14 @@ def render_thumbnails():
                 image_path = record.get("image_path")
                 if image_path and image_path.is_file():
                     st.image(str(image_path), use_container_width=True)
+                    st.download_button(
+                        "Descarregar thumbnail",
+                        data=image_path.read_bytes(),
+                        file_name=image_path.name,
+                        mime="image/jpeg" if image_path.suffix.lower() in {".jpg", ".jpeg"} else "image/png",
+                        key=f"thumbnail_download_{task_id}_{record['variant_index']}",
+                        use_container_width=True,
+                    )
                 else:
                     st.markdown("### Sem imagem")
                     st.caption("Imagem ainda não gerada")
@@ -6242,6 +6255,21 @@ def render_settings():
                         saved_lyria_model = str(settings.get("lyria_model") or lyria_models[0])
                         lyria_model = st.selectbox("Modelo Google Lyria", lyria_models, index=lyria_models.index(saved_lyria_model) if saved_lyria_model in lyria_models else 0, key="settings_lyria_model")
 
+                        def save_google_lyria() -> None:
+                            settings.update({"lyria_api_key": lyria_api_key.strip(), "lyria_model": lyria_model})
+                            write_json("settings.json", settings)
+
+                        if st.form_submit_button("Guardar Google Lyria", type="primary", use_container_width=True, key="save_google_lyria"):
+                            save_google_lyria()
+                            st.success("Google Lyria guardado.")
+                        _render_api_test_control(
+                            settings,
+                            "voice:google_lyria",
+                            lambda: test_voice_provider("google_lyria", {"lyria_api_key": lyria_api_key, "lyria_model": lyria_model}),
+                            widget_key="api_test_voice_google_lyria",
+                            persist_callback=save_google_lyria,
+                        )
+
                 with st.expander("Publicação através do Upload-Post", expanded=False):
                     upload_post_enabled = st.checkbox("Activar Upload-Post", bool(settings.get("upload_post_enabled", False)))
                     upload_post_api_key = text_setting("Upload-Post API key", "upload_post_api_key", secret=True)
@@ -6960,6 +6988,7 @@ def main():
     music_items = [
         ("Criação de Músicas", ":material/music_note:", "Criação de Músicas"),
         ("Music Backlog", ":material/queue_music:", "Music Backlog"),
+        ("Vozes Personalizadas, Funcionará como um Blueprint", ":material/record_voice_over:", "Vozes Personalizadas, Funcionará como um Blueprint"),
         ("Upload Música", ":material/library_music:", "Upload Música"),
     ]
     models_ai_items = [
@@ -7083,6 +7112,7 @@ def main():
         "Backlog Vídeos": render_videos,
         "Criação de Músicas": render_music_creation,
         "Music Backlog": render_music_backlog,
+        "Vozes Personalizadas, Funcionará como um Blueprint": render_custom_music_voices,
         "Upload Música": render_music_upload,
         "Roteiros": render_scripts,
         "Thumbnails": render_thumbnails,

package/hermes_ui/api_key_tests.py

@@ -128,6 +128,20 @@ def test_nano_banana_credentials(api_key: str, model: str) -> dict[str, Any]:
     )
 
 
+def test_google_lyria_credentials(api_key: str, model: str) -> dict[str, Any]:
+    """Validate access to the selected Lyria model without requesting audio generation."""
+    api_key = str(api_key or "").strip()
+    model = str(model or "").strip()
+    if not api_key:
+        return _missing("Introduza a Google Lyria API key antes de testar.")
+    if not model:
+        return _result("missing", "Seleccione o modelo Google Lyria antes de testar.")
+    return _get(
+        f"https://generativelanguage.googleapis.com/v1beta/models/{quote(model.removeprefix('models/'), safe='')}",
+        headers={"x-goog-api-key": api_key},
+    )
+
+
 def test_media_provider_card(card: Mapping[str, Any]) -> dict[str, Any]:
     """Run a bounded, non-generative check for an image/video provider card."""
     source = dict(card) if isinstance(card, Mapping) else {}
@@ -318,6 +332,8 @@ def test_voice_provider(provider: str, settings: dict[str, Any]) -> dict[str, An
         return test_openai_compatible_voice_credentials("Sonilo", settings.get("sonilo_api_key", ""), settings.get("sonilo_base_url", ""))
     if provider == "suno":
         return test_suno_credentials(settings.get("suno_api_key", ""), settings.get("suno_api_base_url", ""), settings.get("suno_api_endpoint", ""))
+    if provider == "google_lyria":
+        return test_google_lyria_credentials(settings.get("lyria_api_key", ""), settings.get("lyria_model", ""))
     return _unsupported("Este provider de voz não tem diagnóstico remoto configurado.")
 
 
@@ -325,6 +341,7 @@ __all__ = [
     "test_apify_credentials",
     "test_azure_speech_credentials",
     "test_elevenlabs_credentials",
+    "test_google_lyria_credentials",
     "test_innertube_api_key",
     "test_kaggle_credentials",
     "test_influencer_database",

package/package.json

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