Update src/streamlit_app.py

src/streamlit_app.py

@@ -11,13 +11,12 @@ import ast
 import random
 import tempfile
 
-# Пути к файлам
+# ====== Настройки путей и констант ======
 HERE = os.path.dirname(os.path.abspath(__file__))
 CSV_PATH = os.path.join(HERE, "tvshows_processed2.csv")
 EMB_PATH = os.path.join(HERE, "embeddings.npy")
 FAISS_PATH = os.path.join(HERE, "faiss_index.index")
 
-# Статические данные
 BASIC_GENRES = [
     "комедия", "драма", "боевик", "фэнтези", "ужасы", "триллер", "романтика",
     "научная фантастика", "приключения", "криминал", "мюзикл",
@@ -32,6 +31,7 @@ BAD_PHRASE_PARTS = [
     "описание отсутствует", "пусто"
 ]
 
+# ====== Вспомогательные функции ======
 def list_str_to_text(x):
     try:
         lst = ast.literal_eval(x) if isinstance(x, str) else x
@@ -58,19 +58,24 @@ def extract_intro_paragraph(text, max_sentences=4):
 
 def clean_tvshows_data(path):
     if not os.path.exists(path):
-        st.error(f"Файл данных не найден: {path}.")
-        st.stop()
+        raise FileNotFoundError(f"Файл данных не найден: {path}.")
     df = pd.read_csv(path)
-    df["actors"] = df["actors"].apply(list_str_to_text).apply(clean_actors_string)
-    df["genres"] = df["genres"].apply(list_str_to_text)
-    df["year"] = pd.to_numeric(df["year"], errors="coerce").fillna(0).astype(int)
-    df["num_seasons"] = pd.to_numeric(df["num_seasons"], errors="coerce").fillna(0).astype(int)
-    df["tvshow_title"] = df["tvshow_title"].fillna("Неизвестно")
-    df["description"] = df["description"].fillna("Нет описания").astype(str).str.strip()
+    df["actors"] = df.get("actors", "").apply(list_str_to_text).apply(clean_actors_string)
+    df["genres"] = df.get("genres", "").apply(list_str_to_text)
+    df["year"] = pd.to_numeric(df.get("year", 0), errors="coerce").fillna(0).astype(int)
+    df["num_seasons"] = pd.to_numeric(df.get("num_seasons", 0), errors="coerce").fillna(0).astype(int)
+    df["tvshow_title"] = df.get("tvshow_title", "").fillna("Неизвестно")
+    df["description"] = df.get("description", "").fillna("Нет описания").astype(str).str.strip()
 
+    # Минимальная длина описания — фильтр "мусора"
     df = df[df["description"].apply(lambda x: len(str(x).split())) >= 15]
-    to_drop_exact = df["description"].value_counts()[lambda x: x >= 3].index
-    df = df[~df["description"].isin(to_drop_exact)]
+
+    # Удалим часто повторяющиеся одинаковые описания (вероятный мусор)
+    try:
+        to_drop_exact = df["description"].value_counts()[lambda x: x >= 3].index
+        df = df[~df["description"].isin(to_drop_exact)]
+    except Exception:
+        pass
 
     garbage_patterns = [
         r"(всё в порядке[.!?~ ,]*){3,}",
@@ -80,19 +85,23 @@ def clean_tvshows_data(path):
         r"(нет[.,\s]*){5,}",
     ]
     def matches_garbage(text):
-        return any(re.search(p, str(text).lower()) for p in garbage_patterns)
+        t = str(text).lower()
+        return any(re.search(p, t) for p in garbage_patterns)
     df = df[~df["description"].apply(matches_garbage)]
 
     # фильтрация по плохим фразам
     df = df[~df["description"].str.lower().apply(lambda text: any(phrase in text for phrase in BAD_PHRASE_PARTS))]
 
+    # удалить бинарные столбцы жанров (one-hot), если есть
+    cols_to_ignore = {
+        'tvshow_title','year','genres','actors','rating','description',
+        'image_url','url','language','country','directors','page_url','num_seasons'
+    }
     genre_onehots = [
-        c for c in df.columns if c not in [
-            'tvshow_title','year','genres','actors','rating','description',
-            'image_url','url','language','country','directors','page_url','num_seasons'
-        ] and df[c].nunique() <= 2
+        c for c in df.columns if c not in cols_to_ignore and df[c].nunique() <= 2
     ]
     df = df.drop(columns=genre_onehots, errors="ignore")
+
     df["basic_genres"] = df["genres"].apply(filter_to_basic_genres)
     df["type"] = df["num_seasons"].apply(lambda x: "Сериал" if pd.notna(x) and int(x) > 1 else "Фильм")
     for col in ["image_url", "url", "rating", "language", "country"]:
@@ -100,56 +109,66 @@ def clean_tvshows_data(path):
             df[col] = None
     return df.reset_index(drop=True)
 
+# ====== Кэширование и инициализация (один раз) ======
 @st.cache_data
-def load_data():
-    return clean_tvshows_data(CSV_PATH)
+def cached_load_data(path):
+    return clean_tvshows_data(path)
 
 @st.cache_resource
-def init_embedder():
+def cached_init_embedder():
     cache_dir = os.path.join(tempfile.gettempdir(), "sbert_cache")
     os.makedirs(cache_dir, exist_ok=True)
     return SentenceTransformer("sberbank-ai/sbert_large_nlu_ru", cache_folder=cache_dir)
 
 @st.cache_resource
-def load_embeddings_and_index():
+def cached_load_embeddings_and_index():
     if not os.path.exists(EMB_PATH) or not os.path.exists(FAISS_PATH):
-        st.error("Файлы embeddings.npy или faiss_index.index не найдены.")
-        st.stop()
+        raise FileNotFoundError("Файлы embeddings.npy или faiss_index.index не найдены.")
     embeddings = np.load(EMB_PATH)
     index = faiss.read_index(FAISS_PATH)
     return embeddings, index
 
+def cached_init_groq_llm(api_key: str):
+    # Не кэшируем внутри функции Streamlit виджет — вызываем только если ключ есть.
+    if not api_key:
+        return None
+    os.environ["GROQ_API_KEY"] = api_key
+    try:
+        return ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0, max_tokens=2000)
+    except Exception as e:
+        st.error(f"Ошибка инициализации Groq: {e}")
+        return None
+
+# ====== Поисковые/вспомогательные функции ======
 def semantic_search(query, embedder, index, df, genre=None, year=None, country=None, vtype=None, k=5):
