Update app.py

app.py

@@ -54,27 +54,6 @@ embeddings_table = "movie_embeddings"
 query_cache_table = "query_cache"
 movies_table = "Movies"  # Имя таблицы с фильмами
 
-# Максимальный размер таблицы кэша запросов в байтах (50MB)
-MAX_CACHE_SIZE = 50 * 1024 * 1024
-
-# Очередь для необработанных фильмов
-movies_queue = queue.Queue()
-
-# Флаг, указывающий, что обработка фильмов завершена
-processing_complete = False
-
-# Флаг, указывающий, что выполняется поиск
-search_in_progress = False
-
-# Блокировка для доступа к базе данных
-db_lock = threading.Lock()
-
-# Размер пакета для обработки эмбеддингов
-batch_size = 32
-
-# Количество потоков для параллельной обработки
-num_threads = 5
-
 # FastAPI приложение
 app = FastAPI()
 
@@ -143,46 +122,6 @@ def encode_string(text):
     embedding = model.encode(text, convert_to_tensor=True, normalize_embeddings=True)
     return embedding.cpu().numpy()
 
-def get_movies_without_embeddings():
-    """Получает список фильмов, для которых нужно создать эмбеддинги."""
-    conn = get_db_connection()
-    if conn is None:
-        return []
-
-    movies_to_process = []
-    try:
-        with conn.cursor() as cur:
-            # Получаем список ID фильмов, которые уже есть в таблице эмбеддингов
-            cur.execute(f"SELECT movie_id FROM \"{embeddings_table}\"")
-            existing_ids = {row[0] for row in cur.fetchall()}
-
-            # Получаем список всех фильмов из таблицы Movies с подготовленной строкой
-            cur.execute(f"""
-                SELECT id, data,
-                    jsonb_build_object(
-                        'Название', data->>'name',
-                        'Год', data->>'year',
-                        'Жанры', (SELECT string_agg(genre->>'name', ', ') FROM jsonb_array_elements(data->'genres') AS genre),
-                        'Описание', COALESCE(data->>'description', '')
-                    ) AS prepared_json
-                FROM "{movies_table}"
-            """)
-            all_movies = cur.fetchall()
-
-            # Фильтруем только те фильмы, которых нет в таблице эмбеддингов
-            for movie_id, movie_data, prepared_json in all_movies:
-                if movie_id not in existing_ids:
-                    prepared_string = f"Название: {prepared_json['Название']}\nГод: {prepared_json['Год']}\nЖанры: {prepared_json['Жанры']}\nОписание: {prepared_json['Описание']}"
-                    movies_to_process.append((movie_id, movie_data, prepared_string))
-
-        logging.info(f"Найдено {len(movies_to_process)} фильмов для обработки.")
-    except Exception as e:
-        logging.error(f"Ошибка при получении списка фильмов для обработки: {e}")
-    finally:
-        conn.close()
-
-    return movies_to_process
-
 def get_embedding_from_db(conn, table_name, crc32_column, crc32_value, model_name):
     """Получает эмбеддинг из базы данных."""
     try:
@@ -197,97 +136,6 @@ def get_embedding_from_db(conn, table_name, crc32_column, crc32_value, model_nam
         logging.error(f"Ошибка при получении эмбеддинга из БД: {e}")
     return None
 
-def insert_embedding(conn, table_name, movie_id, embedding_crc32, string_crc32, embedding):
-    """Вставляет эмбеддинг в базу данных."""
-    try:
-        # Нормализуем эмбеддинг перед сохранением
-        normalized_embedding = normalize(embedding.reshape(1, -1))[0]
-        with conn.cursor() as cur:
-            cur.execute(f"""
-                INSERT INTO "{table_name}" 
-                (movie_id, embedding_crc32, string_crc32, model_name, embedding)
-                VALUES (%s, %s, %s, %s, %s)
-                ON CONFLICT (movie_id) DO NOTHING
-            """, (movie_id, embedding_crc32, string_crc32, model_name, normalized_embedding.tolist()))
-        conn.commit()
-        return True
-    except Exception as e:
-        logging.error(f"Ошибка при вставке эмбеддинга: {e}")
-        conn.rollback()
-        return False
-
-def process_batch(batch):
-    """Обрабатывает пакет фильмов, создавая для них эмбеддинги."""
-    conn = get_db_connection()
-    if conn is None:
-        return
-
-    try:
-        for movie_id, movie_data, prepared_string in batch:
-            string_crc32 = calculate_crc32(prepared_string)
-
-            # Проверяем существующий эмбеддинг
-            existing_embedding = get_embedding_from_db(conn, embeddings_table, "string_crc32", string_crc32, model_name)
-
-            if existing_embedding is None:
-                embedding = encode_string(prepared_string)
-                embedding_crc32 = calculate_crc32(str(embedding.tolist()))
-
-                if insert_embedding(conn, embeddings_table, movie_id, embedding_crc32, string_crc32, embedding):
-                    logging.info(f"Сохранен эмбеддинг для '{movie_data['name']}' (ID: {movie_id})")
-                else:
-                    logging.error(f"Ошибка сохранения эмбеддинга для '{movie_data['name']}' (ID: {movie_id})")
-            else:
-                logging.info(f"Эмбеддинг для '{movie_data['name']}' (ID: {movie_id}) уже существует")
-    except Exception as e:
-        logging.error(f"Ошибка при обработке пакета фильмов: {e}")
-    finally:
-        conn.close()
-
-def process_movies():
-    """Обрабатывает фильмы, создавая для них эмбеддинги."""
-    global processing_complete
-
-    logging.info("Начало обработки фильмов.")
-
-    # Получаем список фильмов, которые нужно обработать
-    movies_to_process = get_movies_without_embeddings()
-
-    if not movies_to_process:
-        logging.info("Все фильмы уже обработаны.")
-        processing_complete = True
-        return
-
-    # Добавляем фильмы в очередь
-    for movie in movies_to_process:
-        movies_queue.put(movie)
-
-    with ThreadPoolExecutor(max_workers=num_threads) as executor:
-        try:
-            while not movies_queue.empty():
-                if search_in_progress:
-                    time.sleep(1)
-                    continue
-
-                batch = []
-                while not movies_queue.empty() and len(batch) < batch_size:
-                    try:
-                        movie = movies_queue.get_nowait()
-                        batch.append(movie)
-                    except queue.Empty:
-                        break
-
-                if not batch:
-                    break
-
-                executor.submit(process_batch, batch)
-                logging.info(f"Отправлен на обработку пакет из {len(batch)} фильмов.")
-        except Exception as e:
-            logging.error(f"Ошибка при обработке фильмов: {e}")
-
-    processing_complete = True
-    logging.info("Обработка фильмов завершена")
-
 def get_movie_data_from_db(conn, movie_ids):
     """Получает данные фильмов из таблицы Movies по списку ID."""
     movie_data_dict = {}
@@ -362,11 +210,9 @@ def rerank_with_api(query, results, top_k):
     except requests.exceptions.RequestException as e:
         logging.error(f"Ошибка при запросе к API реранжировщика: {e}")
         return []
-    
+
 def search_movies_internal(query: str, top_k: int = 25):
     """Внутренняя функция для поиска фильмов по запросу (используется и в Gradio, и в API)."""
-    global search_in_progress
-    search_in_progress = True
     start_time = time.time()
 
     try:
@@ -449,9 +295,6 @@ def search_movies_internal(query: str, top_k: int = 25):
         logging.error(f"Ошибка при выполнении поиска: {e}")
         raise
 
-    finally:
-        search_in_progress = False
-        
 def search_movies(query, top_k=25):
     """Функция поиска фильмов для Gradio интерфейса."""
     try:
@@ -476,14 +319,6 @@ async def api_search_movies(query: str = Query(..., description="Поисков
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
-# Запускаем обработку фильмов в отдельном потоке (если ещё не запущена)
-if not 'processing_thread' in globals():
-    processing_thread = threading.Thread(target=process_movies)
-    processing_thread.start()
-elif not processing_thread.is_alive():
-    processing_thread = threading.Thread(target=process_movies)
-    processing_thread.start()
-
 # Создаем интерфейс Gradio
 iface = gr.Interface(
     fn=search_movies,