Update app.py

app.py

@@ -1,370 +1,393 @@
+import os
+# Говорим системе игнорировать прокси для локального адреса
+os.environ['NO_PROXY'] = '127.0.0.1,localhost'
+
 import gradio as gr
 import pandas as pd
 import pdfplumber
-import os
 import tempfile
 import re
 from datetime import datetime
 from reportlab.pdfgen import canvas
 from reportlab.lib.pagesizes import A4
-from reportlab.lib import colors
-# Импорты для шрифтов и форм
 from reportlab.pdfbase import pdfmetrics
 from reportlab.pdfbase.ttfonts import TTFont
+from reportlab.lib import colors
 
-# ========== АВТОРИЗАЦИЯ ==========
-AUTH_USERNAME = "admin"
-AUTH_PASSWORD = "12345"
-# =================================
-
-print("=" * 40)
-print(f"App Start: {datetime.now()}")
-print(f"Gradio: {gr.__version__}")
-print("=" * 40)
-
+# --- ЛОГИКА (Ваш код, без изменений) ---
 
 class KDChecker:
     def __init__(self):
         self.excel_db = pd.DataFrame()
         self.cabinet_list = []
         self.known_docs = ["Э3", "В4", "ПЭ3", "ВО", "ТЭ5", "СБ", "С5", "ОЛ", "Э1", "Э4", "Э7", "Д3", "Э6"]
-        
-        # === ШРИФТЫ ===
-        self.font_name = 'Helvetica' 
-        try:
-            font_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "arial.ttf")
-            if os.path.exists(font_path):
-                pdfmetrics.registerFont(TTFont('Arial', font_path))
-                self.font_name = 'Arial'
-                print(f"✅ Шрифт загружен: {font_path}")
-            else:
-                print(f"⚠️ Шрифт не найден (ищем {font_path})")
-        except Exception as e:
-            print(f"❌ Ошибка шрифта: {e}")
 
-    def load_excel_db(self, excel_file):
-        if excel_file is None:
-            return "❌ Файл не выбран", gr.update(choices=[], value=None)
-        
-        excel_path = excel_file if isinstance(excel_file, str) else getattr(excel_file, 'name', str(excel_file))
-        
-        if not os.path.exists(excel_path):
-            return f"❌ Файл не найден", gr.update(choices=[], value=None)
+    def load_excel_db(self, excel_path):
+        print(f"--- Загрузка Excel: {excel_path} ---")
+        if excel_path is None:
+            return "Файл не выбран", gr.update(choices=[], value=None)
 
         all_data = []
+        sheets_log = []
 
         try:
-            xls = pd.read_excel(excel_path, sheet_name=None, header=None, engine='openpyxl')
+            xls = pd.read_excel(excel_path, sheet_name=None, header=None)
 
             for sheet_name, df_raw in xls.items():
-                header_row = -1
-                cab_col = -1
-                rem_col = -1
+                # print(f"Обработка листа: {sheet_name}") # Скрыл спам в консоль
+                header_row_index = -1
+                cab_col_idx = -1
+                rem_col_idx = -1
 
-                # Ищем заголовки
                 for i in range(min(20, len(df_raw))):
-                    row_vals = [str(x).lower().strip() for x in df_raw.iloc[i].values]
-                    for idx, val in enumerate(row_vals):
-                        if "шкаф" in val or "cabinet" in val:
-                            cab_col = idx
-                        if "примечание" in val or "remark" in val:
-                            rem_col = idx
-                    if cab_col != -1 and rem_col != -1:
-                        header_row = i
+                    row_values = [str(x).lower().strip() for x in df_raw.iloc[i].values]
+                    c_idx = -1
+                    r_idx = -1
+                    for idx, val in enumerate(row_values):
+                        if "шкаф" in val or "cabinet" in val: c_idx = idx
+                        if "примечание" in val or "remark" in val: r_idx = idx
+                    if c_idx != -1 and r_idx != -1:
+                        header_row_index = i
+                        cab_col_idx = c_idx
+                        rem_col_idx = r_idx
                         break
 
