Update app.py

app.py

@@ -1,229 +1,204 @@
 import os
+from datetime import datetime
+
 import gradio as gr
 from transformers import pipeline
 import pdfplumber
-
-# OCR
-try:
-    import pytesseract
-    from pdf2image import convert_from_path
-    OCR_AVAILABLE = True
-except ImportError:
-    OCR_AVAILABLE = False
-
-# DOCX / PDF экспорт
 from docx import Document
 from fpdf import FPDF
 
+# ===== НАСТРОЙКИ =====
 
-# ---------- НАСТРОЙКИ ----------
-
-# Имя файла шрифта в корне Space
+# Имя шрифта TTF, который лежит в корне Space (Files → root)
 FONT_PATH = "DejaVuSans.ttf"
+FONT_FAMILY = "DejaVu"
 
-# Глобальная модель (ленивая загрузка)
-summarizer = None
+# Максимальная длина текста в одном заходе в модель (по символам)
+# Это грубая оценка, чтобы не превышать лимит ~1024 токена у BART
+CHUNK_SIZE = 2000
 
+# Ленивая инициализация summarizer, чтобы не грузить модель при импортe
+_summarizer = None
 
-# ---------- МОДЕЛЬ ----------
 
 def get_summarizer():
-    global summarizer
-    if summarizer is None:
-        summarizer = pipeline(
+    global _summarizer
+    if _summarizer is None:
+        _summarizer = pipeline(
             "summarization",
-            model="sshleifer/distilbart-cnn-12-6"
+            model="facebook/bart-large-cnn"
         )
-    return summarizer
+    return _summarizer
 
 
-# ---------- ЧТЕНИЕ ФАЙЛА ----------
-
-def extract_pdf_text(path: str):
-    """Пытаемся вытащить текст из PDF. Если нет текста — пробуем OCR (если доступен)."""
-    text = ""
-
-    # 1) обычный текстовый PDF
-    try:
-        with pdfplumber.open(path) as pdf:
-            for page in pdf.pages:
-                chunk = page.extract_text()
-                if chunk:
-                    text += chunk + "\n"
-    except Exception as e:
-        return "", f"Ошибка при чтении PDF: {e}"
+# ===== ВСПОМОГАТЕЛЬНЫЕ ФУНКЦИИ =====
 
-    if text.strip():
-        return text, None
+def read_text_from_file(file_path: str) -> str:
+    """Читает текст из PDF или TXT."""
+    if not file_path:
+        return ""
 
-    # 2) если текста нет и OCR недоступен
-    if not OCR_AVAILABLE:
-        return "", "PDF выглядит как скан. Для OCR нужен pytesseract + pdf2image + tesseract-ocr."
+    path_lower = file_path.lower()
 
-    # 3) OCR по картинкам
-    try:
-        images = convert_from_path(path, dpi=200)
-        ocr_text = ""
-        for img in images:
-            ocr_text += pytesseract.image_to_string(img) + "\n"
-        if not ocr_text.strip():
-            return "", "OCR не смог распознать текст в этом PDF."
-        return ocr_text, None
-    except Exception as e:
-        return "", f"Ошибка OCR при обработке PDF: {e}"
+    # PDF
+    if path_lower.endswith(".pdf"):
+        text = []
+        with pdfplumber.open(file_path) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text() or ""
+                text.append(page_text)
+        return "\n".join(text)
 
+    # TXT (или любой другой текстовый)
+    with open(file_path, "rb") as f:
+        raw = f.read()
+    return raw.decode("utf-8", errors="ignore")
 
-def read_file(path: str):
-    """Чтение PDF или текстового файла по пути."""
-    if not path:
-        return "", "Файл не передан."
 
-    lower = path.lower()
+def split_into_chunks(text: str, chunk_size: int = CHUNK_SIZE):
+    """Режет длинный текст на куски по chunk_size символов."""
+    text = text.strip()
+    if len(text) <= chunk_size:
+        return [text]
 
-    if lower.endswith(".pdf"):
-        return extract_pdf_text(path)
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + chunk_size
 
-    # TXT / другие текстовые файлы
-    try:
-        with open(path, "r", encoding="utf-8", errors="ignore") as f:
-            return f.read(), None
-    except Exception as e:
-        return "", f"Ошибка при чтении TXT: {e}"
+        # стараемся резать по границе предложения/абзаца
+        if end < len(text):
+            dot_pos = text.rfind(".", start, end)
+            newline_pos = text.rfind("\n", start, end)
+            sep_pos = max(dot_pos, newline_pos)
+            if sep_pos > start + chunk_size * 0.3:
+                end = sep_pos + 1
 
+        chunks.append(text[start:end].strip())
+        start = end
 
-# ---------- ЧАНКИНГ ТЕКСТА ----------
-
-def chunk_text(text: str, max_chars: int = 2500):
-    """Режем длинный текст на куски, стара��сь обрезать по точкам."""
-    chunks = []
-    while len(text) > max_chars:
-        cut = text[:max_chars]
-        last_dot = cut.rfind(".")
-        if last_dot != -1:
-            cut = cut[:last_dot + 1]
-        chunks.append(cut)
-        text = text[len(cut):]
-    if text:
-        chunks.append(text)
-    return chunks
+    return [c for c in chunks if c]
 
 
 def summarize_long_text(text: str) -> str:
-    model = get_summarizer()
-    parts = []
-    for chunk in chunk_text(text, max_chars=2500):
-        if not chunk.strip():
+    """Суммаризирует длинный текст по частям и склеивает результат."""
+    summarizer = get_summarizer()
+    chunks = split_into_chunks(text)
+
+    summaries = []
+    for chunk in chunks:
+        # подстрахуемся от совсем коротких кусков
+        if len(chunk) < 50:
             continue
-        summary = model(
+        result = summarizer(
             chunk,
-            max_length=180,
-            min_length=60,
+            max_length=200,
+            min_length=50,
             do_sample=False
         )
-        parts.append(summary[0]["summary_text"])
-    return "\n\n".join(parts)
+        summaries.append(result[0]["summary_text"].strip())
+
+    if not summaries:
+        return "⚠️ Не удалось создать осмысленное резюме (слишком мало текста)."
 
+    return "\n\n".join(summaries)
 
-# ---------- ЭКСПОРТ В DOCX / PDF ----------
 
-def save_docx(summary: str) -> str:
+def save_docx(summary_text: str) -> str:
+    """Сохраняет резюме в DOCX и возвращает путь к файлу."""
+    filename = f"summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.docx"
     doc = Document()
-    doc.add_heading("Eroha Summarizer – Резюме документа", level=1)
-    for paragraph in summary.split("\n"):
+    doc.add_heading("Резюме документа", level=1)
+    for paragraph in summary_text.split("\n\n"):
         doc.add_paragraph(paragraph)
-    out_path = "/tmp/summary.docx"
-    doc.save(out_path)
-    return out_path
+    doc.save(filename)
+    return filename
+
+
+def save_pdf(summary_text: str) -> str | None:
+    """
+    Сохраняет резюме в PDF и возвращает путь к файлу.
+    Если шрифт не найден или не подключился — возвращает None,
+    чтобы не падать с Unicode ошибкой.
+    """
+    if not os.path.exists(FONT_PATH):
+        # Шрифт не найден — лучше вернуть None, чем падать
+        return None
 
+    filename = f"summary_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
 
-def save_pdf(summary: str) -> str:
     pdf = FPDF()
     pdf.add_page()
 
-    # Подключаем Unicode-шрифт
+    # Регистрируем Unicode-шрифт
     try:
-        pdf.add_font("DejaVu", "", FONT_PATH, uni=True)
-        pdf.set_font("DejaVu", size=12)
-    except Exception:
-        # Фоллбек – латинский Arial (кириллица может не сохраниться, но ошибок не будет)
-        pdf.set_font("Arial", size=12)
-
-    for line in summary.split("\n"):
-        try:
-            pdf.multi_cell(0, 8, line)
-        except Exception:
-            # Если шрифт не поддерживает символы – пропускаем проблемную строку
-            continue
+        pdf.add_font(FONT_FAMILY, "", FONT_PATH, uni=True)
+    except Exception as e:
+        # Если даже тут что-то пошло не так — не ломаем всё приложение
+        print(f"Ошибка подключения шрифта для PDF: {e}")
+        return None
 
-    out_path = "/tmp/summary.pdf"
-    pdf.output(out_path)
-    return out_path
+    pdf.set_font(FONT_FAMILY, size=12)
 
+    # Пишем текст резюме
+    for line in summary_text.split("\n"):
+        pdf.multi_cell(0, 8, line)
+        pdf.ln(0.5)
 
-# ---------- ОСНОВНАЯ ФУНКЦИЯ ДЛЯ GRADIO ----------
+    pdf.output(filename)
+    return filename
 
-def summarize_file(file_path: str):
-    text, err = read_file(file_path)
-    if err:
-        return f"⚠️ {err}", None, None
 
-    if not text.strip():
-        return "⚠️ Не удалось извлечь текст из файла.", None, None
+# ===== ОСНОВНАЯ ФУНКЦИЯ ДЛЯ GRADIO =====
 
-    if len(text.strip()) < 80:
-        return "⚠️ Слишком мало текста для суммаризации.", None, None
+def summarize_file(file) -> tuple[str, str | None, str | None]:
+    """
+    Основной обработчик:
+    1) читает файл,
+    2) делает суммаризацию,
+    3) сохраняет DOCX и PDF.
+    Возвращает: (текстовое резюме, путь к DOCX, путь к PDF).
+    """
+    if file is None:
+        return "⚠️ Пожалуйста, загрузите файл.", None, None
 
-    # Суммаризация с чанкингом
     try:
-        final_summary = summarize_long_text(text)
-    except Exception as e:
-        return f"⚠️ Ошибка суммаризации: {e}", None, None
+        text = read_text_from_file(file.name)
 
-    # Экспорт в DOCX / PDF
-    try:
-        docx_path = save_docx(final_summary)
-    except Exception as e:
-        docx_path = None
-        final_summary += f"\n\n[Предупреждение: ошибка сохранения DOCX: {e}]"
-
-    try:
-        pdf_path = save_pdf(final_summary)
-    except Exception as e:
-        pdf_path = None
-        final_summary += f"\n\n[Предупреждение: ошибка сохранения PDF: {e}]"
+        if len(text.strip()) < 50:
+            return "⚠️ Слишком короткий текст для суммаризации.", None, None
 
-    return final_summary, docx_path, pdf_path
+        summary_text = summarize_long_text(text)
 
+        docx_path = save_docx(summary_text)
+        pdf_path = save_pdf(summary_text)
 
-# ---------- ИНТЕРФЕЙС GRADIO ----------
+        # Если PDF не создался (нет шрифта) — просто не отдаём файл
+        return summary_text, docx_path, pdf_path
 
-with gr.Blocks() as demo:
-    gr.Markdown("# Eroha Summarizer 🧠")
-    gr.Markdown(
-        "Загрузите документ (**PDF или TXT**), и модель создаст краткое резюме "
-        "с возможностью скачивания **DOCX** и **PDF**."
-    )
-
-    with gr.Row():
-        file_input = gr.File(
-            type="filepath",
-            label="Загрузите файл (.pdf или .txt)"
-        )
-        with gr.Column():
-            summary_output = gr.Textbox(
-                label="Результат суммаризации",
-                lines=20
-            )
-            docx_output = gr.File(label="Скачать DOCX")
-            pdf_output = gr.File(label="Скачать PDF")
-
-    submit_btn = gr.Button("Запустить суммаризацию")
-
-    submit_btn.click(
-        fn=summarize_file,
-        inputs=file_input,
-        outputs=[summary_output, docx_output, pdf_output]
-    )
+    except Exception as e:
+        # Логируем в консоль Space, а пользователю — аккуратное сообщение
+        print(f"Ошибка при суммаризации: {e}")
+        return f"❌ Ошибка суммаризации: {e}", None, None
+
+
+# ===== ИНТЕРФЕЙС GRADIO =====
+
+demo = gr.Interface(
+    fn=summarize_file,
+    inputs=gr.File(label="Загрузите файл (.pdf или .txt)"),
+    outputs=[
+        gr.Textbox(label="Результат суммаризации"),
+        gr.File(label="Скачать DOCX"),
+        gr.File(label="Скачать PDF"),
+    ],
+    title="Eroha Summarizer 🧠",
+    description=(
+        "Загрузите документ (PDF или TXT), модель создаст краткое резюме. "
+        "Результат можно скачать в DOCX и PDF. Для корректного PDF нужен файл шрифта "
+        f"{FONT_PATH} в корне Space."
+    ),
+)
 
 if __name__ == "__main__":
     demo.launch()