Spaces:
Sleeping
Sleeping
| 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.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(f"Auth: {AUTH_USERNAME} / *****") | |
| 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"] | |
| def load_excel_db(self, excel_file): | |
| """Загрузка Excel базы""" | |
| 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"❌ Файл не найден: {excel_path}", gr.update(choices=[], value=None) | |
| all_data = [] | |
| sheets_info = [] | |
| try: | |
| xls = pd.read_excel(excel_path, sheet_name=None, header=None, engine='openpyxl') | |
| for sheet_name, df_raw in xls.items(): | |
| header_row = -1 | |
| cab_col = -1 | |
| rem_col = -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 | |
| break | |
| if header_row != -1 and cab_col < len(df_raw.columns) and rem_col < len(df_raw.columns): | |
| 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) | |
| sheets_info.append(f"'{sheet_name}': {len(df_sub)}") | |
| if not all_data: | |
| 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\n" | |
| msg += f"📊 Записей: {len(self.excel_db)}\n" | |
| msg += f"🗄️ Шкафов: {len(self.cabinet_list)}\n" | |
| msg += f"📋 Листы: {', '.join(sheets_info)}" | |
| return msg, gr.update(choices=self.cabinet_list, value=None) | |
| except Exception as e: | |
| import traceback | |
| return f"❌ Ошибка: {e}\n\n{traceback.format_exc()}", gr.update(choices=[], value=None) | |
| def extract_text(self, pdf_path): | |
| try: | |
| text = "" | |
| with pdfplumber.open(pdf_path) as pdf: | |
| for page in pdf.pages: | |
| text += (page.extract_text() or "") + "\n" | |
| return text | |
| except: | |
| return "" | |
| 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 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() | |
| 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 | |
| return "UNKNOWN" | |
| def get_remarks(self, cabinet_key, is_clean=True): | |
| if self.excel_db.empty: | |
| return {} | |
| if is_clean: | |
| 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 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 = [] | |
| 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 | |
| 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) | |
| 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 = [] | |
| for f in files: | |
| fp = f if isinstance(f, str) else getattr(f, 'name', str(f)) | |
| file_paths.append(fp) | |
| detected_cabinet = "Не определен" | |
| method = "" | |
| is_manual = False | |
| if manual_cabinet and manual_cabinet.strip(): | |
| detected_cabinet = manual_cabinet | |
| 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" | |
| 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" | |
| break | |
| if method: | |
| break | |
| if detected_cabinet == "Не определен": | |
| return "⚠️ Шкаф не определён. Выберите вручную.", None | |
| remarks = self.get_remarks(detected_cabinet, is_clean=(method == "number")) | |
| if not remarks: | |
| return f"⚠️ Для '{detected_cabinet}' замечаний нет.", None | |
| checklist = {} | |
| for fp in file_paths: | |
| fname = os.path.basename(fp) | |
| dtype = self.determine_doc_type(fname) | |
| tasks = remarks.get(dtype, []) + (remarks.get("ALL", []) if dtype != "С2" else []) | |
| if tasks: | |
| checklist[fname] = list(dict.fromkeys(tasks)) | |
| title = detected_cabinet + (" (ручной)" if is_manual else "") | |
| try: | |
| pdf_path = self.create_pdf(title, checklist) | |
| except Exception as e: | |
| return f"❌ Ошибка PDF: {e}", None | |
| total = sum(len(v) for v in checklist.values()) | |
| method_name = {"manual": "Ручной", "number": "По номеру", "name": "По названию"}.get(method, "?") | |
| return f"✅ Готово!\n\n📂 {detected_cabinet}\n🔍 {method_name}\n📄 Файлов: {len(file_paths)}\n🚩 Замечаний: {total}", pdf_path | |
| def create_pdf(self, cabinet, data): | |
| path = os.path.join(tempfile.gettempdir(), "CheckList.pdf") | |
| c = canvas.Canvas(path, pagesize=A4) | |
| w, h = A4 | |
| font = 'Helvetica' | |
| y = h - 50 | |
| c.setFont(font, 16) | |
| c.drawString(50, y, "CHECK-LIST") | |
| y -= 25 | |
| c.setFont(font, 12) | |
| c.drawString(50, y, f"Cabinet: {cabinet[:50]}") | |
| c.drawString(400, y, datetime.now().strftime('%d.%m.%Y')) | |
| y -= 20 | |
| c.line(50, y, w - 50, y) | |
| y -= 30 | |
| if not data: | |
| c.drawString(50, y, "No remarks.") | |
| c.save() | |
| return path | |
| for fname, tasks in data.items(): | |
| if y < 100: | |
| c.showPage() | |
| y = h - 50 | |
| c.setFillColor(colors.darkblue) | |
| c.setFont(font, 11) | |
| c.drawString(50, y, f"File: {fname}") | |
| c.setFillColor(colors.black) | |
| y -= 18 | |
| c.setFont(font, 10) | |
| for task in tasks: | |
| if y < 60: | |
| c.showPage() | |
| y = h - 50 | |
| c.setFont(font, 10) | |
| c.rect(50, y - 2, 8, 8, stroke=1, fill=0) | |
| words = task.replace('\n', ' ').split() | |
| lines, line = [], "" | |
| for word in words: | |
| if len(line) + len(word) < 85: | |
| 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(65, y, ln) | |
| y -= 12 | |
| y -= 5 | |
| y -= 15 | |
| c.save() | |
| return path | |
| # ========== ИНТЕРФЕЙС ========== | |
| checker = KDChecker() | |
| with gr.Blocks(title="КД Checker", theme=gr.themes.Soft()) as app: | |
| gr.Markdown("# ✅ Генератор чек-листов КД") | |
| with gr.Row(): | |
| with gr.Column(): | |
| gr.Markdown("### 📁 База знаний") | |
| db_input = gr.File(label="Excel (.xlsx)", file_types=[".xlsx", ".xls"], type="filepath") | |
| cabinet_dd = gr.Dropdown(label="Шкаф вручную", choices=[], interactive=True) | |
| db_status = gr.Textbox(label="Статус", lines=5) | |
| with gr.Column(): | |
| gr.Markdown("### 📄 Чертежи") | |
| pdf_input = gr.File(label="PDF файлы", file_count="multiple", file_types=[".pdf"], type="filepath") | |
| run_btn = gr.Button("🔍 Сформировать", variant="primary") | |
| with gr.Row(): | |
| result_txt = gr.Textbox(label="Результат", lines=5) | |
| 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]) | |
| if __name__ == "__main__": | |
| app.launch( | |
| server_name="0.0.0.0", | |
| server_port=7860, | |
| auth=(AUTH_USERNAME, AUTH_PASSWORD) | |
| ) |