-                if header_row != -1:
-                    df = pd.read_excel(excel_path, sheet_name=sheet_name, header=header_row, engine='openpyxl')
-                    # Проверяем индексы еще раз
-                    if cab_col < len(df.columns) and rem_col < len(df.columns):
-                        df_sub = df.iloc[:, [cab_col, rem_col]]
-                        df_sub.columns = ["Cabinet", "Remark"]
-                        df_sub["Cabinet"] = df_sub["Cabinet"].ffill()
-                        df_sub = df_sub.dropna(subset=["Remark"]).astype(str)
-                        df_sub["Cabinet_Clean"] = df_sub["Cabinet"].apply(
-                            lambda x: x.strip().replace(" ", "").replace("\n", "").replace("\r", "")
-                        )
-                        all_data.append(df_sub)
+                if header_row_index != -1:
+                    df = pd.read_excel(excel_path, sheet_name=sheet_name, header=header_row_index)
+                    df_subset = df.iloc[:, [cab_col_idx, rem_col_idx]]
+                    df_subset.columns = ["Cabinet", "Remark"]
+                    df_subset["Cabinet"] = df_subset["Cabinet"].ffill()
+                    df_subset = df_subset.dropna(subset=["Remark"]).astype(str)
+                    df_subset["Cabinet_Clean"] = df_subset["Cabinet"].apply(
+                        lambda x: x.strip().replace(" ", "").replace("\n", "").replace("\r", "")
+                    )
+                    all_data.append(df_subset)
+                    sheets_log.append(f"'{sheet_name}': {len(df_subset)}")
 
             if not all_data:
-                return "❌ Структура Excel не распознана", gr.update(choices=[], value=None)
+                return "❌ Ошибка: Не найдены заголовки 'Шкаф' и 'Примечание'.", gr.update(choices=[], value=None)
 
             self.excel_db = pd.concat(all_data, ignore_index=True)
             self.cabinet_list = sorted(self.excel_db["Cabinet"].unique().tolist())
-            
-            msg = f"✅ База загружена!\nВсего записей: {len(self.excel_db)}\nШкафов: {len(self.cabinet_list)}"
-            return msg, gr.update(choices=self.cabinet_list, value=None)
+
+            print(f"Excel загружен. Всего строк: {len(self.excel_db)}")
+            msg = f"✅ База загружена!\nЗаписей: {len(self.excel_db)}\nЛисты: {', '.join(sheets_log)}"
+            return msg, gr.update(choices=self.cabinet_list, value=None, interactive=True)
 
         except Exception as e:
-            return f"❌ Ошибка Excel: {e}", gr.update(choices=[], value=None)
+            print(f"Ошибка Excel: {e}")
+            return f"❌ Ошибка: {e}", gr.update(choices=[], value=None)
 
     def extract_text(self, pdf_path):
+        text = ""
         try:
-            text = ""
             with pdfplumber.open(pdf_path) as pdf:
                 for page in pdf.pages:
                     text += (page.extract_text() or "") + "\n"
-            return text
-        except:
-            return ""
+        except Exception as e:
+            print(f"Ошибка чтения PDF {pdf_path}: {e}")
+        return text
 
-    def find_decimal_numbers(self, text):
+    def find_all_decimal_numbers(self, text):
         pattern = r"(РЛТ|ЛДАР|ВНАР|ШТМ)[\s\.]*\d{1}[\s\.]*\d{3}[\s\.]*[А-ЯA-Z]{1,4}[\s\.]*\d{3}(-[\d]+)?"
         matches = []
-        for m in re.finditer(pattern, text):
-            clean = m.group(0).replace(" ", "").replace("\n", "")
-            if clean not in matches:
-                matches.append(clean)
+        for match in re.finditer(pattern, text):
+            clean_num = match.group(0).replace(" ", "").replace("\n", "")
+            if clean_num not in matches:
+                matches.append(clean_num)
         return matches
 
     def determine_doc_type(self, filename):
         fname = filename.upper()
