@danhachuel/thunderbolt 0.4.33 → 0.4.34

package/app/main.py

@@ -35,6 +35,7 @@ def display_version(version: str) -> str:
 APP_VERSION_LABEL = display_version(APP_VERSION)
 
 from hermes_ui.domain import STAGES, create_batch, create_channel, create_tasks_for_batch, delete_channel, delete_task, pipeline_summary, retry_task_with_current_settings, set_channel_defaults, stop_task_by_user, transition_task, update_channel, update_channel_video
+from hermes_ui.channel_import import build_channel_template_xlsx, channel_is_duplicate, find_duplicate_channel, parse_channel_workbook, resolve_blueprint, resolve_google_account, resolve_voice
 from hermes_ui.drafts import list_drafts, save_draft
 from hermes_ui.automation_worker import load_worker_status
 from hermes_ui.pipeline_worker import load_pipeline_worker_status, recover_stale_tasks, STALE_TASK_SECONDS, WORKER_HEARTBEAT_TIMEOUT_SECONDS
@@ -1849,7 +1850,7 @@ def render_channels():
     youtube_account_labels = {"": "Sem conta Google associada"}
     youtube_account_labels.update({str(account["id"]): f"{account.get('label', 'Canais YouTube')} — {account.get('email', 'sem e-mail')}" for account in youtube_accounts})
     youtube_accounts_by_id = {str(account["id"]): account for account in youtube_accounts}
-    import_tab, batch_tab, manual_tab = render_localized_tabs(["Importar do YouTube", "Canais em lote gmail", "Cadastro manual"])
+    import_tab, spreadsheet_tab, batch_tab, manual_tab = render_localized_tabs(["Importar do YouTube", "Canais em lote Planilha", "Canais em lote gmail", "Cadastro manual"])
 
     with import_tab:
         st.caption("A pesquisa pública funciona sem API Key. A Data API é opcional e fica disponível numa opção separada para métricas oficiais.")
@@ -1943,6 +1944,142 @@ def render_channels():
         else:
             st.info("Introduza um URL, handle ou ID e clique em Buscar no YouTube. Não é necessária API Key na opção pública.")
 
