Update main.py

main.py

@@ -1,46 +1,51 @@
 import os
-import io
-import uuid
-import tempfile
-import logging
-import threading
-import traceback
-from datetime import datetime
-from docx import Document
-
 import streamlit as st
+import logging
 from dotenv import load_dotenv
 
-# ====== БАЗОВАЯ НАСТРОЙКА ======
+# Load environment variables first, before any other code
 load_dotenv()
-from config import ENV_DEFAULTS, DEFAULT_CONFIG  # после .env, чтобы приоритет был у env
 
-# Логирование
+# Import configuration defaults (after loading .env to prioritize environment variables)
+from config import ENV_DEFAULTS, DEFAULT_CONFIG
+
+# Configure logging based on configuration
 log_level = os.environ.get('LOGLEVEL', DEFAULT_CONFIG['LOGLEVEL']).upper()
 logging.basicConfig(
     level=getattr(logging, log_level),
     format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler() if log_level != 'WARNING' else logging.NullHandler()]
+    handlers=[
+        # Only log to console if level is INFO or higher
+        logging.StreamHandler() if log_level != 'WARNING' else logging.NullHandler()
+    ]
 )
 
-# Конфиг приложения
-st.set_page_config(page_title="Translator & Readability", page_icon="🗨️", layout="wide")
+# Configure app
+st.set_page_config(page_title="Translator & Readability", layout="wide")
 
-# Подставляем дефолты переменных окружения при их отсутствии
+# Check for missing environment variables and use defaults from config
 for var, default in ENV_DEFAULTS.items():
     if var not in os.environ:
         logging.debug(f"Environment variable {var} not found, using default: {default}")
         os.environ[var] = default
 
+# Model configuration from default config
 MODEL_CONFIG = {
     "max_parallel_models": DEFAULT_CONFIG["MAX_PARALLEL_MODELS"],
     "session_timeout": DEFAULT_CONFIG["SESSION_TIMEOUT"],
     "allow_gpu": DEFAULT_CONFIG["ALLOW_GPU"]
 }
 
+# Initialize model semaphore for limiting concurrent model usage
+import threading
 model_semaphore = threading.Semaphore(MODEL_CONFIG["max_parallel_models"])
 
-# ====== ИМПОРТЫ МОДЕЛЕЙ/УТИЛИТ ======
+import tempfile
+import io
+from docx import Document
+import uuid
+import traceback
+
 from models.nltk_resources import setup_nltk
 from utils.file_readers import read_file
 from utils.text_processing import detect_language
@@ -52,351 +57,273 @@ from utils.readability_indices import (
     highlight_complex_text
 )
 from utils.formatting import color_code_index
-from utils.tilmash_translation import tilmash_translate, display_tilmash_streaming_translation, TilmashTranslator
+from utils.tilmash_translation import tilmash_translate, display_tilmash_streaming_translation
 
-
-# ====== СЕССИИ ======
+# Initialize session state for user identification
 if 'session_id' not in st.session_state:
     st.session_state.session_id = str(uuid.uuid4())
+
 if 'translation_lock' not in st.session_state:
     st.session_state.translation_lock = False