-        doc_map = {
-            "С2": ["С2"], "ПЭ3": ["ПЭ3", "ПЕРЕЧЕНЬ"], "Э3": ["Э3", "СХЕМА"],
-            "Э4": ["Э4"], "В4": ["В4", "СПЕЦИФИКАЦИЯ"], "ВО": ["ВО", "Э7", "ГАБАРИТ"],
-            "ТЭ5": ["ТЭ5", "ТАБЛИЦА"], "СБ": ["СБ"], "С5": ["С5"], "ОЛ": ["ОЛ"],
-            "Э1": ["Э1"], "Э6": ["Э6", "ЗАЗЕМЛЕНИЯ"], "Д3": ["Д3", "МОНТАЖ"]
-        }
-        for doc_type, patterns in doc_map.items():
-            if any(p in fname for p in patterns):
-                return doc_type
+        if "С2" in fname: return "С2"
+        if "ПЭ3" in fname or "ПЕРЕЧЕНЬ" in fname: return "ПЭ3"
+        if "Э3" in fname or "СХЕМА ЭЛЕКТРИЧЕСКАЯ" in fname: return "Э3"
+        if "Э4" in fname: return "Э4"
+        if "В4" in fname or "СПЕЦИФИКАЦИЯ" in fname: return "В4"
+        if "ВО" in fname or "Э7" in fname or "ГАБАРИТ" in fname: return "ВО"
+        if "ТЭ5" in fname or "ТАБЛИЦА" in fname: return "ТЭ5"
+        if "СБ" in fname: return "СБ"
+        if "С5" in fname: return "С5"
+        if "ОЛ" in fname: return "ОЛ"
+        if "Э1" in fname: return "Э1"
+        if "Э6" in fname or "ЗАЗЕМЛЕНИЯ" in fname: return "Э6"
+        if "Д3" in fname or "МОНТАЖ" in fname: return "Д3"
         return "UNKNOWN"
 
-    def get_remarks(self, cabinet_key, is_clean=True):
+    def get_remarks(self, cabinet_key, is_clean_key=True):
         if self.excel_db.empty: return {}
-        
-        if is_clean:
+        if is_clean_key:
             target = cabinet_key.replace(" ", "")
             mask = self.excel_db['Cabinet_Clean'].str.contains(re.escape(target), case=False, na=False)
         else:
             mask = self.excel_db['Cabinet'] == cabinet_key
 
         rows = self.excel_db[mask]
+        if rows.empty: return {}
         parsed = {}
-        for remark in rows['Remark']:
-            text = str(remark)
-            text = re.sub(r'(\d+)\.([А-ЯA-Z])', r'\1. \2', text)
-            items = re.split(r'(?:^|\n)\s*(?=\d+[\.\)])', text)
-            
+        for remark_cell in rows['Remark']:
+            cell_text = str(remark_cell)
+            cell_text = re.sub(r'(\d+)\.([А-ЯA-Z])', r'\1. \2', cell_text)
+            items = re.split(r'(?:^|\n)\s*(?=\d+[\.\)])', cell_text)
             for item in items:
                 if len(item) < 3: continue
                 clean_item = item.strip()
-                no_num = re.sub(r'^\d+[\.\)]\s*', '', clean_item)
-                pattern = r'^(?:Документ\s+|В\s+)?([А-ЯA-Z0-9\s,\(\)\-]+?)(?:[\.\:\-]|\s+)(.*)'
-                match = re.match(pattern, no_num, re.IGNORECASE | re.DOTALL)
-                
-                docs = []
+                clean_item_no_num = re.sub(r'^\d+[\.\)]\s*', '', clean_item)
+                doc_pattern = r'^(?:Документ\s+|В\s+)?([А-ЯA-Z0-9\s,\(\)\-]+?)(?:[\.\:\-]|\s+)(.*)'
+                match = re.match(doc_pattern, clean_item_no_num, re.IGNORECASE | re.DOTALL)
+                detected_docs = []
                 final_text = clean_item
                 if match:
-                    potential = match.group(1).upper()
-                    cleaned = potential.replace("(", " ").replace(")", " ").replace(",", " ")
-                    parts = cleaned.split()
-                    valid = [p for p in parts if p in self.known_docs]
-                    if valid:
-                        docs = valid
+                    potential_docs_str = match.group(1).upper()
+                    cleaned_codes = potential_docs_str.replace("(", " ").replace(")", " ").replace(",", " ")
+                    parts = cleaned_codes.split()
+                    valid_parts = [p for p in parts if p in self.known_docs]
+                    if valid_parts:
+                        detected_docs = valid_parts
                         final_text = match.group(2).strip()
