v3.1.0: разбить app.py на routes/main,parse,misc — 52 строки вместо 330

site/routes/__init__.py

@@ -0,0 +1 @@
+"""routes/__init__.py — Пакет маршрутов."""

site/routes/main.py

@@ -0,0 +1,156 @@
+"""routes/main.py — Главные маршруты: загрузка файлов, просмотр договора."""
+
+import datetime
+from flask import render_template, request, jsonify
+import db
+import mimeutil
+
+
+def _save_file_to_db(filename, file_bytes, mime, contract_id, conn=None):
+    """
+    Сохранить загруженный файл в БД.
+
+    Создаёт запись в documents и привязывает к договору через supplements.
+    Если conn передан — используется одно соединение для всей транзакции.
+    Иначе — каждый запрос в своём соединении.
+
+    Возвращает doc_id или None при ошибке.
+    """
+    if conn:
+        # Транзакционный режим: все операции в одном соединении
+        cur = conn.cursor()
+        cur.execute(
+            "INSERT INTO documents (filename, mime_type, original_bytes, status) VALUES (%s,%s,%s,'uploaded')",
+            (filename, mime, file_bytes),
+        )
+        cur.execute(
+            "SELECT id FROM documents WHERE filename=%s AND status='uploaded' ORDER BY created_at DESC LIMIT 1",
+            (filename,),
+        )
+        row = cur.fetchone()
+        doc_id = row[0] if row else None
+        if doc_id:
+            cur.execute(
+                "INSERT INTO supplements (contract_id, document_id, type) VALUES (%s,%s,'initial')",
+                (str(contract_id), str(doc_id)),
+            )
+        conn.commit()
+        cur.close()
+        return doc_id
+
+    # Автономный режим: каждый вызов db.execute сам управляет соединением
+    db.execute(
+        "INSERT INTO documents (filename, mime_type, original_bytes, status) VALUES (%s,%s,%s,'uploaded')",
+        (filename, mime, file_bytes),
+    )
+    doc, _ = db.query_one(
+        "SELECT id FROM documents WHERE filename=%s AND status='uploaded' ORDER BY created_at DESC LIMIT 1",
+        (filename,),
+    )
+    doc_id = doc["id"] if doc else None
+    if doc_id:
+        db.execute(
+            "INSERT INTO supplements (contract_id, document_id, type) VALUES (%s,%s,'initial')",
+            (str(contract_id), str(doc_id)),
+        )
+    return doc_id
+
+
+def index():
+    """
+    GET  /              — страница загрузки
+    GET  /?id=<cid>     — просмотр договора
+    POST /              — приём файлов (multipart/form-data)
+    """
+    if request.method == "POST":
+        return _upload_files()
+    cid = request.args.get("id")
+    if cid:
+        return _show_contract(cid)
+    return render_template("upload.html")
+
+
+def _upload_files():
+    """
+    Принять файлы через multipart/form-data.
+
+    Поле формы: 'files' (один или несколько).
+    ?cid=X — добавить файлы к существующему договору.
+    Если cid не указан — создаётся новый договор.
+    """
+    files = request.files.getlist("files")
+    if not files or not any(f.filename for f in files):
+        return jsonify({"error": "Нет файлов"}), 400
+
+    cid = request.args.get("cid")
+
+    if cid:
+        # Добавляем к существующему договору
+        contract_id = cid
+    else:
+        # Создаём новый договор
+        conn, err = db.connect()
+        if err:
+            return jsonify({"error": f"БД: {err}"}), 500
+        cur = conn.cursor()
+        cur.execute(
+            "INSERT INTO contracts (number, client) VALUES (%s, %s) RETURNING id",
+            ("б/н " + datetime.datetime.now().strftime("%Y%m%d-%H%M"), ""),
+        )
+        contract_id = cur.fetchone()[0]
+        conn.commit()
+        cur.close()
+        db.put_conn(conn)
+
+    # Сохраняем каждый файл
+    for f in files:
+        if not f.filename:
+            continue
+        filename = f.filename
+        mime = mimeutil.guess_mime(filename) or f.content_type or "application/octet-stream"
+        _save_file_to_db(filename, f.read(), mime, str(contract_id))
+
+    return jsonify({"contract_id": str(contract_id)})
+
+
+def _show_contract(cid):
+    """
+    Показать страницу договора со списком файлов и кнопкой «Парсинг».
+
+    Загружает: информацию о договоре, список допников/файлов,
+    существующие строки спецификации (если уже извлечены).
+    """
+    contract, _ = db.query_one(
+        "SELECT id, number, created_at FROM contracts WHERE id = %s",
+        (cid,),
+    )
+    if not contract:
+        return render_template("upload.html", error="Договор не найден")
+
+    # Все файлы, привязанные к договору
+    supps, _ = db.query(
+        "SELECT s.id, s.created_at, d.filename, d.status, d.parsed_text IS NOT NULL as has_text "
+        "FROM supplements s JOIN documents d ON s.document_id = d.id "
+        "WHERE s.contract_id = %s ORDER BY s.created_at",
+        (cid,),
+    )
+    supp_list = [dict(zip(supps["columns"], r)) for r in supps["rows"]] if supps else []
+
+    # Уже извлечённые строки спецификации
+    rows_res, _ = db.query(
+        "SELECT sr.row_num, sr.name, sr.price, sr.qty, sr.sum, sr.date_start "
+        "FROM spec_rows sr JOIN supplements s ON sr.supplement_id = s.id "
+        "WHERE s.contract_id = %s ORDER BY sr.row_num",
+        (cid,),
+    )
+    all_rows = [dict(zip(rows_res["columns"], r)) for r in rows_res["rows"]] if rows_res else []
+
+    # Файлы, готовые к парсингу
+    unprocessed = [s for s in supp_list if s["status"] in ("uploaded", "parsed")]
+
+    return render_template("upload.html",
+        contract=contract,
+        supplements=supp_list,
+        all_rows=all_rows,
+        unprocessed=unprocessed,
+    )

