Update app.py

app.py

@@ -18,7 +18,8 @@ AUTH_PASSWORD = "12345"
 
 print("===== Application Startup =====")
 print(f"Time: {datetime.now()}")
-print(f"Auth enabled: Username={AUTH_USERNAME}")
+print(f"Gradio version: {gr.__version__}")
+print(f"Auth: {AUTH_USERNAME} / *****")
 print("================================")
 
 
@@ -27,150 +28,111 @@ class KDChecker:
         self.excel_db = pd.DataFrame()
         self.cabinet_list = []
         self.known_docs = ["Э3", "В4", "ПЭ3", "ВО", "ТЭ5", "СБ", "С5", "ОЛ", "Э1", "Э4", "Э7", "Д3", "Э6"]
-        print("[KDChecker] Инициализация завершена")
+        print("[KDChecker] Initialized")
 
     def load_excel_db(self, excel_file):
         """Загрузка Excel базы знаний"""
-        log = [f"[{datetime.now().strftime('%H:%M:%S')}] Старт загрузки Excel"]
+        log = [f"[{datetime.now().strftime('%H:%M:%S')}] Начало загрузки"]
         
-        # Проверка входных данных
         if excel_file is None:
-            log.append("ERROR: excel_file is None")
-            return "\n".join(log), gr.update(choices=[], value=None)
+            return "❌ Файл не выбран", gr.Dropdown.update(choices=[], value=None)
         
-        # Определяем путь к файлу (gradio может передать разные типы)
+        # Получаем путь к файлу
         if isinstance(excel_file, str):
             excel_path = excel_file
-        elif hasattr(excel_file, 'name'):
-            excel_path = excel_file.name
         else:
-            excel_path = str(excel_file)
+            excel_path = excel_file.name if hasattr(excel_file, 'name') else str(excel_file)
         
-        log.append(f"Тип входных данных: {type(excel_file)}")
-        log.append(f"Путь к файлу: {excel_path}")
+        log.append(f"Путь: {excel_path}")
+        log.append(f"Тип: {type(excel_file)}")
         
-        # Проверка существования файла
         if not os.path.exists(excel_path):
-            log.append(f"ERROR: Файл не найден по пути: {excel_path}")
-            return "\n".join(log), gr.update(choices=[], value=None)
+            log.append(f"❌ Файл не найден!")
+            return "\n".join(log), gr.Dropdown.update(choices=[], value=None)
         
         try:
-            size = os.path.getsize(excel_path)
-            log.append(f"Размер файла: {size} байт")
+            file_size = os.path.getsize(excel_path)
+            log.append(f"Размер: {file_size} байт")
         except Exception as e:
-            log.append(f"ERROR при получении размера: {e}")
-            return "\n".join(log), gr.update(choices=[], value=None)
-
-        # Проверка openpyxl
-        try:
-            import openpyxl
-            log.append(f"openpyxl version: {openpyxl.__version__}")
-        except ImportError as e:
-            log.append(f"ERROR: openpyxl не установлен: {e}")
-            return "\n".join(log), gr.update(choices=[], value=None)
+            log.append(f"Ошибка размера: {e}")
 
         all_data = []
-        sheets_log = []
+        sheets_info = []
 
         try:
-            log.append("Чтение Excel файла...")
+            log.append("Читаю Excel...")
             xls = pd.read_excel(excel_path, sheet_name=None, header=None, engine='openpyxl')
-            log.append(f"Найдено листов: {len(xls)}")
-            log.append(f"Имена листов: {list(xls.keys())}")
+            log.append(f"Листов найдено: {len(xls)}")
 
             for sheet_name, df_raw in xls.items():
-                log.append(f"--- Обработка листа: '{sheet_name}' ({len(df_raw)} строк) ---")
-                
-                header_row_index = -1
-                cab_col_idx = -1
-                rem_col_idx = -1
+                header_row = -1
+                cab_col = -1
+                rem_col = -1
 
-                # Поиск заголовков в первых 20 строках
                 for i in range(min(20, len(df_raw))):
-                    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):
+                    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:
-                            c_idx = idx
+                            cab_col = 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
-                        log.append(f"  Заголовки найдены в строке {i}: шкаф={c_idx}, примечание={r_idx}")
+                            rem_col = idx
+                    if cab_col != -1 and rem_col != -1:
+                        header_row = i
                         break
 