-if 'analysis_lock' not in st.session_state:
-    st.session_state.analysis_lock = False
-
-
-# ====== UI-ХЕЛПЕРЫ ======
-def columns_safe(spec, **kwargs):
-    """Совместимый вызов st.columns: игнорирует неподдерживаемые аргументы (например, vertical_alignment)."""
-    try:
-        return st.columns(spec, **kwargs)
-    except TypeError:
-        return st.columns(spec)
-
-def badge(text: str, kind: str = "neutral"):
-    palette = {
-        "ok": "#16a34a",
-        "warn": "#f59e0b",
-        "err": "#ef4444",
-        "info": "#3b82f6",
-        "neutral": "#6b7280"
-    }
-    color = palette.get(kind, palette["neutral"])
-    st.markdown(
-        f"""
-        <span style="
-            display:inline-block;padding:2px 8px;border-radius:999px;
-            font-size:12px;line-height:18px;background:{color}20;color:{color};
-            border:1px solid {color}50;
-        ">{text}</span>
-        """,
-        unsafe_allow_html=True
-    )
-
-def section_title(title: str, subtitle: str = ""):
-    st.markdown(
-        f"""
-        <div style="margin:8px 0 2px 0;font-weight:700;font-size:20px;">{title}</div>
-        {"<div style='color:#6b7280;margin-bottom:12px;'>"+subtitle+"</div>" if subtitle else ""}
-        """,
-        unsafe_allow_html=True
-    )
-
-def horizontal_rule():
-    st.markdown('<hr style="margin:12px 0;opacity:.2;">', unsafe_allow_html=True)
-
-
-# ====== БОКОВАЯ ПАНЕЛЬ ======
-with st.sidebar:
-    st.header("Панель")
-    with st.expander("Сведения о сессии", expanded=False):
-        st.code(f"Session: {st.session_state.session_id}")
-        st.caption(datetime.now().strftime("Started: %Y-%m-%d %H:%M:%S"))
-
-    # GPU-параметр
-    if MODEL_CONFIG["allow_gpu"]:
-        st.session_state.use_gpu = st.checkbox("Использовать GPU (если доступен)", value=True)
-        try:
-            import torch
-            if st.session_state.use_gpu:
-                if torch.cuda.is_available():
-                    badge(f"CUDA: {torch.cuda.get_device_name(0)}", "ok")
-                elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
-                    badge("Apple Silicon (MPS) доступен", "ok")
-                else:
-                    badge("GPU не обнаружен → CPU", "warn")
-                    st.session_state.use_gpu = False
-        except ImportError:
-            badge("PyTorch не установлен → CPU", "warn")
-            st.session_state.use_gpu = False
-    else:
-        st.session_state.use_gpu = False
-        st.caption("GPU отключён в конфигурации.")
 
-    horizontal_rule()
-    st.caption("Подсказка: используйте вкладки сверху для переключения режимов.")
 
+def handle_translation():
+    st.header("Перевод (Kazakh, Russian, English)")
 
-# ====== ВЕРХНИЙ ХЕДЕР ======
-st.title("Translation & Readability Analysis")
-st.caption("Перевод между 🇰🇿 🇷🇺 🇬🇧 и анализ удобочитаемости текста. Без сторонних библиотек — только Streamlit.")
+    # Show session ID in sidebar for debugging
+    with st.sidebar.expander("Session Info", expanded=False):
+        st.write(f"Session ID: {st.session_state.session_id}")
 
+        # Add GPU usage option
+        if MODEL_CONFIG["allow_gpu"]:
+            st.session_state.use_gpu = st.checkbox("Использовать GPU (быстрее)", value=True)
+            if st.session_state.use_gpu:
+                try:
+                    import torch
+                    if torch.cuda.is_available():
+                        gpu_info = f"CUDA: {torch.cuda.get_device_name(0)}"
+                        st.success(f"Доступен GPU: {gpu_info}")
+                    elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+                        st.success("Доступен Apple Silicon GPU (MPS)")
+                    else:
+                        st.warning("GPU не обнаружен, будет использован CPU")
+                        st.session_state.use_gpu = False
+                except ImportError:
+                    st.warning("PyTorch не установлен, будет использован CPU")
+                    st.session_state.use_gpu = False
+        else:
+            st.session_state.use_gpu = False
+            st.write("GPU отключен в конфигурации")
 
-# ====== ВКЛАДКИ ======
-tab_translate, tab_readability = st.tabs(["📝 Перевод", "📊 Удобочитуемость"])
-
-
-# ====== ПЕРЕВОД ======
-with tab_translate:
-    section_title("Перевод (Kazakh, Russian, English)",
-                  "Загрузите файл или вставьте текст. Язык определится автоматически (можно задать вручную).")
-
-    c1, c2 = columns_safe([1, 2])  # удалён vertical_alignment
-    with c1:
-        input_mode = st.radio("Источник текста:", ["Загрузить файл", "Вставить текст"], horizontal=True)
-    with c2:
-        clear_input = st.button("Очистить ввод", use_container_width=True)
-
+    translate_input_method = st.radio("Способ ввода текста:", ["Загрузить файл", "Вставить текст"])
     input_text = ""
