@danhachuel/thunderbolt 0.6.28 → 0.6.30

package/app/social_networks_ui.py

@@ -45,7 +45,11 @@ def _metric_input(value: Any) -> int | None:
 def _render_instagram_bio(value: Any) -> None:
     bio = normalize_instagram_bio(value)
     if bio:
-        st.markdown(bio.replace("\n", "  \n"))
+        st.text(bio)
+
+
+def _profile_bio(profile: Mapping[str, Any]) -> str:
+    return normalize_instagram_bio(profile.get("bio")) or normalize_instagram_bio(profile.get("bio_raw"))
 
 
 def _language_index(value: Any) -> int:
@@ -99,7 +103,6 @@ def _render_instagram_posts(profile: Mapping[str, Any]) -> None:
     profile_id = _clean(profile.get("id"))
     state_key = _instagram_posts_key(profile_id)
     posts = st.session_state.get(state_key, [])
-    source = _clean(profile.get("url")) or _clean(profile.get("handle"))
     with st.expander("Últimos posts do Instagram", expanded=False):
         action_cols = st.columns(3)
         with action_cols[0]:
@@ -110,13 +113,14 @@ def _render_instagram_posts(profile: Mapping[str, Any]) -> None:
             download_clicked = bool(posts) and st.download_button("Baixar todos", data=_instagram_posts_archive(posts), file_name=f"instagram-{profile_id}-posts.zip", mime="application/zip", key=f"download_instagram_posts_{profile_id}", use_container_width=True)
         if load_clicked or refresh_clicked:
             target = max(10, len(posts)) if refresh_clicked else 10
-            result = fetch_public_instagram_posts(source, limit=target)
-            if result.ok:
-                posts = result.data.get("posts", [])
+            posts_ok, posts_message, loaded_posts = _load_instagram_posts(profile, limit=target)
+            if posts_ok:
+                posts = loaded_posts
                 st.session_state[state_key] = posts
                 st.success(f"{len(posts)} posts carregados.")
+                st.rerun()
             else:
-                st.warning(result.message)
+                st.warning(posts_message)
         posts = st.session_state.get(state_key, posts)
         if not posts:
             st.info("Clique em Carregar últimos 10 para consultar os posts públicos desta conta.")
@@ -133,11 +137,11 @@ def _render_instagram_posts(profile: Mapping[str, Any]) -> None:
                     if _clean(post.get("caption")):
                         st.caption(post["caption"])
         if st.button("Mostrar + 10", key=f"more_instagram_posts_{profile_id}", use_container_width=True):
-            result = fetch_public_instagram_posts(source, limit=len(posts) + 10)
-            if result.ok:
-                st.session_state[state_key] = result.data.get("posts", posts)
+            posts_ok, posts_message, loaded_posts = _load_instagram_posts(profile, limit=len(posts) + 10)
+            if posts_ok:
+                st.session_state[state_key] = loaded_posts
                 st.rerun()
-            st.warning(result.message)
+            st.warning(posts_message)
 
 
 def _api_card_defaults(kind: str) -> tuple[str, list[str], Callable[[Mapping[str, Any]], dict[str, Any]]]:
@@ -291,6 +295,7 @@ def _characters(settings: Mapping[str, Any]) -> tuple[list[dict[str, Any]], Any
 def _save_public_profile(data: Mapping[str, Any], *, country: str, language: str, character_id: str = "") -> dict[str, Any]:
     name = _clean(data.get("name")) or _clean(data.get("username")) or "Conta Instagram"
     url = _clean(data.get("url"))
+    selected_country = _clean(country) if _clean(country) in COUNTRY_OPTIONS else ""
     metadata = {
         **dict(data),
         "platform": "instagram",
@@ -298,8 +303,9 @@ def _save_public_profile(data: Mapping[str, Any], *, country: str, language: str
         "name": name,
         "url": url,
         "handle": _clean(data.get("handle")),
-        "bio": normalize_instagram_bio(data.get("bio")),
-        "country": country.strip(),
+        "bio": _profile_bio(data),
+        "bio_raw": _clean(data.get("bio_raw")),
+        "country": selected_country,
         "language": language.strip(),
         "post_count": data.get("post_count"),
         "subscriber_count": data.get("subscriber_count"),
@@ -313,12 +319,27 @@ def _save_public_profile(data: Mapping[str, Any], *, country: str, language: str
 
 def _merge_instagram_refresh(existing: Mapping[str, Any], refreshed: Mapping[str, Any]) -> dict[str, Any]:
     merged = dict(refreshed)
-    for field in ("subscriber_count", "following_count", "post_count", "bio", "avatar_url"):
+    for field in ("subscriber_count", "following_count", "post_count", "bio", "bio_raw", "avatar_url"):
         if merged.get(field) in (None, "") and existing.get(field) not in (None, ""):
             merged[field] = existing[field]
     return merged
 
 
+def _refresh_instagram_profile(profile: Mapping[str, Any]) -> tuple[bool, str, dict[str, Any]]:
+    source = _clean(profile.get("url")) or _clean(profile.get("handle"))
+    result = fetch_public_instagram_profile(source)
+    if not result.ok:
+        return False, result.message, {}
+    return True, result.message, _merge_instagram_refresh(profile, result.data)
+
+
+def _load_instagram_posts(profile: Mapping[str, Any], limit: int = 10) -> tuple[bool, str, list[dict[str, Any]]]:
+    source = _clean(profile.get("url")) or _clean(profile.get("handle"))
+    result = fetch_public_instagram_posts(source, limit=limit)
+    posts = result.data.get("posts", []) if isinstance(result.data, dict) else []
+    return result.ok, result.message, posts
+
+
 def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, Any]], settings: Mapping[str, Any]) -> None:
     profile_id = _clean(profile.get("id"))
     edit_key = f"edit_instagram_profile_{profile_id}"
@@ -332,7 +353,7 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
         with header_cols[1]:
             st.write(f"**{_clean(profile.get('name')) or 'Sem nome'}**")
             st.caption(f"{_clean(profile.get('handle')) or _clean(profile.get('url')) or 'sem handler'}")
-            _render_instagram_bio(profile.get("bio"))
+            _render_instagram_bio(_profile_bio(profile))
             st.caption(f"{_clean(profile.get('country')) or 'País não definido'} · {_clean(profile.get('language')) or 'Idioma não definido'}")
         with header_cols[2]:
             st.metric("posts", _metric(profile.get("post_count")))
@@ -344,13 +365,17 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
             refresh_col, edit_col = st.columns(2)
             with refresh_col:
                 if st.button("↻", help="Actualizar posts, seguidores e seguindo", key=f"refresh_instagram_{profile_id}"):
-                    result = fetch_public_instagram_profile(_clean(profile.get("url")) or _clean(profile.get("handle")))
-                    if result.ok:
-                        refreshed = _merge_instagram_refresh(profile, result.data)
+                    refreshed_ok, refreshed_message, refreshed = _refresh_instagram_profile(profile)
+                    if refreshed_ok:
+                        posts_key = _instagram_posts_key(profile_id)
+                        current_posts = st.session_state.get(posts_key, [])
+                        posts_ok, _, refreshed_posts = _load_instagram_posts(refreshed, limit=max(10, len(current_posts)))
+                        if posts_ok:
+                            st.session_state[posts_key] = refreshed_posts
                         update_channel(profile_id, {**refreshed, "platform": "instagram", "country": profile.get("country", ""), "language": profile.get("language", ""), "character_id": profile.get("character_id", "")})
                         st.success("Métricas Instagram actualizadas.")
                         st.rerun()
-                    st.warning(result.message)
+                    st.warning(refreshed_message)
             with edit_col:
                 if st.button("Editar", key=f"edit_instagram_button_{profile_id}", use_container_width=True):
                     st.session_state[edit_key] = True
@@ -382,7 +407,7 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
                 with edit_cols[0]:
                     name = st.text_input("Nome", value=_clean(profile.get("name")), key=f"instagram_edit_name_{profile_id}")
                     handle = st.text_input("handler", value=_clean(profile.get("handle")), key=f"instagram_edit_handle_{profile_id}")
-                    bio = st.text_area("Bio", value=normalize_instagram_bio(profile.get("bio")), key=f"instagram_edit_bio_{profile_id}")
+                    bio = st.text_area("Bio", value=_profile_bio(profile), key=f"instagram_edit_bio_{profile_id}")
                     country = st.selectbox("País", _country_options(), index=_country_index(profile.get("country")), format_func=_country_label, key=f"instagram_edit_country_{profile_id}")
                     language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=_language_index(profile.get("language")), format_func=language_label, key=f"instagram_edit_language_{profile_id}")
                 with edit_cols[1]:
@@ -391,7 +416,7 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
                     following = st.number_input("seguindo", min_value=0, value=_metric_input(profile.get("following_count")), placeholder="Não encontrado", key=f"instagram_edit_following_{profile_id}")
                 save_edit = st.form_submit_button("Guardar alterações", type="primary", use_container_width=True)
             if save_edit:
-                update_channel(profile_id, {"name": name.strip(), "handle": handle.strip(), "bio": normalize_instagram_bio(bio), "country": country.strip(), "language": language, "post_count": _metric_input(posts), "subscriber_count": _metric_input(followers), "following_count": _metric_input(following)})
+                update_channel(profile_id, {"name": name.strip(), "handle": handle.strip(), "bio": normalize_instagram_bio(bio), "bio_raw": bio, "country": country.strip(), "language": language, "post_count": _metric_input(posts), "subscriber_count": _metric_input(followers), "following_count": _metric_input(following)})
                 st.session_state.pop(edit_key, None)
                 st.success("Conta Instagram actualizada.")
                 st.rerun()
@@ -451,7 +476,7 @@ def render_social_networks(settings: dict[str, Any]) -> None:
                 with preview_cols[1]:
                     st.write(f"**{_clean(data.get('name')) or _clean(data.get('username'))}**")
                     st.caption(_clean(data.get("handle")))
-                    _render_instagram_bio(data.get("bio"))
+                    _render_instagram_bio(_profile_bio(data))
                 with preview_cols[2]:
                     st.metric("posts", _metric(data.get("post_count")))
                 with preview_cols[3]:
@@ -462,7 +487,7 @@ def render_social_networks(settings: dict[str, Any]) -> None:
                     form_cols = st.columns(2)
                     with form_cols[0]:
                         name = st.text_input("Nome", value=_clean(data.get("name")), key="social_instagram_result_name")
-                        bio = st.text_area("Bio", value=normalize_instagram_bio(data.get("bio")), key="social_instagram_result_bio")
+                        bio = st.text_area("Bio", value=_profile_bio(data), key="social_instagram_result_bio")
                         country = st.selectbox("País", _country_options(), index=_country_index(data.get("country")), format_func=_country_label, key="social_instagram_result_country")
                         language = st.selectbox("Idioma", list(LANGUAGE_CODES), index=_language_index(data.get("language")), format_func=language_label, key="social_instagram_result_language")
                     with form_cols[1]:
@@ -475,7 +500,7 @@ def render_social_networks(settings: dict[str, Any]) -> None:
                     save_profile = st.form_submit_button("Cadastrar conta Instagram", type="primary", use_container_width=True)
                 if save_profile:
                     profile_data = dict(data)
-                    profile_data.update({"name": name, "bio": normalize_instagram_bio(bio), "post_count": _metric_input(posts), "subscriber_count": _metric_input(followers), "following_count": _metric_input(following)})
+                    profile_data.update({"name": name, "bio": normalize_instagram_bio(bio), "bio_raw": bio, "post_count": _metric_input(posts), "subscriber_count": _metric_input(followers), "following_count": _metric_input(following)})
                     _save_public_profile(profile_data, country=country, language=language, character_id=selected_character)
                     st.success("Conta Instagram cadastrada em Redes Sociais.")
                     for key in ("social_instagram_result", "social_instagram_ok", "social_instagram_message"):