-                if header_row_index != -1:
-                    df = pd.read_excel(excel_path, sheet_name=sheet_name, header=header_row_index, engine='openpyxl')
-                    log.append(f"  Колонок в листе: {len(df.columns)}")
-                    
-                    if cab_col_idx < len(df.columns) and rem_col_idx < len(df.columns):
-                        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(
+                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_subset)
-                        sheets_log.append(f"'{sheet_name}': {len(df_subset)} записей")
-                        log.append(f"  ✓ Добавлено {len(df_subset)} записей")
-                    else:
-                        sheets_log.append(f"'{sheet_name}': ошибка индексов")
-                        log.append(f"  ✗ Ошибка индексов колонок")
-                else:
-                    sheets_log.append(f"'{sheet_name}': заголовки не найдены")
-                    log.append(f"  ✗ Заголовки 'шкаф'/'примечание' не найдены")
+                        all_data.append(df_sub)
+                        sheets_info.append(f"'{sheet_name}': {len(df_sub)}")
 
             if not all_data:
-                log.append("ИТОГ: Не найдены данные ни на одном листе!")
-                return "\n".join(log), gr.update(choices=[], value=None)
+                log.append("❌ Данные не найдены ни на одном листе")
+                return "\n".join(log), gr.Dropdown.update(choices=[], value=None)
 
             self.excel_db = pd.concat(all_data, ignore_index=True)
             self.cabinet_list = sorted(self.excel_db["Cabinet"].unique().tolist())
             
-            log.append(f"ИТОГ: Загружено {len(self.excel_db)} записей")
-            log.append(f"Уникальных шкафов: {len(self.cabinet_list)}")
-            
-            result_msg = f"✅ База загружена успешно!\n\n"
-            result_msg += f"📊 Всего записей: {len(self.excel_db)}\n"
-            result_msg += f"🗄️ Шкафов: {len(self.cabinet_list)}\n"
-            result_msg += f"📋 Листы: {', '.join(sheets_log)}"
+            result = f"✅ База загружена!\n\n"
+            result += f"📊 Записей: {len(self.excel_db)}\n"
+            result += f"🗄️ Шкафов: {len(self.cabinet_list)}\n"
+            result += f"📋 Листы: {', '.join(sheets_info)}"
             
-            return result_msg, gr.update(choices=self.cabinet_list, value=None)
+            return result, gr.Dropdown.update(choices=self.cabinet_list, value=None)
 
         except Exception as e:
-            log.append(f"КРИТИЧЕСКАЯ ОШИБКА: {str(e)}")
+            log.append(f"❌ ОШИБКА: {str(e)}")
             import traceback
             log.append(traceback.format_exc())
-            return "\n".join(log), gr.update(choices=[], value=None)
+            return "\n".join(log), gr.Dropdown.update(choices=[], value=None)
 
     def extract_text(self, pdf_path):
-        """Извлечение текста из PDF"""
         try:
-            full_text = ""
+            text = ""
             with pdfplumber.open(pdf_path) as pdf:
                 for page in pdf.pages:
-                    full_text += (page.extract_text() or "") + "\n"
-            return full_text
-        except Exception as e:
-            print(f"[extract_text] Error: {e}")
+                    text += (page.extract_text() or "") + "\n"
+            return text
+        except:
             return ""
 
-    def find_all_decimal_numbers(self, text):
-        """Поиск децимальных номеров в тексте"""
+    def find_decimal_numbers(self, text):
         pattern = r"(РЛТ|ЛДАР|ВНАР|ШТМ)[\s\.]*\d{1}[\s\.]*\d{3}[\s\.]*[А-ЯA-Z]{1,4}[\s\.]*\d{3}(-[\d]+)?"
         matches = []
-        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)
+        for m in re.finditer(pattern, text):
+            clean = m.group(0).replace(" ", "").replace("\n", "")
+            if clean not in matches:
+                matches.append(clean)
         return matches
 
     def determine_doc_type(self, filename):
-        """Определение типа документа по имени файла"""
         fname = filename.upper()
         if "С2" in fname: return "С2"
         if "ПЭ3" in fname or "ПЕРЕЧЕНЬ" in fname: return "ПЭ3"
@@ -187,12 +149,11 @@ class KDChecker:
         if "Д3" in fname or "МОНТАЖ" in fname: return "Д3"
         return "UNKNOWN"
 
-    def get_remarks(self, cabinet_key, is_clean_key=True):
-        """Получение замечаний для шкафа"""
+    def get_remarks(self, cabinet_key, is_clean=True):
         if self.excel_db.empty:
             return {}
         
-        if is_clean_key:
+        if is_clean:
             target = cabinet_key.replace(" ", "")
             mask = self.excel_db['Cabinet_Clean'].str.contains(re.escape(target), case=False, na=False)
         else:
