Update app.py

app.py

@@ -30,8 +30,9 @@ HF_REQUESTS_REPO = os.getenv("HF_REQUESTS_REPO", "PlanetExpress2125/PostDocReque
 HF_REQUESTS_REPO_TYPE = os.getenv("HF_REQUESTS_REPO_TYPE", "dataset")  # dataset | model
 HF_WRITE_TOKEN = os.getenv("HF_WRITE_TOKEN")  # write token (рекомендуется)
 
-# OpenAlex index dataset
+# OpenAlex index datasets
 OA_INDEX_REPO = os.getenv("OA_INDEX_REPO", "yogl/diss_authors_with_oa_index")
+OA_AUTHORS_REPO = os.getenv("OA_AUTHORS_REPO", "yogl/oa_authors_rus")
 
 SLIDER_MIN_YEAR = 2005  # нижняя граница диапазона лет
 
@@ -46,6 +47,11 @@ COLUMN_LABELS_RU_EXCEL = {
     "registration_number": "Регистрационный номер",
     "vak_link": "Ссылка ВАК",
     "openalex_url": "OpenAlex",
+    "orcid_url": "ORCID",
+    "h_index": "h-index",
+    "i10_index": "i10-index",
+    "works_count": "Работ",
+    "cited_by_count": "Цитат",
 }
 
 DISPLAY_COLUMNS_ALL = [
@@ -71,7 +77,6 @@ if HF_TOKEN is None:
     )
     st.stop()
 
-# HF_TOKEN нужен для чтения приватных датасетов
 try:
     login(token=HF_TOKEN)
 except Exception:
@@ -106,14 +111,8 @@ SCIENCE_LABELS = [
 ]
 SCIENCE_LABELS = sorted(list(dict.fromkeys(SCIENCE_LABELS)), key=lambda s: s.casefold())
 
-DEFAULT_SCIENCES = {
-    "Технические",
-    "Физико-математические",
-    "Химические",
-    "Биологические",
-}
+DEFAULT_SCIENCES = {"Технические", "Физико-математические", "Химические", "Биологические"}
 
-# Паттерны для сопоставления с degree_pursued (на случай разных формулировок в базе)
 SCIENCE_PATTERNS = {
     "Архитектура": ["архитектур"],
     "Биологические": ["биолог"],
@@ -147,14 +146,6 @@ def _keyify(label: str) -> str:
 # ==========================
 
 def save_request_to_hub(payload: dict) -> str:
-    """
-    Сохраняем каждую заявку отдельным JSON-файлом в:
-      <HF_REQUESTS_REPO>/requests/<timestamp>_<uuid>.json
-
-    Требуется токен с правами write:
-      - HF_WRITE_TOKEN (рекомендуется)
-      - если не задан, будет использован HF_TOKEN (если он write)
-    """
     token = HF_WRITE_TOKEN or HF_TOKEN
     if not token:
         raise RuntimeError("Не задан HF_WRITE_TOKEN (и нет HF_TOKEN).")
@@ -178,7 +169,7 @@ def save_request_to_hub(payload: dict) -> str:
 
 
 # ==========================
-# OPENALEX INDEX
+# OPENALEX: REG->AUTHOR + AUTHOR STATS
 # ==========================
 
 def _normalize_regnum(x: Any) -> Optional[str]:
@@ -191,12 +182,6 @@ def _normalize_regnum(x: Any) -> Optional[str]:
 
 
 def _iter_registration_numbers(value: Any) -> List[str]:
-    """
-    registration_numbers может быть:
-      - list/tuple
-      - строкой (один номер или несколько через , ; пробел)
-      - строкой вида "['123','456']"
-    """
     if value is None:
         return []
     if isinstance(value, (list, tuple, np.ndarray)):
@@ -211,7 +196,7 @@ def _iter_registration_numbers(value: Any) -> List[str]:
     if not s or s.lower() == "nan":
         return []
 
-    # попытка распарсить список
+    # попытка распарсить json-список
     if (s.startswith("[") and s.endswith("]")) or (s.startswith("(") and s.endswith(")")):
         try:
             parsed = json.loads(s)
@@ -220,7 +205,6 @@ def _iter_registration_numbers(value: Any) -> List[str]:
         except Exception:
             pass
 
-    # fallback: split
     parts = re.split(r"[,\s;]+", s)
     return [r for r in (_normalize_regnum(p) for p in parts) if r]
 
@@ -231,30 +215,58 @@ def _normalize_oa_url(value: Any) -> str:
     s = str(value).strip()
     if not s or s.lower() == "nan":
         return ""
-    # если уже URL
     if s.startswith("http://") or s.startswith("https://"):
-        # нормализуем домен/слеши
         m = re.search(r"(A\d+)", s)
         if m:
             return f"https://openalex.org/{m.group(1)}"
         return s
-    # если только ID
-    m = re.match(r"^A\d+$", s)
-    if m:
-        return f"https://openalex.org/{s}"
-    # если вдруг мусор — попробуем вытащить A...
     m = re.search(r"(A\d+)", s)
     if m:
         return f"https://openalex.org/{m.group(1)}"
     return ""
 
 
-@st.cache_data(show_spinner="Загрузка индекса OpenAlex...")
-def load_openalex_map() -> Dict[str, str]:
-    """
-    Строим маппинг: registration_number -> openalex_url
-    из yogl/diss_authors_with_oa_index (поле registration_numbers + oa_author_id).
-    """
+def _normalize_orcid_url(value: Any) -> str:
+    if value is None:
+        return ""
+    s = str(value).strip()
+    if not s or s.lower() == "nan":
+        return ""
+    if s.startswith("http://") or s.startswith("https://"):
+        m = re.search(r"(0000-[0-9X]{4}-[0-9X]{4}-[0-9X]{4})", s)
+        if m:
+            return f"https://orcid.org/{m.group(1)}"
+        return s
+    m = re.search(r"(0000-[0-9X]{4}-[0-9X]{4}-[0-9X]{4})", s)
+    if m:
+        return f"https://orcid.org/{m.group(1)}"
+    return ""
+
+
+def _safe_get_stats(summary_stats: Any) -> Tuple[Optional[int], Optional[int]]:
+    # ожидается dict {"h_index":..., "i10_index":...}
+    try:
+        if isinstance(summary_stats, dict):
+            h = summary_stats.get("h_index", None)
+            i10 = summary_stats.get("i10_index", None)
+            h = int(h) if h is not None and str(h).strip() != "" else None
+            i10 = int(i10) if i10 is not None and str(i10).strip() != "" else None
+            return h, i10
+        if isinstance(summary_stats, str) and summary_stats.strip():
+            # иногда может быть строкой json
+            try:
+                d = json.loads(summary_stats)
+                if isinstance(d, dict):
+                    return _safe_get_stats(d)
+            except Exception:
+                pass
+    except Exception:
+        pass
+    return None, None
+
+
+@st.cache_data(show_spinner="Загрузка индекса OpenAlex (registration_number → openalex)...")
+def load_openalex_reg_map() -> Dict[str, str]:
     try:
         ds = load_dataset(OA_INDEX_REPO, split="train")
         df = ds.to_pandas()
@@ -268,16 +280,76 @@ def load_openalex_map() -> Dict[str, str]:
     for _, row in df.iterrows():
         regs = row.get("registration_numbers", None)
         oa = row.get("oa_author_id", None)
-        url = _normalize_oa_url(oa)
-        if not url:
+        oa_url = _normalize_oa_url(oa)
+        if not oa_url:
             continue
         for reg in _iter_registration_numbers(regs):
             if reg and reg not in mapping:
-                mapping[reg] = url
+                mapping[reg] = oa_url
     return mapping
 
 
-OA_MAP = load_openalex_map()
+@st.cache_data(show_spinner="Загрузка базы OpenAlex authors (oa_url → stats)...")
+def load_openalex_authors_map() -> Dict[str, Dict[str, Any]]:
+    """
+    Маппинг по ключу id (пример: https://openalex.org/A5070718545)
+    """
+    try:
+        ds = load_dataset(OA_AUTHORS_REPO, split="train")
+        df = ds.to_pandas()
+    except Exception:
+        return {}
+
+    if "id" not in df.columns:
+        return {}
+
+    need_cols = [c for c in ["id", "orcid", "works_count", "cited_by_count", "summary_stats", "ids"] if c in df.columns]
+    df = df[need_cols].copy()
+
+    out: Dict[str, Dict[str, Any]] = {}
+    for _, row in df.iterrows():
+        oa_url = _normalize_oa_url(row.get("id"))
+        if not oa_url:
+            continue
+
+        orcid_url = _normalize_orcid_url(row.get("orcid"))
+        if not orcid_url:
+            ids = row.get("ids", None)
+            if isinstance(ids, dict):
+                orcid_url = _normalize_orcid_url(ids.get("orcid"))
+            elif isinstance(ids, str) and ids.strip():
+                try:
+                    ids_d = json.loads(ids)
+                    if isinstance(ids_d, dict):
+                        orcid_url = _normalize_orcid_url(ids_d.get("orcid"))
+                except Exception:
+                    pass
+
+        h, i10 = _safe_get_stats(row.get("summary_stats", None))
+
+        wc = row.get("works_count", None)
+        cb = row.get("cited_by_count", None)
+        try:
+            wc = int(wc) if wc is not None and str(wc).strip() != "" else None
+        except Exception:
+            wc = None
+        try:
+            cb = int(cb) if cb is not None and str(cb).strip() != "" else None
+        except Exception:
+            cb = None
+
+        out[oa_url] = {
+            "orcid_url": orcid_url,
+            "h_index": h,
+            "i10_index": i10,
+            "works_count": wc,
+            "cited_by_count": cb,
+        }
+    return out
+
+
+OA_REG_MAP = load_openalex_reg_map()
+OA_AUTHORS_MAP = load_openalex_authors_map()
 
 
 # ==========================
@@ -286,13 +358,11 @@ OA_MAP = load_openalex_map()
 
 @st.cache_data(show_spinner="Загрузка данных...")
 def load_data():
-    # 1) МЕТА-ДАННЫЕ
     ds_meta = load_dataset(HF_MERGED_REPO, split="train")
     df_meta = ds_meta.to_pandas()
     df_meta["registration_number"] = df_meta["registration_number"].astype(str)
     df_meta = df_meta.set_index("registration_number", drop=False)
 
-    # 2) ЭМБЕДДИНГИ
     ds_emb = load_dataset(HF_EMB_REPO, split="train")
     df_emb = ds_emb.to_pandas()
     df_emb["registration_number"] = df_emb["registration_number"].astype(str)
@@ -303,19 +373,15 @@ def load_data():
     norms = np.linalg.norm(emb_matrix, axis=1, keepdims=True)
     emb_matrix = emb_matrix / np.maximum(norms, 1e-8)
 
-    # выравниваем meta под reg_nums
     meta_aligned = df_meta.reindex(reg_nums)
 
-    # dissertation_type masks
     type_s = meta_aligned.get("dissertation_type", pd.Series([""] * len(reg_nums))).fillna("").astype(str)
     is_candidate = type_s.str.contains("кандид", case=False, na=False).to_numpy()
     is_doctor = type_s.str.contains("доктор", case=False, na=False).to_numpy()
 
-    # degree_pursued lower
     deg_s = meta_aligned.get("degree_pursued", pd.Series([""] * len(reg_nums))).fillna("").astype(str)
     degree_lower = np.char.lower(deg_s.to_numpy().astype(str))
 
-    # years
     if "protection_date" in meta_aligned.columns:
         dt = pd.to_datetime(meta_aligned["protection_date"], errors="coerce")
         year_arr = dt.dt.year.astype("float").to_numpy()
@@ -362,15 +428,13 @@ def build_filter_mask(
 ) -> np.ndarray:
     mask = np.ones(len(reg_nums), dtype=bool)
 
-    # Тип диссертации
     type_mask = np.zeros(len(reg_nums), dtype=bool)
     if candidate_selected:
         type_mask |= is_candidate
     if doctor_selected:
         type_mask |= is_doctor
-    mask &= type_mask  # если оба выключены -> всё False
+    mask &= type_mask
 
-    # Науки
     if science_selected:
         sci_mask = np.zeros(len(reg_nums), dtype=bool)
         for label in science_selected:
@@ -378,7 +442,6 @@ def build_filter_mask(
             sci_mask |= _contains_any(degree_lower, patterns)
         mask &= sci_mask
 
-    # Годы (NaN пропускаем)
     if year_range is not None:
         y0, y1 = int(year_range[0]), int(year_range[1])
         yr = year_arr
@@ -479,12 +542,25 @@ def run_search(
     results = search_core(query, top_k, mask=mask)
     df_raw = build_result_df(results)
 
-    # OpenAlex URL по registration_number
-    if not df_raw.empty and OA_MAP:
-        df_raw["openalex_url"] = df_raw["registration_number"].astype(str).map(OA_MAP).fillna("")
+    # 1) registration_number -> openalex_url
+    if not df_raw.empty and OA_REG_MAP:
+        df_raw["openalex_url"] = df_raw["registration_number"].astype(str).map(OA_REG_MAP).fillna("")
     else:
         df_raw["openalex_url"] = ""
 
+    # 2) openalex_url -> orcid + stats
+    def _map_author_field(url: str, field: str):
+        d = OA_AUTHORS_MAP.get(url or "", None)
+        if not d:
+            return None if field != "orcid_url" else ""
+        return d.get(field, None if field != "orcid_url" else "")
+
+    df_raw["orcid_url"] = df_raw["openalex_url"].apply(lambda u: _map_author_field(u, "orcid_url") or "")
+    df_raw["h_index"] = df_raw["openalex_url"].apply(lambda u: _map_author_field(u, "h_index"))
+    df_raw["i10_index"] = df_raw["openalex_url"].apply(lambda u: _map_author_field(u, "i10_index"))
+    df_raw["works_count"] = df_raw["openalex_url"].apply(lambda u: _map_author_field(u, "works_count"))
+    df_raw["cited_by_count"] = df_raw["openalex_url"].apply(lambda u: _map_author_field(u, "cited_by_count"))
+
     # UI: скрываем №, reg номер, тип
     df_ui = df_raw.copy().reset_index(drop=True)
     df_ui = df_ui.rename(
@@ -496,14 +572,18 @@ def run_search(
             "protection_year": "Год",
             "vak_link": "ВАК",
             "openalex_url": "OpenAlex",
+            "orcid_url": "ORCID",
+            "h_index": "h-index",
+            "i10_index": "i10-index",
+            "works_count": "Работ",
+            "cited_by_count": "Цитат",
         }
     )
     df_ui = df_ui.drop(columns=["№", "registration_number", "dissertation_type"])
 
-    # Excel: полный набор + OpenAlex
+    # Excel: полный набор + OA поля
     df_excel = df_raw.copy()
     df_excel_ru = df_excel.rename(columns=COLUMN_LABELS_RU_EXCEL)
-
     output = io.BytesIO()
     with pd.ExcelWriter(output, engine="xlsxwriter") as writer:
         df_excel_ru.to_excel(writer, index=False)
@@ -514,8 +594,8 @@ def run_search(
 
 def format_selected_list_for_ui(df_ui_show: pd.DataFrame, selected_idx: List[int]) -> str:
     lines = []
-    for i in selected_idx:
-        r = df_ui_show.iloc[i]
+    for rid in selected_idx:
+        r = df_ui_show.loc[rid]
         fio = str(r.get("ФИО", "")).strip()
         title = str(r.get("Название диссертации", "")).strip()
         year = r.get("Год", "")
@@ -618,38 +698,55 @@ excel_saved = st.session_state.last_excel
 if isinstance(df_ui_saved, pd.DataFrame) and not df_ui_saved.empty:
     st.success(f"Найдено записей: {len(df_ui_saved)}")
 
+    # Стабильный row id для корректного выбора даже после сортировки кликом
     df_ui_show = df_ui_saved[
-        ["Сходство", "ФИО", "Название диссертации", "Организация", "Год", "ВАК", "OpenAlex"]
+        ["Сходство", "ORCID", "ФИО", "Название диссертации", "Организация", "Год",
+         "ВАК", "OpenAlex", "h-index", "i10-index", "Работ", "Цитат"]
     ].copy()
+    df_ui_show.insert(0, "_rid", np.arange(len(df_ui_show)))
+    df_ui_show = df_ui_show.set_index("_rid")
 
-    # Таблица: сортировка по клику по заголовку + мультивыбор строк (чекбоксы)
+    # Примечание: "гиперссылка над ФИО" внутри одной ячейки в st.dataframe не рендерится;
+    # поэтому ORCID сделан отдельным кликабельным столбцом перед ФИО.
     event = st.dataframe(
         df_ui_show,
         use_container_width=True,
         hide_index=True,
-        column_order=["Сходство", "ФИО", "Название диссертации", "Организация", "Год", "ВАК", "OpenAlex"],
+        column_order=[
+            "Сходство", "ORCID", "ФИО", "Название диссертации", "Организация", "Год",
+            "ВАК", "OpenAlex", "h-index", "i10-index", "Работ", "Цитат"
+        ],
         column_config={
             "Сходство": st.column_config.NumberColumn("Сходство", format="%.4f", width="small"),
+            "ORCID": st.column_config.LinkColumn(
+                "ORCID",
+                display_text=r"https://orcid\.org/([0-9X\-]+)",
+                width="small",
+                help="Профиль автора в ORCID (если найден)",
+            ),
             "ФИО": st.column_config.TextColumn("ФИО", width="medium"),
             "Название диссертации": st.column_config.TextColumn("Название диссертации", width="large"),
             "Организация": st.column_config.TextColumn("Организация", width="medium"),
             "Год": st.column_config.NumberColumn("Год", width="small"),
             "ВАК": st.column_config.LinkColumn("ВАК", display_text="открыть", width="small"),
-            # Отображаем ID (A123...) из URL через regex capture group
             "OpenAlex": st.column_config.LinkColumn(
                 "OpenAlex",
                 display_text=r"https://openalex\.org/(A\d+)",
                 width="small",
                 help="Профиль автора в OpenAlex (если найден)",
             ),
+            "h-index": st.column_config.NumberColumn("h-index", width="small"),
+            "i10-index": st.column_config.NumberColumn("i10-index", width="small"),
+            "Работ": st.column_config.NumberColumn("Работ", width="small"),
+            "Цитат": st.column_config.NumberColumn("Цитат", width="small"),
         },
         on_select="rerun",
         selection_mode="multi-row",
     )
 
-    # сохраняем выбранные строки (позиции 0..N-1 исходного df_ui_show)
     sel = getattr(event, "selection", None)
     if sel is not None and sel.rows is not None:
+        # здесь rows — значения индекса _rid
         st.session_state.selected_rows = list(sel.rows)
 
     if excel_saved is not None:
@@ -678,7 +775,7 @@ if isinstance(df_ui_saved, pd.DataFrame) and not df_ui_saved.empty:
 
         comment = st.text_area(
             "Комментарий",
-            height=140,
+            height=160,
             placeholder=(
                 "Какую дополнительную информацию по авторам диссертаций вы хотите получить?\n"
                 "Какие замечания/пожелания по функционалу системы?"
@@ -693,10 +790,10 @@ if isinstance(df_ui_saved, pd.DataFrame) and not df_ui_saved.empty:
         elif len(selected_rows) == 0:
             st.warning("Выберите хотя бы одну диссертацию в таблице (чекбоксами слева).")
         else:
-            # items по выбранным строкам
             items = []
-            for i in selected_rows:
-                raw = df_raw_saved.iloc[i].to_dict()
+            for rid in selected_rows:
+                # rid == позиция строки в исходном df_raw_saved (потому что _rid = range(len))
+                raw = df_raw_saved.iloc[int(rid)].to_dict()
                 items.append(
                     {
                         "author_fio": raw.get("fio"),
@@ -707,6 +804,11 @@ if isinstance(df_ui_saved, pd.DataFrame) and not df_ui_saved.empty:
                         "registration_number": raw.get("registration_number"),
                         "score": raw.get("score"),
                         "openalex_url": raw.get("openalex_url", ""),
+                        "orcid_url": raw.get("orcid_url", ""),
+                        "h_index": raw.get("h_index"),
+                        "i10_index": raw.get("i10_index"),
+                        "works_count": raw.get("works_count"),
+                        "cited_by_count": raw.get("cited_by_count"),
                     }
                 )
 
@@ -734,7 +836,6 @@ if isinstance(df_ui_saved, pd.DataFrame) and not df_ui_saved.empty:
 else:
     st.info("Введите запрос и нажмите «Поиск». После этого мо��но выбрать диссертации и отправить запрос.")
 
-# Футер
 st.markdown(
     "<p style='font-size: 0.8rem; text-align: right; color: gray;'>(с) Антон Лощилов, 2025</p>",
     unsafe_allow_html=True,