+    with spreadsheet_tab:
+        st.caption("Carregue uma planilha Excel (.xlsx ou .xls). Os cabeçalhos e valores são interpretados, normalizados e associados aos cadastros existentes antes da gravação.")
+        download_col, help_col = st.columns([1.35, 2.65])
+        with download_col:
+            st.download_button(
+                "Baixar planilha modelo",
+                data=build_channel_template_xlsx(),
+                file_name="modelo_canais_youtube.xlsx",
+                mime="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+                use_container_width=True,
+                key="download_channel_spreadsheet_template",
+            )
+        with help_col:
+            st.caption("O modelo inclui as 15 colunas aceitas. Deixe campos não utilizados vazios; a Descrição será pesquisada publicamente pelo handle, URL ou nome quando estiver vazia.")
+
+        uploaded_sheet = st.file_uploader(
+            "Upload da planilha de canais",
+            type=["xlsx", "xls"],
+            key="channel_spreadsheet_upload",
+            help="Apenas a primeira aba do arquivo será importada. Linhas sem URL, nome e handle são ignoradas.",
+        )
+        if st.button("Ler e preparar planilha", type="primary", use_container_width=True, key="read_channel_spreadsheet"):
+            if uploaded_sheet is None:
+                st.error("Selecione um arquivo Excel antes de continuar.")
+            else:
+                try:
+                    spreadsheet_rows, spreadsheet_warnings = parse_channel_workbook(uploaded_sheet.getvalue(), uploaded_sheet.name)
+                    st.session_state["channel_spreadsheet_rows"] = spreadsheet_rows
+                    st.session_state["channel_spreadsheet_warnings"] = spreadsheet_warnings
+                    st.session_state.pop("channel_spreadsheet_result", None)
+                    if spreadsheet_rows:
+                        st.success(f"{len(spreadsheet_rows)} linha(s) de canal preparada(s) para revisão.")
+                    else:
+                        st.warning("A planilha não contém linhas com URL, nome ou handle de canal.")
+                except ValueError as exc:
+                    st.session_state.pop("channel_spreadsheet_rows", None)
+                    st.error(str(exc))
+
+        spreadsheet_warnings = st.session_state.get("channel_spreadsheet_warnings", [])
+        for spreadsheet_warning in spreadsheet_warnings:
+            st.warning(spreadsheet_warning)
+        spreadsheet_result = st.session_state.get("channel_spreadsheet_result")
+        if isinstance(spreadsheet_result, dict):
+            if spreadsheet_result.get("created"):
+                st.success(f"Canais cadastrados: {', '.join(spreadsheet_result['created'])}")
+            if spreadsheet_result.get("skipped"):
+                st.info(f"Já cadastrados e não duplicados: {', '.join(spreadsheet_result['skipped'])}")
+            for spreadsheet_error in spreadsheet_result.get("errors", []):
+                st.warning(spreadsheet_error)
+
+        spreadsheet_rows = st.session_state.get("channel_spreadsheet_rows", [])
+        if spreadsheet_rows:
+            blueprint_items = blueprint_catalog()
+            voice_options = voice_catalog()
+            spreadsheet_accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
+            existing_spreadsheet_channels = [channel for channel in read_json("channels.json", []) if isinstance(channel, dict)]
+            preview_rows = []
+            for row in spreadsheet_rows:
+                resolved_blueprint = resolve_blueprint(row.get("blueprint"), blueprint_items)
+                resolved_voice = resolve_voice(row.get("voice"), voice_options)
+                resolved_account, _ = resolve_google_account(row.get("google_account"), spreadsheet_accounts)
+                preview_rows.append({
+                    "Linha": row.get("_source_row", "—"),
+                    "Nome": row.get("name") or "—",
+                    "Handle": row.get("handle") or "—",
+                    "Blueprint interpretado": resolved_blueprint or "—",
+                    "Voz interpretada": resolved_voice or "—",
+                    "Idioma": language_code(row.get("language")) if row.get("language") else "—",
+                    "Descrição": "Preencher via YouTube" if not row.get("description") else "Da planilha",
+                    "Estado": "Já cadastrado" if find_duplicate_channel({"name": row.get("name"), "handle": row.get("handle"), "url": row.get("url")}, existing_spreadsheet_channels) else "Novo",
+                })
+            st.dataframe(preview_rows, use_container_width=True, hide_index=True, height=min(420, 86 + 38 * len(preview_rows)))
+            st.caption("Blueprints e vozes são resolvidos pelos catálogos atuais. Por exemplo, `finanças`, `blueprint_finanças` e `Blueprint Canal Finanças` apontam para o mesmo Blueprint quando ele existe.")
+            if st.button("Cadastrar canais da planilha", type="primary", use_container_width=True, key="import_channel_spreadsheet"):
+                created_names: list[str] = []
+                skipped_names: list[str] = []
+                spreadsheet_errors: list[str] = []
+                current_channels = list(existing_spreadsheet_channels)
+                for row in spreadsheet_rows:
+                    row_label = str(row.get("name") or row.get("handle") or row.get("url") or f"Linha {row.get('_source_row', '?')}")
+                    candidate = {"name": row.get("name", ""), "handle": row.get("handle", ""), "url": row.get("url", "")}
+                    duplicate = find_duplicate_channel(candidate, current_channels)
+                    if duplicate:
+                        skipped_names.append(f"{row_label} (linha {row.get('_source_row', '?')})")
+                        continue
+                    automation_time = str(row.get("automation_time") or "").strip()
+                    if automation_time and not valid_hhmm(automation_time):
+                        spreadsheet_errors.append(f"{row_label} (linha {row.get('_source_row', '?')}): horário inválido; a linha não foi cadastrada.")
+                        continue
+                    try:
+                        resolved_blueprint = resolve_blueprint(row.get("blueprint"), blueprint_items)
+                        resolved_voice = resolve_voice(row.get("voice"), voice_options)
+                        google_account_id, google_account_email = resolve_google_account(row.get("google_account"), spreadsheet_accounts)
+                        description = str(row.get("description") or "").strip()
+                        description_status = "da planilha"
+                        if not description:
+                            lookup_source = str(row.get("handle") or row.get("url") or row.get("name") or "").strip()
+                            if lookup_source:
+                                description_result = youtube.fetch_channel_public(lookup_source)
+                                description = str(description_result.data.get("description") or "").strip()
+                                if not description and youtube.api_key:
+                                    api_description_result = youtube.fetch_channel(lookup_source)
+                                    description = str(api_description_result.data.get("description") or "").strip()
+                                description_status = "buscada no YouTube" if description else "não encontrada"
+                        style_value = str(row.get("style_wide") or "").strip()
+                        metadata = {
+                            "handle": str(row.get("handle") or "").strip(),
+                            "description": description,
+                            "niche": str(row.get("niche") or "").strip(),
+                            "reference_channels": [item.strip() for item in re.split(r"[,|]", str(row.get("niche") or "")) if item.strip()],
+                            "language": language_code(row.get("language")) if row.get("language") else "",
+                            "style_wide": style_value,
+                            "blueprint_id": resolved_blueprint,
+                            "default_blueprint_id": resolved_blueprint,
+                            "default_voice": resolved_voice,
+                            "voice": resolved_voice,
+                            "google_account_id": google_account_id,
+                            "google_account_email": google_account_email,
+                            "automation_on": bool(row.get("automation_on")) if row.get("automation_on") is not None else False,
+                            "automation_time": automation_time,
+                            "delegated_session_id": str(row.get("delegated_session_id") or "").strip(),
+                            "active": bool(row.get("active")) if row.get("active") is not None else True,
+                            "default_video_duration_minutes": row.get("duration_minutes"),
+                            "metrics_source": "spreadsheet",
+                            "import_source": "spreadsheet",
+                            "description_source": description_status,
+                        }
+                        created = create_channel(str(row.get("name") or "").strip(), str(row.get("url") or "").strip(), metadata)
+                        current_channels.append(created)
+                        created_names.append(row_label)
+                    except Exception as exc:
+                        spreadsheet_errors.append(f"{row_label} (linha {row.get('_source_row', '?')}): {exc}")
+                st.session_state["channel_spreadsheet_result"] = {"created": created_names, "skipped": skipped_names, "errors": spreadsheet_errors}
+                st.session_state.pop("channel_spreadsheet_rows", None)
+                st.rerun()
+
     with batch_tab:
         st.caption("Esta subaba usa a conta Google/YouTube seleccionada para listar os canais que ela gere. Não lê a caixa Gmail e não usa e-mails como pesquisa pública.")
         accounts = [account for account in settings.get("youtube_batch_accounts", []) if isinstance(account, dict) and account.get("id")]