-    if not query.strip():
+    if not isinstance(query, str) or not query.strip():
         return pd.DataFrame()
     query_embedding = embedder.encode([query])
     faiss.normalize_L2(query_embedding)
-    dists, idxs = index.search(query_embedding, max(k*3, k))
-    res = df.iloc[idxs[0]].copy()
-    res["score"] = dists[0]
-    if genre != "Все":
+    # безопасный search: index.search expects int >=1
+    n_search = max(k*3, 1)
+    dists, idxs = index.search(query_embedding, n_search)
+    # idxs может содержать -1 для неполных результатов — защитим себя
+    valid_idxs = [i for i in idxs[0] if i >= 0 and i < len(df)]
+    if not valid_idxs:
+        return pd.DataFrame()
+    res = df.iloc[valid_idxs].copy()
+    res["score"] = dists[0][:len(valid_idxs)]
+    if genre and genre != "Все":
         res = res[res["basic_genres"].str.contains(genre, na=False)]
-    if year != "Все":
-        res = res[res["year"] == int(year)]
-    if country != "Все":
+    if year and year != "Все":
+        try:
+            res = res[res["year"] == int(year)]
+        except:
+            pass
+    if country and country != "Все":
         res = res[res["country"].astype(str).str.contains(country, na=False)]
-    if vtype != "Все":
+    if vtype and vtype != "Все":
         res = res[res["type"] == vtype]
+    if res.empty:
+        return res
     return res.nlargest(k, "score")
 