-                
-                if not docs: docs = ["ALL"]
-                for d in docs:
-                    if d not in parsed: parsed[d] = []
-                    parsed[d].append(final_text)
+                if not detected_docs: detected_docs = ["ALL"]
+                for doc in detected_docs:
+                    if doc not in parsed: parsed[doc] = []
+                    parsed[doc].append(final_text)
         return parsed
 
-    def check_files(self, files, manual_cabinet):
-        if not files: return "⚠️ Загрузите PDF", None
-        if self.excel_db.empty: return "⚠️ Загрузите базу Excel", None
-
-        file_paths = [f if isinstance(f, str) else getattr(f, 'name', str(f)) for f in files]
+    def check_files(self, files, manual_cabinet, progress=gr.Progress()):
+        print("\n--- Начало проверки ---")
+        if not files: return "Файлы не загружены", None
+        if self.excel_db.empty: return "Сначала загрузите Excel базу!", None
 
+        checklist = {}
         detected_cabinet = "Не определен"
-        method = ""
+        found_by_method = ""
         is_manual = False
 
         if manual_cabinet and manual_cabinet.strip():
             detected_cabinet = manual_cabinet
-            method = "manual"
+            found_by_method = "manual"
             is_manual = True
         else:
-            all_text = "".join(self.extract_text(fp) for fp in file_paths)
-            numbers = self.find_decimal_numbers(all_text)
-            db_keys = set(self.excel_db["Cabinet_Clean"].tolist())
-
-            for num in numbers:
-                if num in db_keys:
-                    detected_cabinet = num
-                    method = "number"
+            all_pdf_text = ""
+            for file_path in progress.tqdm(files, desc="Чтение PDF"):
+                # print(f"Читаю: {os.path.basename(file_path)}")
+                all_pdf_text += self.extract_text(file_path) + "\n"
+
+            pdf_numbers = self.find_all_decimal_numbers(all_pdf_text)
+            print(f"Найдено номеров: {pdf_numbers}")
+
+            db_clean_keys = set(self.excel_db["Cabinet_Clean"].tolist())
+
+            for cand in pdf_numbers:
+                if cand in db_clean_keys:
+                    detected_cabinet = cand
+                    found_by_method = "number"
                     break
 
             if detected_cabinet == "Не определен":
-                for cab in self.excel_db["Cabinet"].unique():
-                    parts = [n.strip() for n in cab.split(',')]
-                    for part in parts:
-                        if len(part) >= 5 and part.lower() in all_text.lower():
-                            detected_cabinet = cab
-                            method = "name"
+                unique_cabinets = self.excel_db["Cabinet"].unique()
+                for cab_name in unique_cabinets:
+                    sub_names = [n.strip() for n in cab_name.split(',')]
+                    for sub_name in sub_names:
+                        if len(sub_name) < 5: continue
+                        if sub_name.lower() in all_pdf_text.lower():
+                            detected_cabinet = cab_name
+                            found_by_method = "name"
                             break
-                    if method: break
+                    if found_by_method == "name": break
+
+        print(f"Определен шкаф: {detected_cabinet}")
 
         if detected_cabinet == "Не определен":
-            return "⚠️ Шкаф не определён. Выберите вручную в списке слева.", None
+            return f"⚠️ Шкаф не опознан автоматически.\nВыберите шкаф вручную.", None
+
+        is_clean_search = (found_by_method == "number")
+        remarks = self.get_remarks(detected_cabinet, is_clean_key=is_clean_search)
 
-        remarks = self.get_remarks(detected_cabinet, is_clean=(method == "number"))
         if not remarks:
-            return f"✅ Для '{detected_cabinet}' замечаний не найдено.", None
+            return f"⚠️ Для шкафа '{detected_cabinet}' нет замечаний в базе.", None
 
-        checklist = {}
-        for fp in file_paths:
-            fname = os.path.basename(fp)
+        processed_count = 0
+        for file_path in files:
+            fname = os.path.basename(file_path)
             dtype = self.determine_doc_type(fname)