@@ -203,107 +164,100 @@ class KDChecker:
             return {}
         
         parsed = {}
-        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 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 item in items:
                 if len(item) < 3:
                     continue
                 clean_item = item.strip()
-                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)
+                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)
                 
-                detected_docs = []
+                docs = []
                 final_text = clean_item
                 
                 if match:
-                    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
+                    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
                         final_text = match.group(2).strip()
                 
-                if not detected_docs:
-                    detected_docs = ["ALL"]
+                if not docs:
+                    docs = ["ALL"]
                 
-                for doc in detected_docs:
-                    if doc not in parsed:
-                        parsed[doc] = []
-                    parsed[doc].append(final_text)
+                for d in docs:
+                    if d not in parsed:
+                        parsed[d] = []
+                    parsed[d].append(final_text)
         
         return parsed
 
     def check_files(self, files, manual_cabinet):
-        """Проверка PDF файлов"""
         if not files:
-            return "❌ Файлы не загружены", None
+            return "❌ Загрузите PDF файлы", None
         if self.excel_db.empty:
             return "❌ Сначала загрузите Excel базу!", None
 
-        checklist = {}
-        detected_cabinet = "Не определен"
-        found_by_method = ""
-        is_manual = False
-
-        # Обработка входных файлов
+        # Получаем пути к файлам
         file_paths = []
         for f in files:
             if isinstance(f, str):
                 file_paths.append(f)
-            elif hasattr(f, 'name'):
-                file_paths.append(f.name)
             else:
-                file_paths.append(str(f))
+                file_paths.append(f.name if hasattr(f, 'name') else str(f))
+
+        checklist = {}
+        detected_cabinet = "Не определен"
+        method = ""
+        is_manual = False
 
         if manual_cabinet and manual_cabinet.strip():
             detected_cabinet = manual_cabinet
-            found_by_method = "manual"
+            method = "manual"
             is_manual = True
         else:
-            all_pdf_text = ""
-            for file_path in file_paths:
-                all_pdf_text += self.extract_text(file_path) + "\n"
+            all_text = ""
+            for fp in file_paths:
+                all_text += self.extract_text(fp) + "\n"
 
-            pdf_numbers = self.find_all_decimal_numbers(all_pdf_text)
-            db_clean_keys = set(self.excel_db["Cabinet_Clean"].tolist())
+            numbers = self.find_decimal_numbers(all_text)
+            db_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"
+            for num in numbers:
+                if num in db_keys:
+                    detected_cabinet = num
+                    method = "number"
                     break
 
             if detected_cabinet == "Не определен":
-                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"
+                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"
                             break
-                    if found_by_method == "name":
+                    if method == "name":
                         break
 
         if detected_cabinet == "Не определен":
-            return "⚠️ Шкаф не опознан автоматически.\nВыберите шкаф из списка вручную.", None
+            return "⚠️ Шкаф не определён. Выберите вручную из списка.", None
 
-        is_clean_search = (found_by_method == "number")
-        remarks = self.get_remarks(detected_cabinet, is_clean_key=is_clean_search)
+        is_clean = (method == "number")
+        remarks = self.get_remarks(detected_cabinet, is_clean=is_clean)
 
         if not remarks:
-            return f"⚠️ Шкаф '{detected_cabinet}' найден, но замечаний в базе нет.", None
+            return f"⚠️ Шкаф '{detected_cabinet}' найден, но замечаний нет.", None
 
-        processed_count = 0
-        for file_path in file_paths:
-            fname = os.path.basename(file_path)
+        for fp in file_paths:
+            fname = os.path.basename(fp)
             dtype = self.determine_doc_type(fname)
 
             tasks = []
@@ -314,72 +268,49 @@ class KDChecker:
 
             if tasks:
                 checklist[fname] = list(dict.fromkeys(tasks))
-            processed_count += 1
 
-        pdf_title = detected_cabinet
+        title = detected_cabinet
         if is_manual:
-            pdf_title += " (Ручной выбор)"
+            title += " (ручной выбор)"
 
         try:
-            pdf_path = self.create_pdf(pdf_title, checklist)
+            pdf_path = self.create_pdf(title, checklist)
         except Exception as e:
-            return f"❌ Ошибка создания PDF: {e}", None
+            return f"❌ Ошибка PDF: {e}", None
 
         total = sum(len(v) for v in checklist.values())
-        method_str = "Ручной выбор" if is_manual else (
-            "По децимальному номеру" if is_clean_search else "По наименованию")
+        method_str = "Ручной" if is_manual else ("По номеру" if is_clean else "По названию")
 