@@ -2094,6 +2231,34 @@ def render_channels():
     if not channels:
         st.info("Nenhum canal cadastrado.")
         return
+    channel_rows = [
+        {
+            "Nome": str(channel.get("name") or ""),
+            "Handle": str(channel.get("handle") or ""),
+            "URL": str(channel.get("url") or ""),
+            "Nicho": channel_niche_label(channel),
+            "Descrição": str(channel.get("description") or ""),
+            "Origem": str(channel.get("import_source") or channel.get("metrics_source") or "manual"),
+            "Activo": "Sim" if channel.get("active", True) else "Não",
+        }
+        for channel in channels
+    ]
+    st.dataframe(
+        channel_rows,
+        use_container_width=True,
+        hide_index=True,
+        height=min(360, 76 + 38 * len(channel_rows)),
+        column_config={
+            "Nome": st.column_config.TextColumn("Nome", width=180),
+            "Handle": st.column_config.TextColumn("Handle", width=150),
+            "URL": st.column_config.LinkColumn("URL", width=220),
+            "Nicho": st.column_config.TextColumn("Nicho", width=160),
+            "Descrição": st.column_config.TextColumn("Descrição", width=360),
+            "Origem": st.column_config.TextColumn("Origem", width=130),
+            "Activo": st.column_config.TextColumn("Activo", width=80),
+        },
+    )
+    st.caption("Tabela de canais cadastrados. Os cartões abaixo mantêm as ações de edição, credenciais e vídeos publicados.")
     for channel in channels:
         channel_id = str(channel["id"])
         edit_key = f"edit_channel_{channel_id}"