-            tasks = remarks.get(dtype, []) + (remarks.get("ALL", []) if dtype != "С2" else [])
+            tasks = []
+            if dtype in remarks: tasks.extend(remarks[dtype])
+            if "ALL" in remarks and dtype != "С2": tasks.extend(remarks["ALL"])
             if tasks:
                 checklist[fname] = list(dict.fromkeys(tasks))
+            processed_count += 1
+
+        pdf_title = detected_cabinet
+        if is_manual: pdf_title += " (Выбор вручную)"
 
-        title = detected_cabinet + (" (ручной)" if is_manual else "")
-        
+        print("Генерация PDF...")
         try:
-            pdf_path = self.create_pdf(title, checklist)
+            pdf = self.create_pdf(pdf_title, checklist)
         except Exception as e:
-            return f"❌ Ошибка PDF: {e}", None
+            print(f"ОШИБКА PDF: {e}")
+            return f"Ошибка создания PDF: {e}", None
 
         total = sum(len(v) for v in checklist.values())
-        return f"✅ Готово!\nШкаф: {detected_cabinet}\nМетод: {method}\nЗамечаний: {total}", pdf_path
+        method_str = "Ручной выбор" if is_manual else ("По номеру" if is_clean_search else "По имени")
+
+        return f"✅ Готово!\n📂 Шкаф: {detected_cabinet}\n🔍 Метод: {method_str}\n📄 Файлов: {processed_count}\n🚩 Замечаний: {total}", pdf
 
     def create_pdf(self, cabinet, data):
-        path = os.path.join(tempfile.gettempdir(), "CheckList.pdf")
+        fname = f"CheckList_Result.pdf"
+        path = os.path.join(tempfile.gettempdir(), fname)
         c = canvas.Canvas(path, pagesize=A4)
-        w, h = A4
-        font = self.font_name
+        form = c.acroForm
+        width, height = A4
+
+        # --- АВТОПОИСК ШРИФТА WINDOWS ---
+        font_name = 'Helvetica'
+        sys_font = "C:\\Windows\\Fonts\\arial.ttf"
+        local_font = "arial.ttf"
 
-        y = h - 50
-        c.setFont(font, 16)
-        c.drawString(50, y, "CHECK-LIST")
+        try:
+            # Ищем шрифт сначала рядом со скриптом, потом в системе
+            if os.path.exists(local_font):
+                pdfmetrics.registerFont(TTFont('Arial', local_font))
+                font_name = 'Arial'
+            elif os.path.exists(sys_font):
+                pdfmetrics.registerFont(TTFont('Arial', sys_font))
+                font_name = 'Arial'
+        except:
+            pass # Если не нашли, будет Helvetica
+
+        y = height - 50
+        c.setFont(font_name, 16)
+        c.drawString(50, y, f"ЧЕК-ЛИСТ ПРОВЕРКИ КД")
         y -= 25
-        c.setFont(font, 12)
-        cab_title = cabinet[:60] + "..." if len(cabinet) > 60 else cabinet
-        c.drawString(50, y, f"Cabinet: {cab_title}")
-        c.drawString(450, y, datetime.now().strftime('%d.%m.%Y'))
+        c.setFont(font_name, 12)
+        disp_cab = cabinet[:60] + "..." if len(cabinet) > 60 else cabinet
+        c.drawString(50, y, f"Шкаф: {disp_cab}")
+        c.drawString(400, y, f"Дата: {datetime.now().strftime('%d.%m.%Y')}")
         y -= 20
-        c.line(50, y, w - 50, y)
+        c.line(50, y, width - 50, y)
         y -= 30
 
         if not data:
-            c.drawString(50, y, "No remarks.")
+            c.drawString(50, y, "Нет замечаний.")
             c.save()
             return path
 
-        cb_counter = 0 # Счетчик для уникальных имен чекбоксов
-
-        for fname, tasks in data.items():
-            if y < 100:
-                c.showPage()
-                y = h - 50
-                c.setFont(font, 12)
-                
+        cb_id = 0
+        for filename, tasks in data.items():
+            if y < 100: c.showPage(); y = height - 50; c.setFont(font_name, 12)
             c.setFillColor(colors.darkblue)