-        result = f"✅ Чек-лист сформирован!\n\n"
+        result = f"✅ Готово!\n\n"
         result += f"📂 Шкаф: {detected_cabinet}\n"
-        result += f"🔍 Метод определения: {method_str}\n"
-        result += f"📄 Обработано файлов: {processed_count}\n"
-        result += f"🚩 Всего замечаний: {total}"
+        result += f"🔍 Метод: {method_str}\n"
+        result += f"📄 Файлов: {len(file_paths)}\n"
+        result += f"🚩 Замечаний: {total}"
 
         return result, pdf_path
 
     def create_pdf(self, cabinet, data):
-        """Создание PDF чек-листа"""
-        fname = "CheckList_Result.pdf"
-        path = os.path.join(tempfile.gettempdir(), fname)
+        path = os.path.join(tempfile.gettempdir(), "CheckList.pdf")
         c = canvas.Canvas(path, pagesize=A4)
         width, height = A4
-
-        # Шрифт
-        font_name = 'Helvetica'
-        font_path = "arial.ttf"
-        if os.path.exists(font_path):
-            try:
-                pdfmetrics.registerFont(TTFont('Arial', font_path))
-                font_name = 'Arial'
-            except:
-                pass
+        font = 'Helvetica'
 
         y = height - 50
-        c.setFont(font_name, 16)
+        c.setFont(font, 16)
+        c.drawString(50, y, "CHECK-LIST KD")
         
-        try:
-            c.drawString(50, y, "ЧЕК-ЛИСТ ПРОВЕРКИ КД")
-        except:
-            c.setFont("Helvetica", 16)
-            c.drawString(50, y, "CHECK-LIST KD")
-
         y -= 25
-        c.setFont(font_name, 12)
-        disp_cab = cabinet[:60] + "..." if len(cabinet) > 60 else cabinet
+        c.setFont(font, 12)
+        cab_display = cabinet[:50] + "..." if len(cabinet) > 50 else cabinet
+        c.drawString(50, y, f"Cabinet: {cab_display}")
+        c.drawString(400, y, f"Date: {datetime.now().strftime('%d.%m.%Y')}")
         
-        try:
-            c.drawString(50, y, f"Шкаф: {disp_cab}")
-        except:
-            c.setFont("Helvetica", 12)
-            c.drawString(50, y, f"Cabinet: {disp_cab}")
-
-        c.drawString(400, y, f"Дата: {datetime.now().strftime('%d.%m.%Y')}")
         y -= 20
         c.line(50, y, width - 50, y)
         y -= 30
 
         if not data:
-            c.drawString(50, y, "Нет замечаний для загруженных файлов.")
+            c.drawString(50, y, "No remarks for loaded files.")
             c.save()
             return path
 
@@ -387,134 +318,97 @@ class KDChecker:
             if y < 100:
                 c.showPage()
                 y = height - 50
-                c.setFont(font_name, 12)
+                c.setFont(font, 12)
 
             c.setFillColor(colors.darkblue)
-            c.setFont(font_name, 11)
-            try:
-                c.drawString(50, y, f"Файл: {filename}")
-            except:
-                c.setFont("Helvetica", 11)
-                c.drawString(50, y, f"File: {filename}")
-                
+            c.setFont(font, 11)
+            c.drawString(50, y, f"File: {filename}")
             c.setFillColor(colors.black)
-            y -= 15
-            c.setFont(font_name, 10)
+            y -= 18
+            c.setFont(font, 10)
 
             for task in tasks:
-                if y < 80:
+                if y < 60:
                     c.showPage()
                     y = height - 50
-                    c.setFont(font_name, 10)
+                    c.setFont(font, 10)
 
                 c.rect(50, y - 2, 8, 8, stroke=1, fill=0)
 
-                # Разбивка текста на строки
-                max_len = 90
-                words = task.replace('\n', ' ').split(' ')
+                # Разбивка на строки
+                words = task.replace('\n', ' ').split()
                 lines = []
-                cur_line = ""
+                line = ""
                 for w in words:
-                    if len(cur_line) + len(w) + 1 <= max_len:
-                        cur_line += w + " "
+                    if len(line) + len(w) < 85:
+                        line += w + " "
                     else:
-                        lines.append(cur_line.strip())
-                        cur_line = w + " "
-                if cur_line:
-                    lines.append(cur_line.strip())
+                        lines.append(line.strip())
+                        line = w + " "
+                if line:
+                    lines.append(line.strip())
 
-                for i, line in enumerate(lines):
+                for i, ln in enumerate(lines):
                     if y < 40:
                         c.showPage()
                         y = height - 50