@@ -7335,10 +7500,16 @@ def main():
     }
     all_children = [item for items in groups.values() for item in items]
     valid_targets = {item[0] for item in top_pages + all_children}
-    current_page = aliases.get(st.session_state.get("page", "Início"), st.session_state.get("page", "Início"))
+    # Session state is reset by a browser refresh or an application update. Keep
+    # the canonical page in the URL so the open section can be restored.
+    query_page = str(st.query_params.get("page") or "").strip()
+    stored_page = query_page or str(st.session_state.get("page", "Início"))
+    current_page = aliases.get(stored_page, stored_page)
     if current_page not in valid_targets:
         current_page = "Início"
     st.session_state["page"] = current_page
+    if str(st.query_params.get("page") or "") != current_page:
+        st.query_params["page"] = current_page
     ui_language = current_ui_language()
     current_path = nav_paths.get(current_page, "/inicio")
 
@@ -7352,6 +7523,7 @@ def main():
 
     def navigate(target: str):
         st.session_state["page"] = target
+        st.query_params["page"] = target
         st.rerun()
 
     def render_nav_button(target: str, icon: str, label: str, scope: str):

package/hermes_ui/channel_import.py

@@ -0,0 +1,429 @@
+"""Helpers for importing YouTube channel registrations from spreadsheets.
+
+The spreadsheet is intentionally treated as a human-authored document rather
+than a database export: headers and values are normalised semantically, common
+Portuguese/English variants are accepted, and catalog-backed values are
+resolved to the application's canonical identifiers before persistence.
+"""
+
+from __future__ import annotations
+
+from datetime import date, datetime, time
+from difflib import SequenceMatcher
+from io import BytesIO
+import math
+import re
+import unicodedata
+from copy import copy
+from typing import Any, Iterable, Mapping, Sequence
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+import pandas as pd
+
+from .languages import language_code
+
+
+CHANNEL_TEMPLATE_COLUMNS: tuple[str, ...] = (
+    "URL canal",
+    "Nome canal",
+    "Handle canal",
+    "Narrador/ voz padrão",
+    "Idioma",
+    "Nicho",
+    "Blueprint Padrão",
+    "Estilo Wide",
+    "Activo ",
+    "Descrição",
+    "Conta Google do Documento deste Canal",
+    "Automação Ligada ",
+    "Horário diário (HH:MM)",
+    "DELEGATED_SESSION_ID",
+    "Duração Padrão Vídeos (Min)",
+)
+
+
+_FIELD_ALIASES: dict[str, tuple[str, ...]] = {
+    "url": ("url canal", "url", "link canal", "link", "youtube url", "youtube link", "channel url"),
+    "name": ("nome canal", "nome", "nome do canal", "channel name", "name"),
+    "handle": ("handle canal", "handle", "identificador canal", "youtube handle", "channel handle"),
+    "voice": ("narrador voz padrão", "narrador voz padrao", "narrador", "voz padrão", "voz padrao", "voz", "voice"),
+    "language": ("idioma", "lingua", "language", "lang"),
+    "niche": ("nicho", "niche", "tema", "categoria", "category"),
+    "blueprint": ("blueprint padrão", "blueprint padrao", "blueprint", "modelo blueprint", "blueprint name"),
+    "style_wide": ("estilo wide", "estilo", "wide style", "video style", "style"),
+    "active": ("activo", "ativo", "activa", "ativa", "active", "enabled"),
+    "description": ("descrição", "descricao", "description", "sobre o canal", "channel description"),
+    "google_account": (
+        "conta google do documento deste canal",
+        "conta google",
+        "google account",
+        "gmail",
+        "email google",
+        "e mail google",
+    ),
+    "automation_on": ("automação ligada", "automacao ligada", "automação", "automacao", "automation", "automation on"),
+    "automation_time": ("horário diário hh mm", "horario diario hh mm", "horário diário", "horario diario", "automation time", "schedule"),
+    "delegated_session_id": ("delegated session id", "delegated_session_id", "delegated session", "session id"),
+    "duration_minutes": (
+        "duração padrão vídeos min",
+        "duracao padrao videos min",
+        "duração padrão vídeos",
+        "duracao padrao videos",
+        "duração vídeos min",
+        "video duration minutes",
+        "duration minutes",
+    ),
+}
+
+
+def _strip_accents(value: Any) -> str:
+    text = str(value or "")
+    return "".join(char for char in unicodedata.normalize("NFKD", text) if not unicodedata.combining(char))
+
+
+def _text(value: Any) -> str:
+    if value is None:
+        return ""
+    try:
+        if bool(pd.isna(value)):
+            return ""
+    except (TypeError, ValueError):
+        pass
+    if isinstance(value, float) and math.isnan(value):
+        return ""
+    return str(value).strip()
+
+
+def _key(value: Any) -> str:
+    return re.sub(r"[^a-z0-9]+", "", _strip_accents(value).casefold())
+
+
+def _semantic_key(value: Any) -> str:
+    """Return a comparison key that ignores catalog naming conventions.
+
+    For example, ``finanças``, ``blueprint_finanças`` and
+    ``Blueprint Canal Finanças`` all become ``financas``.
+    """
+    compact = _key(value)
+    for generic in ("blueprints", "blueprint", "canal", "channel", "padrao", "default", "modelo"):
+        compact = compact.replace(generic, "")
+    return compact
+
+
+def _header_match(header: Any) -> str | None:
+    normalized = _key(header)
+    if not normalized:
+        return None
+    aliases: dict[str, str] = {}
+    for field, values in _FIELD_ALIASES.items():
+        for alias in values:
+            aliases[_key(alias)] = field
+    if normalized in aliases:
+        return aliases[normalized]
+    # Spreadsheet authors often add a unit or a harmless prefix/suffix.
+    ranked: list[tuple[float, str]] = []
+    for alias, field in aliases.items():
+        if alias and (alias in normalized or normalized in alias):
+            ranked.append((min(len(alias), len(normalized)) / max(len(alias), len(normalized)), field))
+    if ranked:
+        return max(ranked)[1]
+    return None
+
+
+def parse_channel_workbook(file_content: bytes, filename: str = "channels.xlsx") -> tuple[list[dict[str, Any]], list[str]]:
+    """Read the first worksheet and return normalised source rows.
+
+    Blank rows are discarded. Unknown columns are ignored and reported so a
+    user can still import a workbook containing extra operational columns.
+    """
+    suffix = str(filename or "").lower().rsplit(".", 1)[-1] if "." in str(filename) else "xlsx"
+    engine = "xlrd" if suffix == "xls" else "openpyxl"
+    try:
+        frame = pd.read_excel(BytesIO(file_content), sheet_name=0, dtype=object, engine=engine)
+    except ImportError as exc:
+        raise ValueError("Para ficheiros .xls, instale o suporte xlrd; para .xlsx, use o formato Excel moderno (.xlsx).") from exc
+    except Exception as exc:
+        raise ValueError(f"Não foi possível ler a planilha Excel: {exc}") from exc
+
+    warnings: list[str] = []
+    field_by_column: dict[Any, str] = {}
+    for column in frame.columns:
+        field = _header_match(column)
+        if field is None:
+            warnings.append(f"Coluna ignorada: {str(column).strip() or '(sem nome)'}")
+            continue
+        if field in field_by_column.values():
+            warnings.append(f"Coluna duplicada ignorada para {field}: {str(column).strip()}")
+            continue
+        field_by_column[column] = field
+
+    if not any(field in field_by_column.values() for field in ("url", "name", "handle")):
+        expected = ", ".join(("URL canal", "Nome canal", "Handle canal"))
+        raise ValueError(f"A planilha precisa de pelo menos uma coluna de identificação: {expected}.")
+
+    rows: list[dict[str, Any]] = []
+    for source_index, (_, record) in enumerate(frame.iterrows(), start=2):
+        if all(not _text(value) for value in record.tolist()):
+            continue
+        row: dict[str, Any] = {field: record[column] for column, field in field_by_column.items()}
+        row["_source_row"] = source_index
+        normalized = normalize_channel_row(row)
+        # The public template contains pre-filled defaults such as False and
+        # 10 minutes. They do not make a row a channel registration.
+        if not any(normalized.get(field) for field in ("url", "name", "handle")):
+            continue
+        rows.append(normalized)
+    return rows, warnings
+
+
+def normalize_handle(value: Any) -> str:
+    raw = _text(value)
+    if not raw:
+        return ""
+    match = re.search(r"(?:youtube\.com/)?@([A-Za-z0-9_.-]+)", raw, flags=re.IGNORECASE)
+    if match:
+        return f"@{match.group(1)}"
+    return raw if raw.startswith("@") else f"@{raw}"
+
+
+def _normalise_boolean(value: Any) -> bool | None:
+    if isinstance(value, bool):
+        return value
+    raw = _strip_accents(_text(value)).casefold()
+    if not raw:
+        return None
+    if raw in {"1", "true", "t", "yes", "y", "sim", "s", "ativo", "activa", "ativa", "ligado", "ligada", "on", "x"}:
+        return True
+    if raw in {"0", "false", "f", "no", "n", "nao", "inativo", "inactiva", "inativa", "desligado", "desligada", "off"}:
+        return False
+    if raw.endswith(".0") and raw[:-2] in {"0", "1"}:
+        return raw[:-2] == "1"
+    return None
+
+
+def _normalise_time(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, datetime):
+        return value.strftime("%H:%M")
+    if isinstance(value, time):
+        return value.strftime("%H:%M")
+    raw = _text(value)
+    if not raw:
+        return ""
+    match = re.search(r"\b([01]?\d|2[0-3])\s*[:hH]\s*([0-5]\d)\b", raw)
+    if match:
+        return f"{int(match.group(1)):02d}:{int(match.group(2)):02d}"
+    return raw
+
+
+def _normalise_duration(value: Any) -> float | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return float(value.hour * 60 + value.minute) or None
+    if isinstance(value, time):
+        return float(value.hour * 60 + value.minute) or None
+    raw = _text(value)
+    if not raw:
+        return None
+    match = re.search(r"(\d+(?:[.,]\d+)?)\s*(?:min|m|minutes?)?", raw, flags=re.IGNORECASE)
+    if match:
+        try:
+            parsed = float(match.group(1).replace(",", "."))
+            return parsed if parsed > 0 else None
+        except ValueError:
+            return None
+    return None
+
+
+def _normalise_style(value: Any) -> str:
+    raw = _strip_accents(_text(value)).casefold()
+    if not raw:
+        return ""
+    if any(token in raw for token in ("musica", "music", "audio only", "so audio")):
+        return "music"
+    if any(token in raw for token in ("full", "ia", "ai", "gerado", "artificial")):
+        return "full_ia"
+    if any(token in raw for token in ("pexels", "pixabay", "stock", "banco", "material")):
+        return "pexels"
+    return _text(value)
+
+
+def normalize_channel_row(row: Mapping[str, Any]) -> dict[str, Any]:
+    """Convert raw spreadsheet values into the application's field vocabulary."""
+    normalized: dict[str, Any] = {
+        "url": _text(row.get("url")),
+        "name": _text(row.get("name")),
+        "handle": normalize_handle(row.get("handle")),
+        "voice": _text(row.get("voice")),
+        "language": _text(row.get("language")),
+        "niche": _text(row.get("niche")),
+        "blueprint": _text(row.get("blueprint")),
+        "style_wide": _normalise_style(row.get("style_wide")),
+        "active": _normalise_boolean(row.get("active")),
+        "description": _text(row.get("description")),
+        "google_account": _text(row.get("google_account")),
+        "automation_on": _normalise_boolean(row.get("automation_on")),
+        "automation_time": _normalise_time(row.get("automation_time")),
+        "delegated_session_id": _text(row.get("delegated_session_id")),
+        "duration_minutes": _normalise_duration(row.get("duration_minutes")),
+    }
+    if "_source_row" in row:
+        normalized["_source_row"] = row["_source_row"]
+    return normalized
+
+
+def resolve_blueprint(value: Any, catalog: Sequence[tuple[str, str]]) -> str:
+    """Resolve a human label or filename-like value to a Blueprint id."""
+    raw = _text(value)
+    if not raw:
+        return ""
+    raw_key = _key(raw)
+    raw_semantic = _semantic_key(raw)
+    candidates = [(str(identifier), str(label)) for identifier, label in catalog if str(identifier).strip()]
+    for identifier, label in candidates:
+        if raw_key in {_key(identifier), _key(label)}:
+            return identifier
+    if raw_semantic:
+        semantic_matches = [(identifier, label) for identifier, label in candidates if raw_semantic in {_semantic_key(identifier), _semantic_key(label)}]
+        if len(semantic_matches) == 1:
+            return semantic_matches[0][0]
+        if semantic_matches:
+            return max(semantic_matches, key=lambda item: SequenceMatcher(None, raw_semantic, _semantic_key(item[1])).ratio())[0]
+    scored: list[tuple[float, str]] = []
+    for identifier, label in candidates:
+        score = max(SequenceMatcher(None, raw_key, _key(identifier)).ratio(), SequenceMatcher(None, raw_key, _key(label)).ratio())
+        if score >= 0.72:
+            scored.append((score, identifier))
+    if scored:
+        return max(scored)[1]
+    return raw
+
+
+def resolve_voice(value: Any, catalog: Iterable[str]) -> str:
+    raw = _text(value)
+    if not raw:
+        return ""
+    options = [str(item) for item in catalog if str(item).strip()]
+    raw_key = _key(raw)
+    for option in options:
+        option_key = _key(option)
+        if raw_key == option_key or raw_key in option_key or option_key in raw_key:
+            return option
+    scored = [(SequenceMatcher(None, raw_key, _key(option)).ratio(), option) for option in options]
+    best = max(scored, default=(0.0, ""))
+    return best[1] if best[0] >= 0.72 else raw
+
+
+def resolve_google_account(value: Any, accounts: Iterable[Mapping[str, Any]]) -> tuple[str, str]:
+    """Resolve an email, id or display label to ``(id, email)``."""
+    raw = _text(value)
+    if not raw:
+        return "", ""
+    raw_key = _key(raw)
+    candidates: list[tuple[str, str, str]] = []
+    for account in accounts:
+        identifier = _text(account.get("id"))
+        if not identifier:
+            continue
+        email = _text(account.get("email"))
+        label = _text(account.get("label"))
+        candidates.append((identifier, email, label))
+        if raw_key in {_key(identifier), _key(email), _key(label)}:
+            return identifier, email
+    scored = []
+    for identifier, email, label in candidates:
+        score = max(SequenceMatcher(None, raw_key, _key(email)).ratio(), SequenceMatcher(None, raw_key, _key(label)).ratio())
+        scored.append((score, identifier, email))
+    best = max(scored, default=(0.0, "", ""))
+    return (best[1], best[2]) if best[0] >= 0.78 else ("", raw)
+
+
+def _canonical_url(value: Any) -> str:
+    raw = _text(value)
+    if not raw:
+        return ""
+    if not re.match(r"^https?://", raw, flags=re.IGNORECASE):
+        raw = f"https://{raw}"
+    try:
+        parsed = urlsplit(raw)
+        query = [(key, val) for key, val in parse_qsl(parsed.query, keep_blank_values=True) if key.casefold() not in {"utm_source", "utm_medium", "utm_campaign", "si"}]
+        return urlunsplit((parsed.scheme.casefold(), parsed.netloc.casefold(), parsed.path.rstrip("/").casefold(), urlencode(query), ""))
+    except ValueError:
+        return _key(raw)
+
+
+def _identity_text(value: Any) -> str:
+    return _key(value)
+
+
+def channel_is_duplicate(candidate: Mapping[str, Any], existing: Mapping[str, Any]) -> bool:
+    """Return true when two records identify the same channel.
+
+    Handle, canonical URL and YouTube id are strong identifiers. A name is a
+    fallback only when one side has no handle, avoiding false positives for
+    two channels that happen to share a common name.
+    """
+    candidate_id = _key(candidate.get("youtube_channel_id") or candidate.get("youtube_id"))
+    existing_id = _key(existing.get("youtube_channel_id") or existing.get("youtube_id"))
+    if candidate_id and existing_id and candidate_id == existing_id:
+        return True
+    candidate_handle = _identity_text(candidate.get("handle"))
+    existing_handle = _identity_text(existing.get("handle"))
+    if candidate_handle and existing_handle and candidate_handle == existing_handle:
+        return True
+    candidate_url = _canonical_url(candidate.get("url"))
+    existing_url = _canonical_url(existing.get("url"))
+    if candidate_url and existing_url and candidate_url == existing_url:
+        return True
+    candidate_name = _identity_text(candidate.get("name"))
+    existing_name = _identity_text(existing.get("name"))
+    return bool(candidate_name and existing_name and candidate_name == existing_name and not (candidate_handle and existing_handle and candidate_handle != existing_handle))
+
+
+def find_duplicate_channel(candidate: Mapping[str, Any], channels: Iterable[Mapping[str, Any]]) -> Mapping[str, Any] | None:
+    return next((channel for channel in channels if isinstance(channel, Mapping) and channel_is_duplicate(candidate, channel)), None)
+
+
+def build_channel_template_xlsx() -> bytes:
+    """Build a fresh, formatted workbook using the public template columns."""
+    frame = pd.DataFrame([{column: "" for column in CHANNEL_TEMPLATE_COLUMNS} for _ in range(20)])
+    frame["Automação Ligada "] = False
+    frame["Activo "] = True
+    frame["Horário diário (HH:MM)"] = "00:00"
+    frame["Duração Padrão Vídeos (Min)"] = 10
+    output = BytesIO()
+    with pd.ExcelWriter(output, engine="openpyxl") as writer:
+        frame.to_excel(writer, index=False, sheet_name="Canais YouTube")
+        worksheet = writer.book["Canais YouTube"]
+        worksheet.freeze_panes = "A2"
+        worksheet.auto_filter.ref = worksheet.dimensions
+        for cell in worksheet[1]:
+            font = copy(cell.font)
+            font.bold = True
+            font.color = "FFFFFF"
+            cell.font = font
+            fill = copy(cell.fill)
+            fill.fill_type = "solid"
+            fill.fgColor = "1F4E78"
+            cell.fill = fill
+        widths = {column: max(18, min(42, len(column) + 4)) for column in CHANNEL_TEMPLATE_COLUMNS}
+        widths["Descrição"] = 48
+        widths["URL canal"] = 38
+        for index, column in enumerate(CHANNEL_TEMPLATE_COLUMNS, start=1):
+            worksheet.column_dimensions[chr(64 + index) if index <= 26 else worksheet.cell(1, index).column_letter].width = widths[column]
+    return output.getvalue()
+
+
+__all__ = [
+    "CHANNEL_TEMPLATE_COLUMNS",
+    "build_channel_template_xlsx",
+    "channel_is_duplicate",
+    "find_duplicate_channel",
+    "normalize_channel_row",
+    "parse_channel_workbook",
+    "resolve_blueprint",
+    "resolve_google_account",
+    "resolve_voice",
+]

package/hermes_ui/domain.py

@@ -35,6 +35,7 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "url": url.strip(),
         "handle": "",
         "description": "",
+        "description_source": "",
         "niche": "",
         "reference_channels": [],
         "thumbnail_url": "",
@@ -56,6 +57,8 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "automation_time": "00:00",
         "active": True,
         "daily_limit": 1,
+        "default_video_duration_minutes": None,
+        "import_source": "manual",
         "backlog_total": 0,
         "created_at": now(),
         "updated_at": now(),

package/package.json

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

package/requirements.txt

@@ -2,6 +2,8 @@ streamlit>=1.37,<2
 requests[socks]>=2.31,<3
 Pillow>=10,<12
 pandas>=2.0,<3
+openpyxl>=3.1,<4
+xlrd>=2.0,<3
 imageio-ffmpeg>=0.6,<1
 toml>=0.10,<1
 google-auth>=2.29,<3