-            c.setFont(font, 11)
-            c.drawString(50, y, f"File: {fname}")
+            c.setFont(font_name, 11)
+            c.drawString(50, y, f"Файл: {filename}")
             c.setFillColor(colors.black)
-            y -= 18
-            c.setFont(font, 10)
+            y -= 15
+            c.setFont(font_name, 10)
 
             for task in tasks:
-                cb_counter += 1
-                if y < 60:
-                    c.showPage()
-                    y = h - 50
-                    c.setFont(font, 10)
+                paragraphs = task.split('\n')
+                if y < 80: c.showPage(); y = height - 50; c.setFont(font_name, 10)
                 
-                # === ИСПРАВЛЕНИЕ ЧЕКБОКСОВ ===
-                # Вместо rect рисуем настоящую форму
-                c.acroForm.checkbox(
-                    name=f'CB_{cb_counter}',
-                    x=50, 
-                    y=y-4, 
-                    buttonStyle='check',
-                    borderColor=colors.black,
-                    fillColor=colors.white,
-                    textColor=colors.black,
-                    forceBorder=True,
-                    size=10
-                )
+                # Рисуем интерактивный чекбокс
+                form.checkbox(name=f"cb_{cb_id}", x=50, y=y - 10, size=10, buttonStyle='check', forceBorder=True, fillColor=colors.white)
+                cb_id += 1
                 
-                # Текст задачи
-                words = task.replace('\n', ' ').split()
-                lines, line = [], ""
-                for word in words:
-                    if len(line) + len(word) < 80:
-                        line += word + " "
-                    else:
-                        lines.append(line.strip())
-                        line = word + " "
-                if line: lines.append(line.strip())
-
-                for ln in lines:
-                    if y < 40:
-                        c.showPage()
-                        y = h - 50
-                        c.setFont(font, 10)
-                    c.drawString(70, y, ln) # Отступ 70, чтобы не налезть на чекбокс
-                    y -= 12
-                y -= 5
-            y -= 15
+                text_start_y = y - 2
+
+                for paragraph in paragraphs:
+                    max_len = 95
+                    lines = []
+                    words = paragraph.split(' ')
+                    cur_line = ""
+                    for w in words:
+                        if len(cur_line) + len(w) + 1 <= max_len:
+                            cur_line += w + " "
+                        else:
+                            lines.append(cur_line);
+                            cur_line = w + " "
+                    lines.append(cur_line)
+
+                    for l in lines:
+                        if text_start_y < 40: c.showPage(); text_start_y = height - 50; c.setFont(font_name, 10)
+                        c.drawString(65, text_start_y, l.strip())
+                        text_start_y -= 12
+                y = text_start_y - 8
+            y -= 10
+            c.setStrokeColor(colors.lightgrey)
+            c.line(50, y, width - 50, y)
+            c.setStrokeColor(colors.black)
+            y -= 20
 
         c.save()
         return path
 
 