-                        c.setFont(font_name, 10)
-                    x_offset = 65 if i == 0 else 65
-                    try:
-                        c.drawString(x_offset, y, line)
-                    except:
-                        pass
+                        c.setFont(font, 10)
+                    c.drawString(65, y, ln)
                     y -= 12
 
                 y -= 5
 
-            y -= 10
+            y -= 15
             c.setStrokeColor(colors.lightgrey)
             c.line(50, y, width - 50, y)
             c.setStrokeColor(colors.black)
-            y -= 15
+            y -= 10
 
         c.save()
         return path
 
 
-def create_app():
-    checker = KDChecker()
-    
-    with gr.Blocks(title="Генератор чек-листов КД", theme=gr.themes.Soft()) as app:
-        gr.Markdown("# ✅ Генератор чек-листов КД")
-        gr.Markdown("Автоматическая проверка конструкторской документации по базе знаний Excel.")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                gr.Markdown("### 📁 1. База знаний")
-                db_in = gr.File(
-                    label="Загрузить Excel (.xlsx)", 
-                    file_types=[".xlsx", ".xls"],
-                    type="filepath"
-                )
-                manual_cab = gr.Dropdown(
-                    label="Или выберите шкаф вручную", 
-                    choices=[], 
-                    interactive=True,
-                    allow_custom_value=False
-                )
-                db_out = gr.Textbox(
-                    label="Статус загрузки", 
-                    lines=8,
-                    max_lines=15
-                )
-
-            with gr.Column(scale=1):
-                gr.Markdown("### 📄 2. Документация (PDF)")
-                files_in = gr.File(
-                    label="Загрузить чертежи (PDF)", 
-                    file_count="multiple", 
-                    file_types=[".pdf"],
-                    type="filepath"
-                )
-                btn = gr.Button("🔍 Сформировать чек-лист", variant="primary", size="lg")
-
-        with gr.Row():
-            with gr.Column(scale=1):
-                res_txt = gr.Textbox(label="Результат проверки", lines=8)
-            with gr.Column(scale=1):
-                res_pdf = gr.File(label="📥 Скачать PDF чек-лист")
-
-        # Привязка событий
-        db_in.change(
-            fn=checker.load_excel_db, 
-            inputs=[db_in], 
-            outputs=[db_out, manual_cab]
-        )
-        
-        btn.click(
-            fn=checker.check_files, 
-            inputs=[files_in, manual_cab], 
-            outputs=[res_txt, res_pdf]
-        )
-    
-    return app
+# ========== СОЗДАНИЕ ИНТЕРФЕЙСА ==========
+checker = KDChecker()
+
+with gr.Blocks(title="КД Checker") as app:
+    gr.Markdown("# ✅ Генератор чек-листов КД")
+    gr.Markdown("Загрузите Excel базу и PDF чертежи для формирования чек-листа.")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### 📁 1. База знаний (Excel)")
+            db_input = gr.File(label="Загрузить .xlsx файл", file_types=[".xlsx", ".xls"])
+            cabinet_dropdown = gr.Dropdown(label="Или выберите шкаф вручную", choices=[], interactive=True)
+            db_status = gr.Textbox(label="Статус", lines=6)
+
+        with gr.Column():
+            gr.Markdown("### 📄 2. Чертежи (PDF)")
+            pdf_input = gr.File(label="Загрузить PDF", file_count="multiple", file_types=[".pdf"])
+            run_btn = gr.Button("🔍 Сформировать чек-лист", variant="primary")
+
+    with gr.Row():
+        result_text = gr.Textbox(label="Результат", lines=6)
+        result_pdf = gr.File(label="📥 Скачать PDF")
 
+    # События
+    db_input.change(
+        fn=checker.load_excel_db,
+        inputs=[db_input],
+        outputs=[db_status, cabinet_dropdown]
+    )
 
-# ========== ЗАПУСК ПРИЛОЖЕНИЯ ==========
-app = create_app()
+    run_btn.click(
+        fn=checker.check_files,
+        inputs=[pdf_input, cabinet_dropdown],
+        outputs=[result_text, result_pdf]
+    )
 
+# ========== ЗАПУСК ==========
 if __name__ == "__main__":
-    print(f"Starting with auth: {AUTH_USERNAME} / {'*' * len(AUTH_PASSWORD)}")
-    
     app.launch(
         server_name="0.0.0.0",
         server_port=7860,
         auth=(AUTH_USERNAME, AUTH_PASSWORD),
-        auth_message="Введите логин и пароль для доступа"
+        auth_message="Введите логин и пароль"
     )