site/routes/misc.py

@@ -0,0 +1,33 @@
+"""routes/misc.py — Служебные маршруты: health, логи."""
+
+from flask import jsonify
+
+# Логи в памяти — здесь чтобы routes/main.py тоже мог писать
+import time as _time
+_log_memory = []
+
+
+def log(step, detail=""):
+    """
+    Записать шаг в оперативную память (мгновенно, без БД).
+
+    Используется для отладки. Лимит: 500 записей, старые вытесняются.
+    """
+    _log_memory.append({"step": step, "detail": str(detail)[:500], "time": _time.time()})
+    if len(_log_memory) > 500:
+        _log_memory.pop(0)
+
+
+def health():
+    """
+    GET /health — проверка живости.
+    Всегда возвращает 200 OK.
+    """
+    return "OK", 200, {"Content-Type": "text/plain"}
+
+
+def logs():
+    """
+    GET /logs — последние 50 записей отладочного лога.
+    """
+    return jsonify(_log_memory[-50:])

site/routes/parse.py

@@ -0,0 +1,193 @@
+"""routes/parse.py — SSE-парсинг: потоковый разбор документов договора."""
+
+import json as _json
+import time as _time
+import io as _io
+import zipfile as _zipfile
+import base64 as _b64
+
+from flask import Response
+
+import db
+import parser as parser_mod
+import textify
+import mimeutil
+
+
+def parse(cid):
+    """
+    GET /parse/<cid> — Server-Sent Events поток.
+
+    Для каждого файла договора:
+      1. Достаёт байты из БД (original_bytes или original_b64)
+      2. Парсит через parser.parse()
+      3. Сохраняет parsed_text + elements_json в БД
+      4. Отправляет SSE-сообщения: file_start → file_done → summary
+
+    ZIP-файлы распаковываются, каждый внутренний файл парсится отдельно.
+    """
+    def generate():
+        start_time = _time.time()
+        total_bytes = 0
+        files_processed = 0
+
+        # ── Получить все файлы договора ─────────────────────
+        supps, _ = db.query(
+            "SELECT s.id, d.id as doc_id, d.filename, d.mime_type, "
+            "LENGTH(d.original_bytes) as file_size "
+            "FROM supplements s JOIN documents d ON s.document_id = d.id "
+            "WHERE s.contract_id = %s",
+            (cid,),
+        )
+        if not supps:
+            yield f"data: {_json.dumps({'type': 'error', 'message': 'Нет файлов'})}\n\n"
+            return
+
+        supp_rows = [dict(zip(supps["columns"], r)) for r in supps["rows"]]
+
+        # ── Вспомогательная: собрать результат парсинга ─────
+        def _file_done(name, elapsed, elements, errors, text):
+            """
+            Сформировать SSE-сообщение file_done со статистикой:
+            количество параграфов, таблиц, строк таблиц, заголовки таблиц.
+            """
+            paragraphs = sum(1 for e in elements if e.get("type") == "paragraph")
+            tables = sum(1 for e in elements if e.get("type") == "table")
+            table_rows = sum(len(e.get("rows", [])) for e in elements if e.get("type") == "table")
+            table_headers = [
+                e["rows"][0] if e.get("rows") else []
+                for e in elements if e.get("type") == "table"
+            ]
+            return {
+                "type": "file_done",
+                "name": name,
+                "time_s": elapsed,
+                "elements": len(elements),
+                "paragraphs": paragraphs,
+                "tables": tables,
+                "table_rows": table_rows,
+                "table_headers": table_headers,
+                "errors": errors,
+                "text_len": len(text) if text else 0,
+                "text_preview": text[:200] if text else "",
+            }
+
+        # ── Основной цикл: каждый файл ──────────────────────
+        for s in supp_rows:
+            # Пропустить уже распарсенные
+            existing, _ = db.query(
+                "SELECT 1 FROM documents WHERE id = %s AND status IN ('parsed', 'expanded')",
+                (s["doc_id"],),
+            )
+            if existing and existing["rows"]:
+                continue
+
+            file_start = _time.time()
+            file_bytes = s.get("file_size", 0) or 0
+            total_bytes += file_bytes
+
+            # SSE: начало обработки файла
+            yield f"data: {_json.dumps({'type': 'file_start', 'name': s['filename'], 'bytes': file_bytes})}\n\n"
+
+            # ── Получить байты файла ────────────────────────
+            doc, _ = db.query_one(
+                "SELECT original_bytes, original_b64 FROM documents WHERE id = %s",
+                (s["doc_id"],),
+            )
+            raw = doc.get("original_bytes") if doc else None
+            b64 = doc.get("original_b64") if doc else None
+
+            if raw:
+                # Обычный файл: original_bytes
+                file_data = bytes(raw) if isinstance(raw, memoryview) else raw
+            elif b64:
+                # Старый формат: base64
+                file_data = _b64.b64decode(b64)
+            else:
+                yield f"data: {_json.dumps({'type': 'file_error', 'name': s['filename'], 'error': 'Нет данных'})}\n\n"
+                continue
+
+            # ── ZIP: распаковать и парсить каждый файл ──────
+            if s["mime_type"] == "application/zip":
+                zip_names = []
+                try:
+                    with _zipfile.ZipFile(_io.BytesIO(file_data)) as zf:
+                        for zname in zf.namelist():
+                            if zname.endswith("/"):
+                                continue  # пропускаем папки
+
+                            zdata = zf.read(zname)
+                            zmime = mimeutil.guess_mime(zname) or "application/octet-stream"
+
+                            # Только PDF и Word внутри ZIP
+                            if zmime not in (
+                                "application/pdf",
+                                "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+                                "application/msword",
+                            ):
+                                continue
+
+                            zip_names.append(zname)
+
+                            # Сохранить как отдельный документ
+                            db.execute(
+                                "INSERT INTO documents (filename, mime_type, original_bytes, status) VALUES (%s,%s,%s,'uploaded')",
+                                (zname, zmime, zdata),
+                            )
+                            zdoc, _ = db.query_one(
+                                "SELECT id FROM documents WHERE filename = %s ORDER BY created_at DESC LIMIT 1",
+                                (zname,),
+                            )
+                            zdoc_id = zdoc["id"] if zdoc else None
+                            if zdoc_id:
+                                db.execute(
+                                    "INSERT INTO supplements (contract_id, document_id, type) VALUES (%s,%s,'initial')",
+                                    (cid, str(zdoc_id)),
+                                )
+
+                            # Парсинг внутреннего файла
+                            zf_start = _time.time()
+                            total_bytes += len(zdata)
+                            yield f"data: {_json.dumps({'type': 'file_start', 'name': zname, 'bytes': len(zdata)})}\n\n"
+
+                            try:
+                                zpr = parser_mod.parse(zdata, zmime)
+                                zelements = zpr.get("elements", [])
+                                ztext = textify.to_text(zelements) if zelements else ""
+                                db.execute(
+                                    "UPDATE documents SET parsed_text = %s, elements_json = %s, status = 'parsed' WHERE id = %s",
+                                    (ztext, _json.dumps(zelements, ensure_ascii=False), str(zdoc_id)),
+                                )
+                                zelapsed = round(_time.time() - zf_start, 2)
+                                files_processed += 1
+                                yield f"data: {_json.dumps(_file_done(zname, zelapsed, zelements, zpr.get('errors', []), ztext))}\n\n"
+                            except Exception as e:
+                                yield f"data: {_json.dumps({'type': 'file_error', 'name': zname, 'error': str(e)})}\n\n"
+
+                except Exception as e:
+                    yield f"data: {_json.dumps({'type': 'file_error', 'name': s['filename'], 'error': 'ZIP: ' + str(e)})}\n\n"
+
+                # Пометить ZIP как expanded
+                db.execute("UPDATE documents SET status = 'expanded' WHERE id = %s", (s["doc_id"],))
+                yield f"data: {_json.dumps({'type': 'zip_expanded', 'name': s['filename'], 'count': len(zip_names)})}\n\n"
+
+            else:
+                # ── Обычный файл (PDF/DOCX) ─────────────────
+                pr = parser_mod.parse(file_data, s["mime_type"])
+                elements = pr.get("elements", [])
+                text = textify.to_text(elements) if elements else ""
+
+                # Сохранить результат в БД
+                db.execute(
+                    "UPDATE documents SET parsed_text = %s, elements_json = %s, status = 'parsed' WHERE id = %s",
+                    (text, _json.dumps(elements, ensure_ascii=False), str(s["doc_id"])),
+                )
+                elapsed = round(_time.time() - file_start, 2)
+                files_processed += 1
+                yield f"data: {_json.dumps(_file_done(s['filename'], elapsed, elements, pr.get('errors', []), text))}\n\n"
+
+        # ── Итоговое сообщение ──────────────────────────────
+        total_time = round(_time.time() - start_time, 2)
+        yield f"data: {_json.dumps({'type': 'summary', 'total_time_s': total_time, 'total_bytes': total_bytes, 'files_processed': files_processed})}\n\n"
+
+    return Response(generate(), mimetype="text/event-stream")