Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,593 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import asyncio
+import nest_asyncio
+import re
+import requests
+import urllib.parse
+import hashlib
+import base64
+import secrets
+import streamlit.components.v1 as components
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+# Применяем nest_asyncio для работы с asyncio в Streamlit
+nest_asyncio.apply()
+
+# ----------- Настройки Telegram -----------
+TELEGRAM_API_ID = 23646321
+TELEGRAM_API_HASH = "102edf31d404cb72d17ee4831d4e8c7b"
+TELEGRAM_STRING_SESSION = "1ApWapzMBu3AR6vZZynrQwc59LD9XDRzbMtXVii-kfgNPeguoA2KOwyFqhsi1X_zDAsBh1DGvmVv46DmtZqk0KCd0jg9XXeS8T05E51D3Al5Ps8NNOF7fMWnpli2ROM2lou-t_8KpYbPoYnNXBAO2SzYkEhvyqQPSD7xGTWVkCLAVWm_s8Lqi-SCpXeOi341K5CR9nUCzaDkBmD3eG8SfqUp6GVO2QksGDZt3YMftWpXDwxsjuFPeeExoIawVD0Kxpjp20V3nS26SlR1-tm9lvOs9ATI_6QWPcCScT3UR5FikvrudyHNE55ZLpwbt3TRGuDMHv936DBtdHwGIQaNWSUf_5lEhIb0="
+
+# ----------- Настройки ВКонтакте -----------
+VK_CLIENT_ID = 53202706
+VK_CLIENT_SECRET = "piaMXHEDj0afa4QObJCD"
+VK_API_VERSION = "5.131"
+REDIRECT_URI = "https://huggingface.co/spaces/PRAnalytics/PR_Tool"
+
+# Инициализация токенов в session_state
+if "VK_ACCESS_TOKEN" not in st.session_state:
+    st.session_state["VK_ACCESS_TOKEN"] = ""
+if "VK_REFRESH_TOKEN" not in st.session_state:
+    st.session_state["VK_REFRESH_TOKEN"] = ""
+if "VK_DEVICE_ID" not in st.session_state:
+    st.session_state["VK_DEVICE_ID"] = ""
+
+# Функции для генерации code_verifier и code_challenge
+def generate_code_verifier(length=128):
+    return secrets.token_urlsafe(length)[:length]
+
+def generate_code_challenge(code_verifier):
+    hashed = hashlib.sha256(code_verifier.encode('utf-8')).digest()
+    return base64.urlsafe_b64encode(hashed).decode('utf-8').rstrip('=')
+
+# Функция для авторизации через VK ID
+def vk_auth():
+    if 'code_verifier' not in st.session_state:
+        st.session_state.code_verifier = generate_code_verifier()
+    
+    # Проверяем наличие токена сразу после перезагрузки
+    if st.session_state.get("VK_ACCESS_TOKEN"):
+        return  # Прерываем авторизацию, если токен уже есть
+    
+    # Шаг 2: Извлечение параметров из URL
+    query_params = st.experimental_get_query_params()
+    user_code = query_params.get("code", [None])[0]
+    user_device_id = query_params.get("device_id", [None])[0]
+    user_state = query_params.get("state", [None])[0]
+    
+    if user_code and user_state:
+        with st.expander("Технические подробности", expanded=False):
+            st.write("Автоматически извлечены параметры из URL:")
+            st.write(f"code: {user_code}")
+            st.write(f"device_id: {user_device_id}")
+            st.write(f"state: {user_state}")
+
+            # Используем code_verifier из параметра state
+            code_verifier = user_state
+
+            url = "https://id.vk.com/oauth2/auth"
+            data = {
+                "grant_type": "authorization_code",
+                "client_id": VK_CLIENT_ID,
+                "client_secret": VK_CLIENT_SECRET,
+                "redirect_uri": REDIRECT_URI,
+                "code": user_code,
+                "code_verifier": code_verifier
+            }
+            if user_device_id:
+                data["device_id"] = user_device_id
+
+            st.write("Отправляем запрос на:", url)
+            st.write("Параметры запроса:", data)
+
+            # Отправка запроса на обмен кода на токены
+            resp = requests.post(url, data=data)
+            st.write("Status code:", resp.status_code)
+            st.write("Response text:", resp.text)
+
+            try:
+                tokens = resp.json()
+                st.write("Ответ (JSON):")
+                st.json(tokens)
+
+                # Сохраняем токены
+                st.session_state["VK_ACCESS_TOKEN"] = tokens["access_token"]
+                st.session_state["VK_REFRESH_TOKEN"] = tokens["refresh_token"]
+                st.session_state["VK_DEVICE_ID"] = user_device_id
+                st.success("Токены успешно получены и сохранены!")
+                
+                # Закрываем технические подробности
+                st.experimental_set_query_params()
+                
+                # Немедленный переход к парсеру без перезагрузки
+                st.rerun()
+            except Exception as e:
+                st.error(f"Ошибка: {e}")
+        return  # Важно: прерываем выполнение после обработки кода
+    
+    # Если дошли сюда, показываем кнопку авторизации
+    st.markdown("### Сначала пройдём авторизацию")
+    code_challenge = generate_code_challenge(st.session_state.code_verifier)
+    auth_params = {
+        "client_id": VK_CLIENT_ID,
+        "redirect_uri": REDIRECT_URI,
+        "response_type": "code",
+        "scope": "wall",
+        "state": st.session_state.code_verifier,
+        "code_challenge": code_challenge,
+        "code_challenge_method": "S256",
+        "response_mode": "query"
+    }
+    auth_url = "https://id.vk.com/authorize?" + urllib.parse.urlencode(auth_params, safe="-._~")
+    st.markdown(
+        f"""
+        <a href="{auth_url}" style="
+            display: inline-block;
+            background-color: #4a76a8;
+            color: white;
+            text-decoration: none;
+            padding: 10px 20px;
+            border-radius: 4px;
+            font-family: -apple-system,BlinkMacSystemFont,Roboto,Helvetica Neue,sans-serif;
+            font-weight: 500;
+            font-size: 16px;
+            margin: 10px 0;
+            text-align: center;
+        ">
+            Авторизоваться через VK ID
+        </a>
+        """, 
+        unsafe_allow_html=True
+    )
+
+# Функция для обновления токена через refresh_token
+def refresh_vk_token() -> bool:
+    st.write("Пытаемся обновить токен...")
+
+    current_refresh = st.session_state["VK_REFRESH_TOKEN"]
+    device_id = st.session_state.get("VK_DEVICE_ID", "")
+
+    if not current_refresh or not VK_CLIENT_ID or not VK_CLIENT_SECRET or not device_id:
+        st.error("Невозможно обновить токен: нет refresh_token, client_id, client_secret или device_id.")
+        return False
+
+    url = "https://id.vk.com/oauth2/auth"
+    data = {
+        "grant_type": "refresh_token",
+        "client_id": VK_CLIENT_ID,
+        "client_secret": VK_CLIENT_SECRET,
+        "refresh_token": current_refresh,
+        "device_id": device_id
+    }
+
+    headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+    resp = requests.post(url, data=data, headers=headers)
+    with st.expander("Посмотреть логи обновления токена"):
+        st.write(f"Статус ответа: {resp.status_code}")
+        st.write(f"Текст ответа: {resp.text}")
+
+    if resp.status_code != 200:
+        st.error(f"Ошибка обновления токена (HTTP {resp.status_code}): {resp.text}")
+        return False
+
+    try:
+        result = resp.json()
+        with st.expander("Посмотреть JSON-ответ обновления токена"):
+            st.write(f"Ответ от VK API: {result}")
+    except Exception as e:
+        st.error(f"Не удалось распарсить ответ при обновлении токена: {e}")
+        return False
+
+    if "access_token" not in result:
+        err_desc = result.get("error_description", result)
+        st.error(f"Не удалось получить новый access_token: {err_desc}")
+        return False
+
+    # Сохраняем новые значения
+    new_access = result["access_token"]
+    st.session_state["VK_ACCESS_TOKEN"] = new_access
+
+    if "refresh_token" in result:
+        new_refresh = result["refresh_token"]
+        st.session_state["VK_REFRESH_TOKEN"] = new_refresh
+        st.write(f"Новый refresh_token: {new_refresh}")
+    else:
+        st.warning("Новый refresh_token не был получен. Убедитесь, что это ожидаемо.")
+
+    st.success("VK-токен обновлён успешно!")
+    st.write(f"Новый access_token: {new_access}")
+
+    return True
+
+# Функция для форматирования числа просмотров
+def human_format_views(num: int) -> str:
+    if num >= 1_000_000:
+        formatted = f"{num / 1_000_000:.1f}M"
+    else:
+        formatted = f"{num / 1000:.1f}K"
+    return formatted.replace('.', ',')
+
+# Функция для обработки ссылок Telegram
+def process_telegram_link(channel_username: str, message_id: str, canonical_link: str) -> tuple[str, int]:
+    import re, requests
+
+    # Набор альтернативных адресов (если t.me не резолвится)
+    urls = [
+        f"https://t.me/{channel_username}/{message_id}?embed=1",
+        f"https://t.me/s/{channel_username}/{message_id}",
+        f"https://telegram.me/{channel_username}/{message_id}?embed=1",
+        # зеркала через r.jina.ai (обходит проблемы DNS/блокировок)
+        f"https://r.jina.ai/http://t.me/{channel_username}/{message_id}?embed=1",
+        f"https://r.jina.ai/http://t.me/s/{channel_username}/{message_id}",
+        f"https://r.jina.ai/http://telegram.me/{channel_username}/{message_id}?embed=1",
+    ]
+    headers = {"User-Agent": "Mozilla/5.0"}
+
+    def _parse_views_number(s: str) -> int:
+        if not s:
+            return 0
+        s = s.strip().replace(" ", "").replace(",", ".")
+        m2 = re.match(r'([\d\.]+)\s*([kKmM]?)', s)
+        if not m2:
+            return 0
+        val = float(m2.group(1))
+        suf = m2.group(2).lower()
+        if suf == "k":
+            val *= 1_000
+        elif suf == "m":
+            val *= 1_000_000
+        return int(val)
+
+    def _fetch_first_ok(url_list):
+        last_err = None
+        for u in url_list:
+            try:
+                resp = requests.get(u, headers=headers, timeout=15)
+                if resp.status_code == 200 and resp.text:
+                    return resp.text
+            except Exception as e:
+                last_err = e
+        raise last_err or Exception("Не удалось получить страницу Telegram")
+
+    try:
+        html = _fetch_first_ok(urls)
+
+        # Title
+        title = None
+        m_title_meta = re.search(r'<meta[^>]*property=["\']og:title["\'][^>]*content=["\']([^"\']+)["\']', html, re.IGNORECASE)
+        if m_title_meta:
+            title = m_title_meta.group(1).strip()
+        if not title:
+            m_title = re.search(
+                r'class="tgme_widget_message_owner_name".*?<span[^>]*>(.*?)</span>',
+                html, re.IGNORECASE | re.DOTALL
+            )
+            if m_title:
+                title = m_title.group(1).strip()
+        if not title:
+            title = channel_username
+
+        # Views
+        views = 0
+        m_views = re.search(
+            r'class="tgme_widget_message_views[^"]*">([\d\s\.,kKmM]+)<',
+            html, re.IGNORECASE
+        )
+        if m_views:
+            views = _parse_views_number(m_views.group(1))
+        else:
+            candidates = re.findall(
+                r'(\d[\d\s\.,]*)([kKmM]?)\s*(?:views|просмотр|просмотра|просмотров|переглядів|visualizações|visualizzazioni|ansichten|visninger|visitas)?',
+                html, re.IGNORECASE
+            )
+            if candidates:
+                last_num, last_suf = candidates[-1]
+                views = _parse_views_number(last_num + last_suf)
+
+        return title, views
+
+    except Exception as e:
+        # Возвращаем «технический» title и 0, чтобы не ломать общий вывод
+        return f"**Ошибка (TG)** при обработке [{canonical_link}]({canonical_link}): {e}", 0
+
+def process_vk_link(owner_id: int, post_id: str, canonical_link: str) -> tuple[str, int]:
+    posts_param = f"{owner_id}_{post_id}"
+    api_url = "https://api.vk.com/method/wall.getById"
+
+    def do_request(token):
+        params = {
+            "posts": posts_param,
+            "access_token": st.session_state["VK_ACCESS_TOKEN"],
+            "v": VK_API_VERSION,
+            "extended": 1
+        }
+        return requests.get(api_url, params=params)
+
+    resp = do_request(st.session_state["VK_ACCESS_TOKEN"])
+    if resp.status_code != 200:
+        return f"**Ошибка (VK)**: HTTP {resp.status_code} — {canonical_link}", 0
+
+    data = resp.json()
+    if "error" in data:
+        error_msg = data["error"].get("error_msg", "")
+        if "access_token has expired" in error_msg.lower():
+            if refresh_vk_token():
+                resp = do_request(st.session_state["VK_ACCESS_TOKEN"])
+                data = resp.json()
+                if "error" in data:
+                    err_msg2 = data["error"].get("error_msg", "")
+                    return f"**Ошибка (VK)**: {err_msg2} — {canonical_link}", 0
+            else:
+                return f"**Ошибка (VK)**: не удалось обновить токен — {canonical_link}", 0
+        else:
+            return f"**Ошибка (VK)**: {error_msg} — {canonical_link}", 0
+
+    response_data = data.get("response", {})
+    items = response_data.get("items", [])
+    if not items:
+        return f"**Ошибка (VK)**: пост не найден — {canonical_link}", 0
+
+    post = items[0]
+    views = post.get("views", {}).get("count", 0)
+    post_owner_id = post.get("owner_id", owner_id)
+
+    title = None
+    if post_owner_id < 0:
+        group_id = -post_owner_id
+        for g in response_data.get("groups", []):
+            if g["id"] == group_id:
+                title = g["name"]
+                break
+    else:
+        user_id = post_owner_id
+        for p in response_data.get("profiles", []):
+            if p["id"] == user_id:
+                first_name = p.get("first_name", "")
+                last_name = p.get("last_name", "")
+                title = (first_name + " " + last_name).strip()
+                break
+    if not title:
+        title = "VK пост"
+
+    return title, views
+
+# Функция для определения платформы
+def detect_platform(link: str) -> str:
+    link = link.strip().lower()
+    if "t.me/" in link or "telegram.me/" in link:
+        return "telegram"
+    elif "vk.com/wall" in link:
+        return "vk"
+    return ""
+
+def canonicalize_tg_link(link: str):
+    """
+    Возвращает (canonical_link, channel_username, message_id) или (None, None, None)
+    Нормализуем и t.me, и telegram.me, и t.me/s/...
+    """
+    link = link.strip()
+    m = re.match(r'https?://(?:t(?:elegram)?\.me)/(?:s/)?([^/]+)/(\d+)', link, re.IGNORECASE)
+    if not m:
+        return None, None, None
+    username = m.group(1)
+    message_id = m.group(2)
+    canonical = f"https://t.me/{username}/{message_id}"
+    return canonical, username, message_id
+
+def canonicalize_vk_link(link: str):
+    """
+    Возвращает (canonical_link, owner_id(int), post_id(str)) или (None, None, None)
+    """
+    link = link.strip()
+    m = re.search(r'vk\.com/wall(-?\d+)_(\d+)', link)
+    if not m:
+        return None, None, None
+    owner_id = int(m.group(1))
+    post_id = m.group(2)
+    canonical = f"https://vk.com/wall{owner_id}_{post_id}"
+    return canonical, owner_id, post_id
+
+# Функция для отображения интерфейса парсера
+def show_parser_interface():
+    st.write("Вставьте ссылки (каждая на новой строке) — как Telegram, так и ВКонтакте. Пример:")
+    st.code("""
+    https://t.me/meduzalive/130606
+    https://t.me/meduzalive/130604
+    https://vk.com/wall-12256840_3220312
+    https://vk.com/wall-237426_1643234
+    """)
+
+    links_input = st.text_area("Ссылки:", height=200)
+
+    if st.button("Обработать"):
+        # Сырые ссылки
+        raw_lines = [link.strip() for link in links_input.strip().split('\n') if link.strip()]
+        if not raw_lines:
+            st.warning("Нет ссылок для обработки.")
+            return
+
+        # Дедупликация по каноническим ссылкам
+        seen = set()
+        lines = []
+        for link in raw_lines:
+            plat = detect_platform(link)
+            if plat == "telegram":
+                canonical, username, mid = canonicalize_tg_link(link)
+                if not canonical:
+                    # оставляем как есть, чтобы позже показать ошибку
+                    canonical = link
+                    username = None
+                    mid = None
+                if canonical in seen:
+                    continue  # дубликат — пропускаем
+                seen.add(canonical)
+                lines.append(("telegram", canonical, username, mid))
+            elif plat == "vk":
+                canonical, owner_id, post_id = canonicalize_vk_link(link)
+                if not canonical:
+                    canonical = link
+                if canonical in seen:
+                    continue
+                seen.add(canonical)
+                lines.append(("vk", canonical, owner_id, post_id))
+            else:
+                lines.append(("unknown", link, None, None))
+
+        total_links = len(lines)
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+
+        # Группы: {group_key: {"title": str, "items": [(canonical_link, views), ...]}}
+        tg_groups = {}
+        vk_groups = {}
+
+        for i, (plat, canonical, a, b) in enumerate(lines):
+            try:
+                status_text.text(f"Обработка {i+1}/{total_links}: {canonical}")
+
+                if plat == "telegram":
+                    username, mid = a, b
+                    if not username or not mid:
+                        # неправильная ссылка — формируем "ошибочную" запись как отдельную группу по канону
+                        key = canonical
+                        tg_groups.setdefault(key, {"title": "Telegram", "items": []})
+                        tg_groups[key]["items"].append((canonical, 0))
+                    else:
+                        title, views = process_telegram_link(username, mid, canonical)
+                        key = username  # группируем по username канала
+                        if key not in tg_groups:
+                            tg_groups[key] = {"title": title, "items": []}
+                        # title обновим только если он выглядит «нормально»
+                        if not tg_groups[key].get("title") or tg_groups[key]["title"].startswith("**Ошибка"):
+                            tg_groups[key]["title"] = title
+                        tg_groups[key]["items"].append((canonical, views))
+
+                elif plat == "vk":
+                    owner_id, post_id = a, b
+                    if owner_id is None or post_id is None:
+                        key = canonical
+                        vk_groups.setdefault(key, {"title": "VK пост", "items": []})
+                        vk_groups[key]["items"].append((canonical, 0))
+                    else:
+                        title, views = process_vk_link(owner_id, post_id, canonical)
+                        key = str(owner_id)  # группируем по owner_id
+                        if key not in vk_groups:
+                            vk_groups[key] = {"title": title, "items": []}
+                        if not vk_groups[key].get("title") or vk_groups[key]["title"].startswith("**Ошибка"):
+                            vk_groups[key]["title"] = title
+                        vk_groups[key]["items"].append((canonical, views))
+
+                else:
+                    st.error(f"Неизвестная платформа: {canonical}")
+
+                progress_bar.progress((i + 1) / total_links)
+
+            except Exception as e:
+                st.error(f"Ошибка при обработке {canonical}: {str(e)}")
+
+        progress_bar.empty()
+        status_text.empty()
+
+        # Подсчитываем суммарные просмотры по платформам
+        tg_total_views = sum(v for g in tg_groups.values() for _, v in g["items"])
+        vk_total_views = sum(v for g in vk_groups.values() for _, v in g["items"])
+
+        # Сортируем группы по суммарным просмотрам по убыванию
+        tg_sorted = sorted(
+            tg_groups.items(),
+            key=lambda kv: sum(v for _, v in kv[1]["items"]),
+            reverse=True
+        )
+        vk_sorted = sorted(
+            vk_groups.items(),
+            key=lambda kv: sum(v for _, v in kv[1]["items"]),
+            reverse=True
+        )
+
+        md_lines = []
+
+        # --- Telegram ---
+        md_lines.append("## Telegram")
+        md_lines.append(f"**Суммарный охват постов — {human_format_views(tg_total_views)} просмотров**")
+        if tg_sorted:
+            for idx, (_, data) in enumerate(tg_sorted, start=1):
+                title = data["title"] or "Telegram"
+                items = data["items"]
+                # первая ссылка — та, что встретилась первой
+                first_link, first_views = items[0]
+                line = f"{idx}. [{title}]({first_link})"
+                # остальные «ещё»
+                if len(items) > 1:
+                    for link2, _v in items[1:]:
+                        line += f" + [ещё]({link2})"
+                # просмотры как «A + B + C»
+                views_str = " + ".join(human_format_views(v) for _, v in items)
+                line += f" — {views_str}"
+                md_lines.append(line)
+        else:
+            md_lines.append("_Нет ссылок на Telegram_")
+        md_lines.append("")
+
+        # --- ВКонтакте ---
+        md_lines.append("## ВКонтакте")
+        md_lines.append(f"**Суммарный охват постов — {human_format_views(vk_total_views)} просмотров**")
+        if vk_sorted:
+            for idx, (_, data) in enumerate(vk_sorted, start=1):
+                title = data["title"] or "VK пост"
+                items = data["items"]
+                first_link, first_views = items[0]
+                line = f"{idx}. [{title}]({first_link})"
+                if len(items) > 1:
+                    for link2, _v in items[1:]:
+                        line += f" + [ещё]({link2})"
+                views_str = " + ".join(human_format_views(v) for _, v in items)
+                line += f" — {views_str}"
+                md_lines.append(line)
+        else:
+            md_lines.append("_Нет ссылок на ВКонтакте_")
+        md_lines.append("")
+
+        # Вывод
+        st.markdown("### Результат:")
+        for line in md_lines:
+            st.markdown(line, unsafe_allow_html=True)
+
+        markdown_result = "\n".join(md_lines)
+
+        # Кнопка копирования
+        copy_button_html = f"""
+        <html>
+          <head>
+            <script>
+              function copyToClipboard() {{
+                const btn = document.getElementById("copy-btn");
+                const text = `{markdown_result}`;
+                navigator.clipboard.writeText(text).then(function() {{
+                  btn.innerText = "Скопировано успешно";
+                }}, function(err) {{
+                  btn.innerText = "Ошибка при копировании";
+                }});
+              }}
+            </script>
+          </head>
+          <body>
+            <button id="copy-btn" onclick="copyToClipboard()" style="padding: 8px 16px; font-size: 16px;">Скопировать код</button>
+          </body>
+        </html>
+        """
+        components.html(copy_button_html, height=80)
+
+# Интерфейс Streamlit
+def main():
+    st.title("PR Tool made by @Dina")
+    
+    # Первым делом проверяем токен
+    if not st.session_state.get("VK_ACCESS_TOKEN"):
+        vk_auth()
+    else:
+        # Показываем интерфейс парсера
+        show_parser_interface()
+
+# Запуск приложения
+if __name__ == "__main__":
+    main()