@danhachuel/thunderbolt 0.6.18 → 0.6.20

package/app/social_networks_ui.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
+import io
 import uuid
+import zipfile
 from typing import Any, Callable, Mapping
 
+import requests
 import streamlit as st
 
 from hermes_ui.domain import create_channel, update_channel
 from hermes_ui.influencers import InfluencerBackendError, STANDALONE_CONTENT_INFLUENCER_ID, get_repository
 from hermes_ui.storage import read_json, write_json
 from hermes_ui.languages import LANGUAGE_CODES, language_code, language_label
-from integrations.instagram_public import fetch_public_instagram_profile
+from integrations.instagram_public import fetch_public_instagram_posts, fetch_public_instagram_profile
 from integrations.meta_social import test_facebook_pages_api_card, test_instagram_api_card
 
 
@@ -26,11 +29,92 @@ def _metric(value: Any) -> str:
         return _clean(value) or "—"
 
 
+def _profile_metric(profile: Mapping[str, Any], *keys: str) -> Any:
+    for key in keys:
+        value = profile.get(key)
+        if value not in (None, ""):
+            return value
+    return None
+
+
 def _language_index(value: Any) -> int:
     code = language_code(value)
     return list(LANGUAGE_CODES).index(code) if code in LANGUAGE_CODES else list(LANGUAGE_CODES).index("pt")
 
 
+def _instagram_posts_key(profile_id: str) -> str:
+    return f"instagram_posts_{profile_id}"
+
+
+def _instagram_posts_archive(posts: list[dict[str, Any]]) -> bytes:
+    archive = io.BytesIO()
+    with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED) as bundle:
+        manifest: list[str] = []
+        for index, post in enumerate(posts, start=1):
+            url = _clean(post.get("image_url"))
+            if url:
+                try:
+                    response = requests.get(url, timeout=15)
+                    response.raise_for_status()
+                    extension = ".jpg"
+                    content_type = response.headers.get("content-type", "")
+                    if "png" in content_type:
+                        extension = ".png"
+                    elif "webp" in content_type:
+                        extension = ".webp"
+                    bundle.writestr(f"post-{index:02d}{extension}", response.content)
+                except requests.RequestException:
+                    pass
+            manifest.append(f"{index}. {_clean(post.get('url'))}\n{_clean(post.get('caption'))}\n")
+        bundle.writestr("posts.txt", "\n".join(manifest))
+    return archive.getvalue()
+
+
+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]:
+            load_clicked = st.button("Carregar últimos 10", key=f"load_instagram_posts_{profile_id}", use_container_width=True)
+        with action_cols[1]:
+            refresh_clicked = st.button("Actualizar tudo", key=f"refresh_instagram_posts_{profile_id}", use_container_width=True)
+        with action_cols[2]:
+            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", [])
+                st.session_state[state_key] = posts
+                st.success(f"{len(posts)} posts carregados.")
+            else:
+                st.warning(result.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.")
+            return
+        for post in posts:
+            with st.container(border=True):
+                post_cols = st.columns([1, 3])
+                with post_cols[0]:
+                    if _clean(post.get("image_url")):
+                        st.image(post["image_url"], use_container_width=True)
+                with post_cols[1]:
+                    if _clean(post.get("url")):
+                        st.link_button("Abrir post", post["url"])
+                    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)
+                st.rerun()
+            st.warning(result.message)
+
+
 def _api_card_defaults(kind: str) -> tuple[str, list[str], Callable[[Mapping[str, Any]], dict[str, Any]]]:
     if kind == "instagram":
         return "instagram_api_cards", ["id", "label", "account_id", "access_token"], test_instagram_api_card
@@ -221,16 +305,20 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
         with header_cols[2]:
             st.metric("posts", _metric(profile.get("post_count")))
         with header_cols[3]:
-            st.metric("Seguidores", _metric(profile.get("subscriber_count")))
+            st.metric("Seguidores", _metric(_profile_metric(profile, "subscriber_count", "followers_count", "follower_count")))
         with header_cols[4]:
-            st.metric("seguindo", _metric(profile.get("following_count")))
+            st.metric("seguindo", _metric(_profile_metric(profile, "following_count", "following", "follows")))
         with header_cols[5]:
             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:
-                        update_channel(profile_id, {**result.data, "platform": "instagram", "country": profile.get("country", ""), "language": profile.get("language", ""), "character_id": profile.get("character_id", "")})
+                        refreshed = dict(result.data)
+                        for field in ("subscriber_count", "following_count", "post_count", "bio", "avatar_url"):
+                            if refreshed.get(field) in (None, "") and profile.get(field) not in (None, ""):
+                                refreshed[field] = profile[field]
+                        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)
@@ -279,6 +367,7 @@ def _render_instagram_card(profile: dict[str, Any], characters: list[dict[str, A
             update_channel(profile_id, {"character_id": selected_character})
             st.success("Personagem associado à conta Instagram.")
             st.rerun()
+        _render_instagram_posts(profile)
 
 
 def render_social_networks(settings: dict[str, Any]) -> None:

package/integrations/instagram_public.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import re
+import json
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from html import unescape
@@ -66,6 +67,24 @@ def _structured_metric(document: str, *keys: str) -> int | None:
     return None
 
 
+def _structured_metric_from_json(document: str, *keys: str) -> int | None:
+    wanted = {key.casefold() for key in keys}
+    for parsed in _embedded_json_documents(document):
+        for node in _walk_json(parsed):
+            if not isinstance(node, dict):
+                continue
+            for key, value in node.items():
+                if str(key).casefold() not in wanted:
+                    continue
+                if isinstance(value, dict):
+                    value = value.get('count') or value.get('value')
+                try:
+                    return int(value)
+                except (TypeError, ValueError):
+                    continue
+    return None
+
+
 def fetch_public_instagram_profile(source: str) -> IntegrationResult:
     try:
         reference = normalize_instagram_reference(source)
@@ -91,11 +110,95 @@ def fetch_public_instagram_profile(source: str) -> IntegrationResult:
                 continue
         return None
 
-    followers = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:followers|seguidores)',)) or _structured_metric(response.text, 'edge_followed_by', 'followers', 'follower_count')
-    following = metric((r'([\d,.]+)\s*(?:mil\s+)?(?:following|seguindo)',)) or _structured_metric(response.text, 'edge_follow', 'follows', 'following', 'following_count', 'followingCount')
+    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': 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)
 
 
-__all__ = ['IntegrationResult', 'fetch_public_instagram_profile', 'normalize_instagram_reference']
+def _walk_json(value: Any):
+    if isinstance(value, dict):
+        yield value
+        for child in value.values():
+            yield from _walk_json(child)
+    elif isinstance(value, list):
+        for child in value:
+            yield from _walk_json(child)
+
+
+def _embedded_json_documents(document: str) -> list[Any]:
+    decoder = json.JSONDecoder()
+    documents: list[Any] = []
+    for script in re.findall(r'<script[^>]*>(.*?)</script>', document, flags=re.IGNORECASE | re.DOTALL):
+        candidate = script.strip()
+        if not candidate:
+            continue
+        for start in [0] + [match.start() for match in re.finditer(r'[\[{]', candidate)][:20]:
+            try:
+                parsed, _ = decoder.raw_decode(candidate[start:])
+            except (json.JSONDecodeError, TypeError):
+                continue
+            documents.append(parsed)
+            break
+    return documents
+
+
+def _post_from_node(node: dict[str, Any]) -> dict[str, Any] | None:
+    shortcode = str(node.get('shortcode') or node.get('code') or '').strip()
+    media_id = str(node.get('id') or '').strip()
+    image_url = str(node.get('display_url') or node.get('thumbnail_src') or node.get('image') or '').strip()
+    if not shortcode and not media_id:
+        return None
+    if not image_url and not node.get('is_video'):
+        return None
+    caption_value = node.get('caption') or node.get('title') or ''
+    if isinstance(caption_value, dict):
+        caption_value = caption_value.get('text') or ''
+    edges = node.get('edge_media_to_caption')
+    if isinstance(edges, dict):
+        edge_list = edges.get('edges') or []
+        if edge_list and isinstance(edge_list[0], dict):
+            caption_value = ((edge_list[0].get('node') or {}).get('text') or caption_value)
+    url = str(node.get('permalink') or node.get('url') or '').strip()
+    if not url and shortcode:
+        url = f'https://www.instagram.com/p/{shortcode}/'
+    return {
+        'id': media_id or shortcode,
+        'shortcode': shortcode,
+        'url': url,
+        'image_url': image_url,
+        'caption': str(caption_value or '').strip(),
+        'published_at': node.get('taken_at_timestamp') or node.get('taken_at') or '',
+        'is_video': bool(node.get('is_video') or node.get('video_url')),
+    }
+
+
+def fetch_public_instagram_posts(source: str, limit: int = 10) -> IntegrationResult:
+    try:
+        reference = normalize_instagram_reference(source)
+    except ValueError as exc:
+        return IntegrationResult(False, str(exc), {})
+    try:
+        response = requests.get(reference['url'], headers={'User-Agent': 'Mozilla/5.0', 'Accept-Language': 'pt-BR,pt;q=0.9,en;q=0.8'}, timeout=15)
+    except requests.RequestException as exc:
+        return IntegrationResult(False, f'Não foi possível consultar os posts públicos do Instagram: {exc}', reference)
+    if response.status_code >= 400:
+        return IntegrationResult(False, f'O Instagram devolveu HTTP {response.status_code} ao consultar os posts.', reference | {'status_code': response.status_code})
+    posts: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    for document in _embedded_json_documents(response.text):
+        for node in _walk_json(document):
+            post = _post_from_node(node)
+            if not post or post['id'] in seen:
+                continue
+            seen.add(post['id'])
+            posts.append(post)
+            if len(posts) >= max(1, int(limit)):
+                break
+        if len(posts) >= max(1, int(limit)):
+            break
+    return IntegrationResult(bool(posts), 'Posts públicos encontrados.' if posts else 'Não foi possível encontrar posts públicos nesta página do Instagram.', reference | {'posts': posts[:max(1, int(limit))]})
+
+
+__all__ = ['IntegrationResult', 'fetch_public_instagram_posts', 'fetch_public_instagram_profile', 'normalize_instagram_reference']

package/package.json

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