-@st.cache_resource(ttl=3600)
-def init_groq_llm():
-    key = os.environ.get("GROQ_API_KEY") or (st.secrets.get("GROQ_API_KEY") if hasattr(st, "secrets") else None) or st.text_input("🔐 Введите API-ключ Groq:", type="password")
-    if not key:
-        st.warning("Введите Groq API ключ.")
-        st.stop()
-    os.environ["GROQ_API_KEY"] = key
-    try:
-        return ChatGroq(model="deepseek-r1-distill-llama-70b", temperature=0, max_tokens=2000)
-    except Exception as e:
-        st.error(f"Ошибка инициализации Groq: {e}")
-        st.stop()
-
 def format_docs_for_prompt(results_df):
     parts = []
     for _, row in results_df.iterrows():
@@ -163,41 +182,99 @@ def format_docs_for_prompt(results_df):
     return "\n\n".join(parts)
 
 def generate_rag_response(user_query, search_results, llm):
+    if llm is None or search_results.empty:
+        return "LLM не инициализирован или нет результатов для анализа."
     ctx = format_docs_for_prompt(search_results)
-    return llm.invoke([SystemMessage(content="Ты — эксперт по кино и сериалам."),
-                       HumanMessage(content=f"Запрос: {user_query}\n\n{ctx}")]).content.strip()
+    try:
+        return llm.invoke([SystemMessage(content="Ты — эксперт по кино и сериалам."),
+                           HumanMessage(content=f"Запрос: {user_query}\n\n{ctx}")]).content.strip()
+    except Exception as e:
+        return f"Ошибка при генерации ответа LLM: {e}"
 
+# ====== UI: main ======
 def main():
     st.set_page_config(page_title="Поиск фильмов и сериалов + AI", layout="wide")
     st.title("Семантический поиск фильмов и сериалов с AI")
 
-    if "results" not in st.session_state:
-        st.session_state.results = pd.DataFrame()
-    if "ai_clicked" not in st.session_state:
-        st.session_state.ai_clicked = False
-    
-    df = load_data()
-    embedder = init_embedder()
-    _, index = load_embeddings_and_index()
-    llm = init_groq_llm()
+    # ====== Сайдбар: API ключ и глобальные настройки (фиксируем здесь) ======
+    st.sidebar.header("Настройки")
+    api_key = st.sidebar.text_input("Groq API ключ (если нужен):", type="password")
+    # Кэш��руем ключ в session_state — чтобы не перерисовывать виджет внутри init-функции
+    if "groq_api_key" not in st.session_state:
+        st.session_state.groq_api_key = api_key
+    else:
+        # если поменял в сайдбаре — актуализируем
+        if api_key and api_key != st.session_state.groq_api_key:
+            st.session_state.groq_api_key = api_key
+
+    # ====== Инициализация данных и ресурсов один раз (через session_state) ======
+    if "df" not in st.session_state:
+        try:
+            st.session_state.df = cached_load_data(CSV_PATH)
+        except FileNotFoundError as e:
+            st.sidebar.error(str(e))
+            st.stop()
+
+    if "embedder" not in st.session_state:
+        try:
+            st.session_state.embedder = cached_init_embedder()
+        except Exception as e:
+            st.sidebar.error(f"Ошибка инициализации embedder: {e}")
+            st.stop()
+
+    if "embeddings_index" not in st.session_state:
+        try:
+            st.session_state.embeddings, st.session_state.index = cached_load_embeddings_and_index()
+        except FileNotFoundError as e:
+            st.sidebar.error(str(e))
+            st.stop()
+        except Exception as e:
+            st.sidebar.error(f"Ошибка загрузки индекса/эмбеддингов: {e}")
+            st.stop()
+
+    # LLM инициализируем только если есть ключ (и положим в st.session_state)
+    if st.session_state.get("groq_api_key"):
+        if "llm" not in st.session_state or st.session_state.get("last_groq_key") != st.session_state.groq_api_key:
+            st.session_state.llm = cached_init_groq_llm(st.session_state.groq_api_key)
+            st.session_state.last_groq_key = st.session_state.groq_api_key
+    else:
+        st.session_state.llm = None
+
+    df = st.session_state.df
+    embedder = st.session_state.embedder
+    index = st.session_state.index
+    llm = st.session_state.llm
+
+    # ====== Форма поиска (стабильная) ======
+    # Резервируем контейнер для результатов чтобы избежать прыжков layout
+    results_container = st.container()
+    ai_response_container = st.container()
 
     with st.form(key='search_form'):
         colf1, colf2, colf3, colf4 = st.columns(4)
         with colf1:
-            genres = ["Все"] + sorted(set(sum([g.split(", ") for g in df["basic_genres"].dropna().unique()], [])))
-            genre_filter = st.selectbox("Жанр", genres)
+            # Генерируем список жанров стабильно (сортируем и делаем set один раз)
+            basic_genres_list = []
+            for g in df["basic_genres"].dropna().unique():
+                # split по ", " и extend
+                for part in str(g).split(","):
+                    p = part.strip()
+                    if p:
+                        basic_genres_list.append(p)
+            genres = ["Все"] + sorted(set(basic_genres_list))
+            genre_filter = st.selectbox("Жанр", genres, index=0, key="genre_filter_key")
         with colf2:
             years = ["Все"] + [str(y) for y in sorted(df["year"].unique())]
-            year_filter = st.selectbox("Год", years)
+            year_filter = st.selectbox("Год", years, index=0, key="year_filter_key")
         with colf3:
             countries = ["Все"] + sorted([c for c in df["country"].dropna().unique()])
-            country_filter = st.selectbox("Страна", countries)
+            country_filter = st.selectbox("Страна", countries, index=0, key="country_filter_key")
         with colf4:
             vtypes = ["Все"] + sorted(df["type"].dropna().unique())
-            type_filter = st.selectbox("Тип", vtypes)
-        
-        k = st.slider("Количество результатов:", 1, 20, 5)
-        user_input = st.text_input("Введите ключевые слова или сюжет:")
+            type_filter = st.selectbox("Тип", vtypes, index=0, key="type_filter_key")
+
+        k = st.slider("Количество результатов:", 1, 20, 5, key="k_slider")
+        user_input = st.text_input("Введите ключевые слова или сюжет:", key="user_input_key")
 
         nav1, nav2, nav3, nav4 = st.columns(4)
         with nav1:
@@ -208,9 +285,12 @@ def main():
             new_search = st.form_submit_button("Новинки")
         with nav4:
             text_search = st.form_submit_button("Искать")
-    
+
+    # ====== Обработка поисковых событий (логика оставлена прежней) ======
+    performed_search = False
     if text_search and user_input:
         st.session_state.last_query = user_input
+        performed_search = True
         with st.spinner("Поиск..."):
             st.session_state.results = semantic_search(
                 user_input, embedder, index, df,
@@ -218,8 +298,9 @@ def main():
             )
             st.session_state.ai_clicked = False
     elif random_search:
-        random_query = random.choice(df["tvshow_title"])
+        random_query = random.choice(df["tvshow_title"].tolist())
         st.session_state.last_query = random_query