-    file_name = None
 
-    if input_mode == "Загрузить файл":
+    if translate_input_method == "Загрузить файл":
         uploaded_file = st.file_uploader("Выберите файл (.txt, .docx, .pdf)", type=["txt", "docx", "pdf"])
         if uploaded_file is not None:
-            file_name = uploaded_file.name
-            suffix = os.path.splitext(file_name)[1]
-            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
-                tmp.write(uploaded_file.getbuffer())
-                temp_path = tmp.name
-            input_text = read_file(temp_path)
-            os.remove(temp_path)
-
-            with st.expander("Предпросмотр файла (только чтение)", expanded=False):
-                st.text_area("Содержимое", value=input_text, height=160, disabled=True)
+            suffix = os.path.splitext(uploaded_file.name)[1]
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
+                tmp_file.write(uploaded_file.getbuffer())
+                temp_file_path = tmp_file.name
+            input_text = read_file(temp_file_path)
+            os.remove(temp_file_path)
+
+            # Скрытый предпросмотр: показываем только по клику
+            with st.expander("Показать предварительный просмотр файла", expanded=False):
+                st.text_area(
+                    "Содержимое (��олько просмотр)",
+                    value=input_text,
+                    height=160,
+                    disabled=True
+                )
     else:
-        default_val = "" if clear_input else st.session_state.get("last_input_text", "")
-        input_text = st.text_area("Вставьте ваш текст здесь", height=220, value=default_val)
-        st.session_state.last_input_text = input_text
+        input_text = st.text_area("Вставьте ваш текст здесь", height=200)
 
     if input_text:
-        horizontal_rule()
-        st.write("Параметры")
-        col_lang1, col_lang2, col_meta = st.columns([1, 1, 1.2])
-        with col_lang1:
-            auto_detect = st.checkbox("Автоопределение языка", value=True)
-            if auto_detect:
-                detected = detect_language(input_text)
-                if detected in ["ru", "en", "kk"]:
-                    badge(f"Язык: {detected}", "info")
-                    src_lang = detected
-                else:
-                    badge("Не удалось однозначно определить язык", "warn")
-                    src_lang = st.selectbox("Язык текста", ["ru", "en", "kk"])
+        auto_detect = st.checkbox("Автоматически определить язык", value=True)
+        src_lang = None
+        if auto_detect:
+            detected_lang = detect_language(input_text)
+            if detected_lang in ['ru', 'en', 'kk']:
+                st.info(f"Определён язык: {detected_lang}")
+                src_lang = detected_lang
             else:
+                st.warning("Не удалось определить язык. Выберите вручную.")
                 src_lang = st.selectbox("Язык текста", ["ru", "en", "kk"])
+        else:
+            src_lang = st.selectbox("Язык текста", ["ru", "en", "kk"])
+
+        if src_lang == "ru":
+            tgt_options = ["en", "kk"]
+        elif src_lang == "en":
+            tgt_options = ["ru", "kk"]
+        else:
+            tgt_options = ["ru", "en"]
 
-        with col_lang2:
-            tgt_options = {"ru": ["en", "kk"], "en": ["ru", "kk"], "kk": ["ru", "en"]}[src_lang]
-            tgt_lang = st.selectbox("Перевести на", tgt_options)
-
-        with col_meta:
-            # Простая статистика
-            words = len(input_text.split())
-            chars = len(input_text)
-            st.metric("Символов", f"{chars:,}".replace(",", " "))
-            st.metric("Слов", f"{words:,}".replace(",", " "))
-            if file_name:
-                st.caption(f"Файл: **{file_name}**")
-
-        horizontal_rule()
-        translate_btn = st.button("🚀 Перевести", type="primary")
-        if translate_btn:
+        tgt_lang = st.selectbox("Перевод на:", tgt_options)
+
+        if st.button("Перевести"):
+            # Prevent multiple concurrent translations from same session
             if st.session_state.translation_lock:
                 st.warning("Перевод уже выполняется. Пожалуйста, дождитесь завершения.")