-# ========== ИНТЕРФЕЙС ==========
-checker = KDChecker()
+# --- НОВЫЙ ИНТЕРФЕЙС С CSS ---
+
+# CSS стили для компактности
+css = """
+/* Убираем лишние отступы у контейнера */
+.gradio-container { max-width: 95% !important; }
+
+/* Делаем зону загрузки компактной */
+.compact_file { 
+    height: 150px !important; 
+    min-height: 150px !important; 
+    max-height: 150px !important;
+    overflow: hidden !important; 
+}
+
+/* Оранжевая кнопка */
+.orange_btn { 
+    background: #FF7F27 !important; 
+    border: none !important; 
+    color: white !important; 
+    font-weight: bold;
+}
+.orange_btn:hover { background: #E06010 !important; }
 
-# CSS для компактности и оранжевой кнопки
-custom_css = """
-.compact_file { height: 120px !important; min-height: 120px !important; }
-.orange_btn { background: #FF7F27 !important; border: none !important; color: white !important; font-size: 16px !important;}
-.gradio-container { max-width: 1400px !important; }
+/* Убираем футер */
 footer { display: none !important; }
 """
 
-with gr.Blocks(title="КД Checker", theme=gr.themes.Soft(), css=custom_css) as app:
-    gr.Markdown("## ✅ Локальный генератор че��-листов КД")
+def create_app():
+    checker = KDChecker()
     
-    with gr.Row():
-        # --- ЛЕВАЯ КОЛОНКА (БАЗА) ---
-        with gr.Column(scale=1):
-            gr.Markdown("### 1. База знаний")
-            db_input = gr.File(label="Загрузить Excel (.xlsx)", file_types=[".xlsx", ".xls"], 
-                               type="filepath", elem_classes="compact_file")
-            
-            # Поля управления базой под файлом
-            with gr.Group():
-                cabinet_dd = gr.Dropdown(label="Или выберите шкаф-аналог вручную", choices=[], interactive=True)
-                db_status = gr.Textbox(label="Статус базы", lines=2, interactive=False, placeholder="Ожидание загрузки...")
-
-        # --- ПРАВАЯ КОЛОНКА (ЧЕРТЕЖИ) ---
-        with gr.Column(scale=1):
-            gr.Markdown("### 2. Документация")
-            pdf_input = gr.File(label="Чертежи (PDF)", file_count="multiple", file_types=[".pdf"], 
-                                type="filepath", elem_classes="compact_file")
-            
-            # Кнопка под файлами
-            gr.Markdown("") # Отступ
-            run_btn = gr.Button("Сформировать чек-лист", variant="primary", elem_classes="orange_btn")
-
-    # --- НИЖНЯЯ СЕКЦИЯ (РЕЗУЛЬТАТ) ---
-    with gr.Row():
-        with gr.Column(scale=1):
-            result_txt = gr.Textbox(label="Результат", lines=6)
-        with gr.Column(scale=1):
-            result_pdf = gr.File(label="📥 Скачать PDF")
-
-    # ЛОГИКА
-    db_input.change(checker.load_excel_db, [db_input], [db_status, cabinet_dd])
-    run_btn.click(checker.check_files, [pdf_input, cabinet_dd], [result_txt, result_pdf])
+    with gr.Blocks(title="Генератор чек-листов КД", theme=gr.themes.Soft(), css=css) as app:
+        gr.Markdown("## ✅ Генератор чек-листов КД")
+
+        with gr.Row():
+            # === КОЛОНКА 1: БАЗА ===
+            with gr.Column(scale=1):
+                gr.Markdown("### 1. База знаний")
+                # elem_classes применяет наш CSS класс
+                db_in = gr.File(label="Excel (.xlsx)", type="filepath", elem_classes="compact_file")
+                
+                with gr.Group():
+                    manual_cab = gr.Dropdown(label="Или шкаф вручную", choices=[], interactive=True)
+                    db_out = gr.Textbox(label="Статус базы", lines=2, max_lines=3, interactive=False)
+                
+                # Привязка событий
+                db_in.upload(checker.load_excel_db, inputs=[db_in], outputs=[db_out, manual_cab])
 
+            # === КОЛОНКА 2: ДОКУМЕНТЫ ===
+            with gr.Column(scale=1):
+                gr.Markdown("### 2. Документация")
+                files_in = gr.File(label="Чертежи (PDF)", file_count="multiple", type="filepath", elem_classes="compact_file")
+                
+                gr.Markdown("") # Пустой разделитель
+                btn = gr.Button("Сформировать чек-лист", variant="primary", elem_classes="orange_btn")
+
+        # === РЕЗУЛЬТАТ ===
+        gr.Markdown("### 3. Результат")
+        with gr.Row():
+            with gr.Column(scale=1):
+                res_txt = gr.Textbox(label="Лог проверки", lines=5)
+            with gr.Column(scale=1):
+                res_pdf = gr.File(label="Скачать готовый PDF")
+
+        # Запуск обработки
+        btn.click(checker.check_files, inputs=[files_in, manual_cab], outputs=[res_txt, res_pdf])
+    
+    return app
 
 if __name__ == "__main__":
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        auth=(AUTH_USERNAME, AUTH_PASSWORD)
-    )
+    app = create_app()
+    app.launch(inbrowser=True, server_name="127.0.0.1", server_port=7861)