package/hermes_ui/domain.py

@@ -37,6 +37,7 @@ def create_channel(name: str, url: str = "", metadata: dict[str, Any] | None = N
         "social_network": "YouTube",
         "handle": "",
         "bio": "",
+        "bio_raw": "",
         "description": "",
         "description_source": "",
         "niche": "",

package/integrations/instagram_public.py

@@ -25,7 +25,13 @@ def normalize_instagram_bio(value: Any) -> str:
     bio = str(value or '').strip()
     if not bio:
         return ''
-    if re.search(r'\b(?:followers|following|seguidores|seguindo|posts|publicações)\b', bio, flags=re.IGNORECASE) and re.search(r'\d', bio):
+    metric_words = r'followers|following|seguidores|seguindo|posts|publicações|publications'
+    metric_hits = re.findall(
+        rf'(?:\d[\d.,]*\s*(?:{metric_words})\b|\b(?:{metric_words})\s*\d[\d.,]*)',
+        bio,
+        flags=re.IGNORECASE,
+    )
+    if len(metric_hits) >= 2:
         return ''
     return bio
 
@@ -148,11 +154,13 @@ def _profile_data_from_api(user: Mapping[str, Any], reference: Mapping[str, str]
     followers = followers if followers is not None else _structured_metric_from_json(json.dumps(user), 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
     following = following if following is not None else _structured_metric_from_json(json.dumps(user), 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
     media = ((user.get('edge_owner_to_timeline_media') or {}).get('count') if isinstance(user.get('edge_owner_to_timeline_media'), dict) else None)
+    biography = str(user.get('biography') or '').strip()
     return {
         'id': f"instagram_{reference['username']}",
         **reference,
         'name': str(user.get('full_name') or user.get('username') or reference['username']).strip(),
-        'bio': normalize_instagram_bio(user.get('biography')),
+        'bio': normalize_instagram_bio(biography),
+        'bio_raw': biography,
         'avatar_url': str(user.get('profile_pic_url_hd') or user.get('profile_pic_url') or '').strip(),
         'subscriber_count': followers,
         'following_count': following,
@@ -214,7 +222,7 @@ def fetch_public_instagram_profile(source: str) -> IntegrationResult:
     followers = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:followers|seguidores)',)) or _structured_metric(response.text, 'edge_followed_by', 'followers', 'follower_count') or _structured_metric_from_json(response.text, 'edge_followed_by', 'followers', 'follower_count', 'followerCount')
     following = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:following|seguindo)',)) or _structured_metric(response.text, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount') or _structured_metric_from_json(response.text, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
     posts = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:posts|publicações|publications)',)) or _structured_metric(response.text, 'edge_owner_to_timeline_media', 'posts', 'post_count')
-    data = {'id': f"instagram_{reference['username']}", **reference, 'name': title.split('(')[0].strip() or reference['username'], 'bio': normalize_instagram_bio(description), 'avatar_url': avatar_url, 'subscriber_count': followers, 'following_count': following, 'post_count': posts, 'public_lookup': True, 'metrics_source': 'instagram_public_page', 'last_public_lookup_at': datetime.now(timezone.utc).isoformat()}
+    data = {'id': f"instagram_{reference['username']}", **reference, 'name': title.split('(')[0].strip() or reference['username'], 'bio': normalize_instagram_bio(description), 'bio_raw': description, 'avatar_url': avatar_url, 'subscriber_count': followers, 'following_count': following, 'post_count': posts, 'public_lookup': True, 'metrics_source': 'instagram_public_page', 'last_public_lookup_at': datetime.now(timezone.utc).isoformat()}
     return IntegrationResult(True, 'Perfil Instagram encontrado publicamente.', data)
 
 

package/package.json

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