-            else:
-                st.session_state.translation_lock = True
+                return
+
+            # Set translation lock
+            st.session_state.translation_lock = True
+
+            try:
+                # Use the model semaphore to limit concurrent model access
+                acquired = model_semaphore.acquire(blocking=False)
+                if not acquired:
+                    st.warning("Максимальное количество параллельных моделей достигнуто. Пожалуйста, попробуйте позже.")
+                    st.session_state.translation_lock = False
+                    return
+
                 try:
-                    acquired = model_semaphore.acquire(blocking=False)
-                    if not acquired:
-                        st.warning("Максимум параллельных процессов достигнут. Попробуйте позже.")
-                    else:
-                        # Оценка прогресса: наивно по доле сгенерированного текста
-                        progress = st.progress(0)
-                        placeholder = st.empty()
-                        result = ""
+                    st.subheader("Результат перевода:")
+                    # Get the approximate size of the text to determine if chunking is needed
+                    approx_text_size = len(input_text) / 4  # rough approximation (4 chars ≈ 1 token)
+                    needs_chunking = approx_text_size > 500  # If text is likely over 500 tokens
+
+                    # Display appropriate spinner message
+                    spinner_message = "Processing text in chunks..." if needs_chunking else "Processing translation..."
 
+                    # Create a dedicated translator instance for this session
+                    from utils.tilmash_translation import TilmashTranslator
+                    # Используем GPU если включено в настройках
+                    use_gpu = getattr(st.session_state, 'use_gpu', False)
+                    translator = TilmashTranslator(use_gpu=use_gpu)
+
+                    with st.spinner(spinner_message):
                         try:
-                            # Инициализируем переводчик (учитываем GPU-параметр)
-                            translator = TilmashTranslator(use_gpu=st.session_state.get('use_gpu', False))
-
-                            approx_len = max(1, len(input_text))
-                            with st.spinner("Выполняется перевод..."):
-                                for chunk in translator.translate_streaming(input_text, src_lang, tgt_lang):
-                                    result += chunk
-                                    # Обновляем UI "по ходу"
-                                    placeholder.markdown(result)
-                                    # Обновляем прогресс до 95%, финал уже после
-                                    done_ratio = min(0.95, len(result) / approx_len)
-                                    progress.progress(done_ratio)
+                            # Use direct streaming approach with session-specific translator
+                            result = ""
+                            translation_placeholder = st.empty()
+
+                            # Stream translation
+                            for chunk in translator.translate_streaming(input_text, src_lang, tgt_lang):
+                                result += chunk
+                                translation_placeholder.markdown(result)
 
                         except Exception as e:
-                            st.error(f"Ошибка перевода: {str(e)}")
+                            st.error(f"Translation error: {str(e)}")
                             logging.error(f"Tilmash translation error: {traceback.format_exc()}")
                             result = None
 