+        performed_search = True
         with st.spinner("Поиск..."):
             st.session_state.results = semantic_search(
                 random_query, embedder, index, df,
@@ -228,6 +309,7 @@ def main():
             st.session_state.ai_clicked = False
     elif genre_search and genre_filter != "Все":
         st.session_state.last_query = genre_filter
+        performed_search = True
         with st.spinner("Поиск..."):
             st.session_state.results = semantic_search(
                 genre_filter, embedder, index, df,
@@ -235,50 +317,71 @@ def main():
             )
             st.session_state.ai_clicked = False
     elif new_search:
-        new_query = str(max(df["year"]))
+        new_query = str(int(df["year"].max())) if not df["year"].isna().all() else ""
         st.session_state.last_query = new_query
+        performed_search = True
         with st.spinner("Поиск..."):
             st.session_state.results = semantic_search(
                 new_query, embedder, index, df,
                 genre_filter, year_filter, country_filter, type_filter, k
             )
             st.session_state.ai_clicked = False
-    elif text_search or random_search or genre_search or new_search:
-        st.session_state.results = pd.DataFrame()
-        st.session_state.ai_clicked = False
-    
-    if not st.session_state.results.empty:
-        st.success(f"Найдено: {len(st.session_state.results)}")
-        for _, row in st.session_state.results.iterrows():
-            col1, col2 = st.columns([1, 3])
-            with col1:
-                if row["image_url"]:
-                    try:
-                        st.image(row["image_url"], use_container_width=True)
-                    except:
-                        st.info("Нет изображения или не удалось загрузить")
-                else:
-                    st.info("Нет изображения")
-            with col2:
-                st.markdown(f"### {row['tvshow_title']} ({row['year']})")
-                st.caption(f"{row['basic_genres']} | {row['country'] or '—'} | {row['rating'] or '—'} | {row['type']} | {row['num_seasons']} сез.")
-                st.write(extract_intro_paragraph(row["description"]))
-                if row["actors"]:
-                    st.caption(f"Актёры: {row['actors']}")
-                if row["url"]:
-                    st.markdown(f"[Подробнее]({row['url']})")
-            st.divider()
-
-        if st.button("AI: почему эти подходят и что ещё посмотреть"):
-            st.session_state.ai_clicked = True
-    elif 'last_query' in st.session_state and st.session_state.last_query.strip() != "":
-        st.warning("Ничего не найдено.")
-    
-    if st.session_state.ai_clicked and not st.session_state.results.empty and llm is not None:
-        st.markdown("### Рекомендации AI:")
-        with st.spinner("Генерация ответа AI..."):
-            st.write(generate_rag_response(st.session_state.last_query, st.session_state.results, llm))
+    else:
+        # если форма была отправлена без поискового действия — не трогаем
+        if 'results' not in st.session_state:
+            st.session_state.results = pd.DataFrame()
+            st.session_state.ai_clicked = False
+
+    # ====== Отрисовка результатов в постоянном контейнере (чтобы не дергалось) ======
+    with results_container:
+        # всегда резервируем пространство — пустой заголовок/плейсхолдер, чтобы layout не менялся
+        st.markdown("## Результаты поиска")
+        if not st.session_state.get("results") or st.session_state.results.empty:
+            # Показываем либо предупреждение если был поиск и ничего не найдено,
+            # либо подсказку с примером — без "скачка" layout.
+            if performed_search and ('last_query' in st.session_state and st.session_state.last_query.strip() != ""):
+                st.warning("Ничего не найдено.")
+            else:
+                st.info("Введите запрос и нажмите «Искать», или выберите «Случайный фильм/сериал».")
+        else:
+            res_df = st.session_state.results
+            st.success(f"Найдено: {len(res_df)}")
+            # выводим карточки — фиксируем ширину изображения, и��пользуем колонки одинаковой структуры
+            for _, row in res_df.iterrows():
+                card_cols = st.columns([1, 3])
+                with card_cols[0]:
+                    # зарезервируем пространство под изображение фиксированной ширины
+                    if row.get("image_url"):
+                        try:
+                            st.image(row["image_url"], width=150)
+                        except Exception:
+                            st.info("Нет изображения")
+                    else:
+                        st.info("Нет изображения")
+                with card_cols[1]:
+                    st.markdown(f"### {row['tvshow_title']} ({row['year']})")
+                    st.caption(f"{row['basic_genres']} | {row['country'] or '—'} | {row['rating'] or '—'} | {row['type']} | {row['num_seasons']} сез.")
+                    st.write(extract_intro_paragraph(row["description"]))
+                    if row.get("actors"):
+                        st.caption(f"Актёры: {row['actors']}")
+                    if row.get("url"):
+                        st.markdown(f"[Подробнее]({row['url']})")
+                st.divider()
+
+            # кнопка AI — рендерим в том же контейнере, чтобы layout был постоянным
+            if st.button("AI: почему эти подходят и что ещё посмотреть", key="ai_button"):
+                st.session_state.ai_clicked = True
+
+    # ====== AI-ответ в отдельном контейнере (резервированном) ======
+    with ai_response_container:
+        if st.session_state.get("ai_clicked") and st.session_state.get("results") is not None and not st.session_state.results.empty:
+            st.markdown("### Рекомендации AI:")
+            with st.spinner("Генерация ответа AI..."):
+                rag = generate_rag_response(st.session_state.last_query, st.session_state.results, llm)
+                # Выводим результат в обрамлённом блоке, не добавляя других виджетов
+                st.write(rag)
 
+    # ====== Сайдбар: статистика ======
     st.sidebar.write(f"Всего записей: {len(df)}")
 
 if __name__ == "__main__":