-                        # Финализация
-                        if result:
-                            progress.progress(1.0)
-                            horizontal_rule()
-                            section_title("Результат перевода")
-                            st.markdown(result)
-
-                            # Скачать DOCX
-                            doc = Document()
-                            doc.add_paragraph(result)
-                            doc_io = io.BytesIO()
-                            doc.save(doc_io)
-                            doc_io.seek(0)
-                            st.download_button(
-                                label="⬇️ Скачать переведённый текст (.docx)",
-                                data=doc_io,
-                                file_name="translated_text.docx",
-                                mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-                                use_container_width=True
-                            )
-                        else:
-                            st.warning("Не удалось выполнить перевод.")
-
-                        # Освобождаем ресурсы модели
-                        try:
-                            if 'translator' in locals() and getattr(translator, "initialized", False):
-                                translator.unload_model()
-                        except Exception as unload_error:
-                            logging.error(f"Error unloading Tilmash model: {str(unload_error)}")
-                except Exception as outer_error:
-                    st.error(f"Unexpected error: {str(outer_error)}")
-                    logging.error(f"Unexpected error: {traceback.format_exc()}")
+                    if result:
+                        # Prepare download capability
+                        doc = Document()
+                        doc.add_paragraph(result)
+                        doc_io = io.BytesIO()
+                        doc.save(doc_io)
+                        doc_io.seek(0)
+
+                        st.download_button(
+                            label="Скачать переведённый текст (.docx)",
+                            data=doc_io,
+                            file_name="translated_text.docx",
+                            mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                        )
+                    else:
+                        st.warning("Не удалось выполнить перевод.")
+
+                    # Unload Tilmash model after use
+                    try:
+                        if translator.initialized:
+                            translator.unload_model()
+                    except Exception as unload_error:
+                        logging.error(f"Error unloading Tilmash model: {str(unload_error)}")
+                except Exception as tilmash_error:
+                    st.error(f"Tilmash model error: {str(tilmash_error)}")
+                    logging.error(f"Tilmash model error: {traceback.format_exc()}")
                 finally:
-                    if model_semaphore._value < MODEL_CONFIG["max_parallel_models"]:
-                        model_semaphore.release()
-                    st.session_state.translation_lock = False
-
-
-# ====== УДОБОЧИТАЕМОСТЬ ======
-with tab_readability:
-    section_title("Анализ удобочитаемости текста",
-                  "Поддерживаются 🇰🇿 🇷🇺 🇬🇧. Индексы: Flesch, F-K Grade, Gunning Fog, SMOG.")
-
-    r1, r2 = columns_safe([1, 2])  # удалён vertical_alignment
-    with r1:
-        read_mode = st.radio("Источник текста:", ["Загрузить файл", "Вставить текст"], horizontal=True)
-    with r2:
-        clear_read = st.button("Очистить ввод (анализ)", use_container_width=True)
-
+                    # Release the semaphore
+                    model_semaphore.release()
+            except Exception as outer_error:
+                st.error(f"Unexpected error: {str(outer_error)}")
+                logging.error(f"Unexpected error: {traceback.format_exc()}")
+            finally:
+                # Release translation lock
+                st.session_state.translation_lock = False
+
+
+def handle_readability_analysis():
+    st.header("Анализ удобочитаемости текста")
+    input_method = st.radio("Способ ввода текста:", ["Загрузить файл", "Вставить текст"])
     text = ""
-    if read_mode == "Загрузить файл":
-        uploaded_file = st.file_uploader("Выберите файл (.txt, .docx, .pdf)", type=["txt", "docx", "pdf"], key="read_upl")
+
+    if input_method == "Загрузить файл":
+        uploaded_file = st.file_uploader("Выберите файл (.txt, .docx, .pdf)", type=["txt", "docx", "pdf"])
         if uploaded_file is not None:
             suffix = os.path.splitext(uploaded_file.name)[1]
-            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp:
-                tmp.write(uploaded_file.getbuffer())
-                temp_path = tmp.name
-            text = read_file(temp_path)
-            os.remove(temp_path)
-
-            with st.expander("Предпросмотр (только чтение)", expanded=False):
-                st.text_area("Содержимое", value=text, height=160, disabled=True, key="read_preview")
+            with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as tmp_file:
+                tmp_file.write(uploaded_file.getbuffer())
+                temp_file_path = tmp_file.name
+            text = read_file(temp_file_path)
+            os.remove(temp_file_path)
+
+            # Скрытый предпросмотр: показываем только по клику
+            with st.expander("Показать предварительный просмотр файла", expanded=False):
+                st.text_area(
+                    "Содержимое (только просмотр)",
+                    value=text,
+                    height=160,
+                    disabled=True
+                )
     else:
-        default_val = "" if clear_read else st.session_state.get("last_read_text", "")
-        text = st.text_area("Вставьте текст для анализа", height=220, value=default_val, key="read_text")
-        st.session_state.last_read_text = text
+        text = st.text_area("Вставьте ваш текст здесь", height=200)
 
     if text:
-        horizontal_rule()
-        cdet, csel, cstats = st.columns([1.2, 1, 1.2])
-
-        with cdet:
-            auto_detect_r = st.checkbox("Определить язык автоматически", value=True, key="read_auto")
-            if auto_detect_r:
-                detected_lang = detect_language(text)
-                badge(f"Язык: {detected_lang}", "info")
-                lang_code = detected_lang if detected_lang in ['ru', 'en', 'kk'] else 'en'
-                if lang_code not in ['ru', 'en', 'kk']:
-                    badge("Неподдерживаемый язык — выбран en по умолчанию", "warn")
-            else:
-                lang_code = st.selectbox("Язык текста", ["ru", "en", "kk"], key="lang_select")
+        auto_detect = st.checkbox("Определить язык автоматически", value=True)
+        if auto_detect:
+            detected_lang = detect_language(text)
+            st.info(f"Определён язык: {detected_lang}")
+            lang_code = detected_lang if detected_lang in ['ru', 'en', 'kk'] else 'en'
+        else:
+            lang_code = st.selectbox("Язык текста", ["ru", "en", "kk"])
+
+        if st.button("Анализировать"):
+            # Prevent multiple concurrent analyses
+            if 'analysis_lock' in st.session_state and st.session_state.analysis_lock:
+                st.warning("Анализ уже выполняется. Пожалуйста, дождитесь завершения.")
+                return
 
-        with csel:
-            words = len(text.split())
-            chars = len(text)
-            st.metric("Символов", f"{chars:,}".replace(",", " "))
-            st.metric("Слов", f"{words:,}".replace(",", " "))
+            # Set analysis lock
+            st.session_state.analysis_lock = True
 
-        with cstats:
-            analyze_btn = st.button("🔎 Анализировать", type="primary", use_container_width=True)
+            try:
+                # Use the model semaphore for consistency with translation
+                acquired = model_semaphore.acquire(blocking=False)
+                if not acquired:
+                    st.warning("Система загружена. Пожалуйста, попробуйте позже.")
+                    st.session_state.analysis_lock = False
+                    return
 
-        if analyze_btn:
-            if st.session_state.analysis_lock:
-                st.warning("Анализ уже выполняется. Пожалуйста, дождитесь завершения.")
-            else:
-                st.session_state.analysis_lock = True
                 try:
-                    acquired = model_semaphore.acquire(blocking=False)
-                    if not acquired:
-                        st.warning("Система загружена. Попробуйте позже.")
-                    else:
-                        with st.spinner("Выполняется анализ..."):
-                            fre = flesch_reading_ease(text, lang_code)
-                            fkgl = flesch_kincaid_grade_level(text, lang_code)
-                            fog = gunning_fog_index(text, lang_code)
-                            smg = smog_index(text, lang_code)
-                            highlighted_text, complex_words_list = highlight_complex_text(text, lang_code)
-
-                        horizontal_rule()
-                        section_title("Результаты")
-                        # Компактные карточки-метрики
-                        m1, m2, m3, m4 = st.columns(4)
-                        with m1:
-                            st.markdown(
-                                f"**Flesch Reading Ease**<br>{color_code_index('Flesch Reading Ease', fre)}",
-                                unsafe_allow_html=True
-                            )
-                        with m2:
-                            st.markdown(
-                                f"**Flesch-Kincaid Grade**<br>{color_code_index('Flesch-Kincaid Grade Level', fkgl)}",
-                                unsafe_allow_html=True
-                            )
-                        with m3:
-                            st.markdown(
-                                f"**Gunning Fog**<br>{color_code_index('Gunning Fog Index', fog)}",
-                                unsafe_allow_html=True
-                            )
-                        with m4:
-                            st.markdown(
-                                f"**SMOG**<br>{color_code_index('SMOG Index', smg)}",
-                                unsafe_allow_html=True
-                            )
-
-                        horizontal_rule()
-                        with st.expander(f"Сложные слова ({len(set(complex_words_list))})", expanded=False):
-                            if complex_words_list:
-                                st.write(", ".join(sorted(set(complex_words_list))))
-                            else:
-                                st.write("Не выявлены.")
-
-                        with st.expander("Подсветка сложных фрагментов (HTML)", expanded=False):
-                            st.markdown(highlighted_text, unsafe_allow_html=True)
+                    with st.spinner("Выполняется анализ..."):
+                        fre = flesch_reading_ease(text, lang_code)
+                        fkgl = flesch_kincaid_grade_level(text, lang_code)
+                        fog = gunning_fog_index(text, lang_code)
+                        smog = smog_index(text, lang_code)
+                        highlighted_text, complex_words_list = highlight_complex_text(text, lang_code)
+
+                    st.subheader("Результаты удобочитаемости")
+                    st.markdown(
+                        f"**Индекс удобочитаемости Флеша:** {color_code_index('Flesch Reading Ease', fre)}",
+                        unsafe_allow_html=True
+                    )
+                    st.markdown(
+                        f"**Индекс Флеша-Кинкейда:** {color_code_index('Flesch-Kincaid Grade Level', fkgl)}",
+                        unsafe_allow_html=True
+                    )
+                    st.markdown(
+                        f"**Индекс тумана Ганнинга:** {color_code_index('Gunning Fog Index', fog)}",
+                        unsafe_allow_html=True
+                    )
+                    st.markdown(
+                        f"**Индекс SMOG:** {color_code_index('SMOG Index', smog)}",
+                        unsafe_allow_html=True
+                    )
+
+                    st.subheader("Сложные слова")
+                    st.write(", ".join(set(complex_words_list)))
                 finally:
-                    if model_semaphore._value < MODEL_CONFIG["max_parallel_models"]:
-                        model_semaphore.release()
-                    st.session_state.analysis_lock = False
+                    # Release the semaphore
+                    model_semaphore.release()
+            finally:
+                # Release analysis lock
+                st.session_state.analysis_lock = False
 
 
-# ====== ИНИЦ И ДИАГНОСТИКА NLTK/GPU (один раз на сессию) ======
-def _startup_once():
+def main():
     setup_nltk()
+
+    # Log the model configuration only once per session
     if 'model_config_logged' not in st.session_state:
         logging.info(f"Using model configuration: {MODEL_CONFIG}")
         st.session_state.model_config_logged = True
+
+        # Проверка доступности GPU при запуске
         try:
             import torch
             if torch.cuda.is_available():
@@ -407,13 +334,28 @@ def _startup_once():
                 logging.info("Обнаружен Apple Silicon GPU (MPS)")
             else:
                 logging.warning("GPU не обнаружен. Устанавливаем устройство на CPU")
-                logging.warning("Диагностика CUDA:")
-                logging.warning(f"torch.__version__: {getattr(__import__('torch'), '__version__', 'N/A')}")
-                if hasattr(__import__('torch').version, "cuda"):
-                    logging.warning(f"torch.version.cuda: {__import__('torch').version.cuda}")
+                if not torch.cuda.is_available():
+                    # Вывод диагностической информации
+                    logging.warning("Диагностика CUDA:")
+                    logging.warning(f"torch.__version__: {torch.__version__}")
+                    if hasattr(torch.version, "cuda"):
+                        logging.warning(f"torch.version.cuda: {torch.version.cuda}")
+                    if hasattr(torch.cuda, "is_available"):
+                        logging.warning(f"torch.cuda.is_available(): {torch.cuda.is_available()}")
         except ImportError:
             logging.warning("PyTorch не установлен, будет использован CPU")
         except Exception as e:
             logging.warning(f"Ошибка при проверке GPU: {str(e)}")
 
-_startup_once()
+    st.title("Translation & Readability Analysis")
+    st.sidebar.header("Функциональность")
+    functionality = st.sidebar.radio("Выберите режим:", ["Перевод", "Анализ удобочитаемости"])
+
+    if functionality == "Перевод":
+        handle_translation()
+    elif functionality == "Анализ удобочитаемости":
+        handle_readability_analysis()
+
+
+if __name__ == "__main__":
+    main()