added the load_table_data function

documents_prep.py

@@ -354,28 +354,43 @@ def load_image_data(repo_id, hf_token, image_data_dir):
                 df = pd.read_csv(local_path)
                 log_message(f"Загружено {len(df)} записей изображений из файла {file_path}")
                 
-                # Обработка с правильными названиями колонок
                 for _, row in df.iterrows():
                     section_value = row.get('Раздел документа', 'Неизвестно')
+                    image_num = str(row.get('№ Изображения', 'Неизвестно'))
+                    image_title = str(row.get('Название изображения', 'Неизвестно'))
+                    image_desc = str(row.get('Описание изображение', 'Неизвестно'))
+                    doc_id = str(row.get('Обозначение документа', 'Неизвестно'))
+                    file_name = str(row.get('Файл изображения', 'Неизвестно'))
                     
-                    content = f"Изображение: {row.get('№ Изображения', 'Неизвестно')}\n"
-                    content += f"Название: {row.get('Название изображения', 'Неизвестно')}\n"
-                    content += f"Описание: {row.get('Описание изображение', 'Неизвестно')}\n"  # Опечатка в названии колонки
-                    content += f"Документ: {row.get('Обозначение документа', 'Неизвестно')}\n"
+                    # FIXED: Create structured, searchable content
+                    content = f"=== ИЗОБРАЖЕНИЕ ===\n"
+                    content += f"Документ: {doc_id}\n"
+                    content += f"Стандарт: {doc_id}\n"
                     content += f"Раздел: {section_value}\n"
-                    content += f"Файл: {row.get('Файл изображения', 'Неизвестно')}\n"
+                    content += f"Изображение: {image_num}\n"
+                    content += f"Название: {image_title}\n"
+                    content += f"Описание: {image_desc}\n"
+                    content += f"Файл: {file_name}\n"
+                    content += f"Уникальный ID: {doc_id} | {section_value} | {image_num}\n"
+                    content += f"===================\n\n"
+                    
+                    # Add contextual information for better retrieval
+                    content += f"Это изображение {image_num} из документа {doc_id}, "
+                    content += f"расположенное в разделе '{section_value}'. "
+                    content += f"{image_title}. {image_desc}"
                     
                     doc = Document(
                         text=content,
                         metadata={
                             "type": "image",
-                            "image_number": str(row.get('№ Изображения', 'unknown')),
-                            "image_title": str(row.get('Название изображения', 'unknown')),
-                            "image_description": str(row.get('Описание изображение', 'unknown')),
-                            "document_id": str(row.get('Обозначение документа', 'unknown')),
-                            "file_path": str(row.get('Файл изображения', 'unknown')),
-                            "section": str(section_value),
-                            "section_id": str(section_value)
+                            "image_number": image_num,
+                            "image_title": image_title,
+                            "image_description": image_desc,
+                            "document_id": doc_id,
+                            "file_path": file_name,
+                            "section": section_value,
+                            "section_id": section_value,
+                            "full_image_id": f"{doc_id} | {section_value} | {image_num}"
                         }
                     )
                     image_documents.append(doc)
@@ -392,53 +407,120 @@ def load_image_data(repo_id, hf_token, image_data_dir):
         return []
 
 def load_table_data(repo_id, hf_token, table_data_dir):
-    files = list_repo_files(repo_id=repo_id, repo_type="dataset", token=hf_token)
-    table_files = [f for f in files if f.startswith(table_data_dir) and f.endswith('.json')]
-    
-    table_documents = []
+    """Load and process table data with sheet-level document_id extraction"""
+    log_message("=" * 60)
+    log_message("НАЧАЛО ЗАГРУЗКИ ТАБЛИЧНЫХ ДАННЫХ")
+    log_message("=" * 60)
     
-    for file_path in table_files:
-        try:
-            local_path = hf_hub_download(
-                repo_id=repo_id,
-                filename=file_path,
-                local_dir='',
-                repo_type="dataset",
-                token=hf_token
-            )
-            
-            with open(local_path, 'r', encoding='utf-8') as f:
-                table_data = json.load(f)
+    try:
+        from huggingface_hub import hf_hub_download, list_repo_files
+        import json
+        from collections import defaultdict
+        
+        files = list_repo_files(repo_id=repo_id, repo_type="dataset", token=hf_token)
+        table_files = [f for f in files if f.startswith(table_data_dir) and f.endswith('.json')]
+        
+        log_message(f"Найдено {len(table_files)} JSON файлов с таблицами")
+        
+        table_documents = []
+        stats = {
+            'total_tables': 0,
+            'total_size': 0,
+            'by_document': defaultdict(lambda: {'count': 0, 'size': 0})
+        }
+        
+        for file_path in table_files:
+            try:
+                local_path = hf_hub_download(
+                    repo_id=repo_id,
+                    filename=file_path,
+                    local_dir='',
+                    repo_type="dataset",
+                    token=hf_token
+                )
                 
-                if isinstance(table_data, dict):
-                    document_id = (
-                        table_data.get('document_id') or 
-                        table_data.get('document') or 
-                        table_data.get('Обозначение документа') or
-                        'unknown'
-                    )
-                    
-                    if 'НП-104-18' in str(document_id):
-                        document_id = 'ГОСТ 59023'
+                log_message(f"\nОбработка файла: {file_path}")
+                
+                with open(local_path, 'r', encoding='utf-8') as f:
+                    table_data = json.load(f)
                     
-                    if 'sheets' in table_data:
-                        for sheet in table_data['sheets']:
-                            sheet['document_id'] = document_id
-                            sheet['document'] = document_id
-                            docs_list = table_to_document(sheet, document_id=document_id)
+                    if isinstance(table_data, dict):
+                        # Extract file-level document_id
+                        file_level_doc_id = (
+                            table_data.get('document_id') or 
+                            table_data.get('document') or 
+                            table_data.get('Обозначение документа') or
+                            'unknown'
+                        )
+                        
+                        # Handle multiple sheets
+                        if 'sheets' in table_data:
+                            sorted_sheets = sorted(
+                                table_data['sheets'],
+                                key=lambda sheet: sheet.get('table_number', '')
+                            )
+                            
+                            for sheet in sorted_sheets:
+                                # CRITICAL FIX: Use sheet-level document_id if available
+                                sheet_doc_id = (
+                                    sheet.get('document_id') or 
+                                    sheet.get('document') or 
+                                    sheet.get('Обозначение документа') or
+                                    file_level_doc_id
+                                )
+                                
+                                log_message(f"  Sheet doc_id: {sheet_doc_id} (file: {file_level_doc_id})")
+                                
+                                # Pass sheet's own document_id
+                                docs_list = table_to_document(sheet, document_id=sheet_doc_id)
+                                table_documents.extend(docs_list)
+                                
+                                for doc in docs_list:
+                                    stats['total_tables'] += 1
+                                    size = doc.metadata.get('content_size', 0)
+                                    stats['total_size'] += size
+                                    stats['by_document'][sheet_doc_id]['count'] += 1
+                                    stats['by_document'][sheet_doc_id]['size'] += size
+                        else:
+                            # Single table
+                            docs_list = table_to_document(table_data, document_id=file_level_doc_id)
                             table_documents.extend(docs_list)
-                    else:
-                        table_data['document_id'] = document_id
-                        table_data['document'] = document_id
-                        docs_list = table_to_document(table_data, document_id=document_id)
-                        table_documents.extend(docs_list)
-                    
-        except Exception as e:
-            log_message(f"Ошибка {file_path}: {str(e)}")
-            continue
-    
-    return table_documents
-
+                            
+                            for doc in docs_list:
+                                stats['total_tables'] += 1
+                                size = doc.metadata.get('content_size', 0)
+                                stats['total_size'] += size
+                                stats['by_document'][file_level_doc_id]['count'] += 1
+                                stats['by_document'][file_level_doc_id]['size'] += size
+                        
+            except Exception as e:
+                log_message(f"❌ ОШИБКА файла {file_path}: {str(e)}")
+                import traceback
+                log_message(f"Traceback: {traceback.format_exc()}")
+                continue
+        
+        # Log summary
+        log_message("\n" + "=" * 60)
+        log_message("СТАТИСТИКА ПО ТАБЛИЦАМ")
+        log_message("=" * 60)
+        log_message(f"Всего таблиц: {stats['total_tables']}")
+        log_message(f"Общий размер: {stats['total_size']:,} символов")
+        if stats['total_tables'] > 0:
+            log_message(f"Средний размер: {stats['total_size'] // stats['total_tables']:,} символов")
+        
+        log_message("\nПо документам:")
+        for doc_id, doc_stats in sorted(stats['by_document'].items()):
+            log_message(f"  • {doc_id}: {doc_stats['count']} таблиц, {doc_stats['size']:,} символов")
+        
+        log_message("=" * 60)
+        
+        return table_documents
+        
+    except Exception as e:
+        log_message(f"❌ КРИТИЧЕСКАЯ ОШИБКА: {str(e)}")
+        import traceback
+        log_message(f"Traceback: {traceback.format_exc()}")
+        return []
 
 def load_csv_chunks(repo_id, hf_token, chunks_filename, download_dir):
     log_message("Загружаю данные чанков из CSV")

table_prep.py

@@ -3,7 +3,23 @@ from llama_index.core import Document
 from config import CHUNK_SIZE, CHUNK_OVERLAP
 from my_logging import log_message
 
+def normalize_table_number(table_num, section):
+    """Normalize table numbers for consistent retrieval"""
+    if not table_num or table_num == 'Неизвестно':
+        return 'Неизвестно'
+    
+    # Clean up common prefixes
+    tn = str(table_num).replace('Таблица', '').replace('№', '').strip()
+    
+    # Add section context for appendix tables
+    if section and ('Приложение' in str(section) or 'приложение' in str(section).lower()):
+        return f"№{tn} ({section})"
+    
+    return f"№{tn}"
+
+
 def create_table_content(table_data):
+    """Create formatted content with strong contextual anchors"""
     doc_id = (
         table_data.get('document_id') or 
         table_data.get('document') or 
@@ -18,80 +34,46 @@ def create_table_content(table_data):
         'Неизвестно'
     )
     
-    content = f"ГОСТ {doc_id} Стандарт {doc_id}\n"
+    # Normalize table number
+    normalized_num = normalize_table_number(table_num, section)
+    
+    # STRONG ANCHOR: Unique identification for semantic search
+    content = f"=== ИСТОЧНИК ДАННЫХ ===\n"
     content += f"Документ: {doc_id}\n"
-    content += f"Таблица {table_num}\n"
-    content += f"Название: {table_title}\n"
+    content += f"Стандарт: {doc_id}\n"
     content += f"Раздел: {section}\n"
-    
-    if 'Приложени' in section:
-        content += f"Приложение таблица {table_num}\n"
+    content += f"Таблица: {normalized_num}\n"
+    content += f"Полное название: {table_title}\n"
+    content += f"Уникальный ID: {doc_id} | {section} | {normalized_num}\n"
+    content += f"======================\n\n"
     
     headers = table_data.get('headers', [])
     if headers:
-        content += f"\nКолонки: {' | '.join(str(h) for h in headers)}\n"
+        content += f"Заголовки колонок: {' | '.join(str(h) for h in headers)}\n\n"
     
+    # Structured row data with JSON-like clarity
     if 'data' in table_data and isinstance(table_data['data'], list):
-        content += "\nДанные:\n"
+        content += "Содержимое таблицы:\n"
         for row_idx, row in enumerate(table_data['data'], start=1):
             if isinstance(row, dict):
-                for k, v in row.items():
-                    if v and str(v).strip():
-                        content += f"{k} {v} "
-                content += "\n"
+                # Add row identifier if available
+                row_id = row.get('Условное обозначение сварного соединения', 
+                                row.get('Обозначение', ''))
+                if row_id:
+                    content += f"Строка {row_idx} ({row_id}): "
+                else:
+                    content += f"Строка {row_idx}: "
+                
+                # Structured key-value pairs for better semantic understanding
+                row_parts = [f"{k}={v}" for k, v in row.items() if v and str(v).strip()]
+                content += " | ".join(row_parts) + "\n"
             elif isinstance(row, list):
-                content += " ".join([str(v) for v in row if v]) + "\n"
+                content += f"Строка {row_idx}: "
+                content += " | ".join([str(v) for v in row if v and str(v).strip()]) + "\n"
     
-    return content
+    return content, normalized_num
 
 
-def table_to_document(table_data, document_id=None):
-    if not isinstance(table_data, dict):
-        return []
-    
-    doc_id = (
-        document_id or 
-        table_data.get('document_id') or 
-        table_data.get('document') or 
-        table_data.get('Обозначение документа') or
-        'Неизвестно'
-    )
-    
-    if 'НП-104-18' in str(table_data.get('document', '')):
-        doc_id = 'ГОСТ 59023'
-    
-    table_num = table_data.get('table_number', 'Неизвестно')
-    table_title = table_data.get('table_title', 'Неизвестно')
-    section = (
-        table_data.get('section') or 
-        table_data.get('Раздел документа') or
-        'Неизвестно'
-    )
-    
-    table_rows = table_data.get('data', [])
-    if not table_rows:
-        return []
-    
-    content = create_table_content(table_data)
-    
-    base_doc = Document(
-        text=content,
-        metadata={
-            "type": "table",
-            "table_number": str(table_num),
-            "table_title": str(table_title),
-            "document_id": str(doc_id),
-            "section": str(section),
-            "total_rows": len(table_rows),
-            "content_size": len(content)
-        }
-    )
-    
-    if len(content) > CHUNK_SIZE:
-        return chunk_table_document(base_doc)
-    else:
-        return [base_doc]
-
 def chunk_table_document(doc, chunk_size=None, chunk_overlap=None):
     if chunk_size is None:
         chunk_size = CHUNK_SIZE
@@ -100,16 +82,21 @@ def chunk_table_document(doc, chunk_size=None, chunk_overlap=None):
     
     table_num = doc.metadata.get('table_number', 'unknown')
     doc_id = doc.metadata.get('document_id', 'unknown')
+    section = doc.metadata.get('section', 'Неизвестно')
+    table_title = doc.metadata.get('table_title', 'Неизвестно')
+    
+    # Create unique anchor for this table
+    full_table_id = f"{doc_id} | {section} | {table_num}"
     
-    # Parse table structure
     lines = doc.text.strip().split('\n')
     
+    # Extract header (everything before data rows)
     table_header_lines = []
     data_rows = []
     in_data = False
     
     for line in lines:
-        if line.startswith('Данные таблицы:'):
+        if line.startswith('Содержимое таблицы:'):
             in_data = True
             table_header_lines.append(line)
         elif in_data and line.startswith('Строка'):
@@ -119,16 +106,14 @@ def chunk_table_document(doc, chunk_size=None, chunk_overlap=None):
     
     table_header = '\n'.join(table_header_lines) + '\n'
     
-    # If no data rows or small table, use standard splitting
     if not data_rows or len(doc.text) < chunk_size * 1.5:
-        log_message(f"  📊 Таблица {table_num}: малая, без разбиения")
+        log_message(f"  📊 {full_table_id}: малая таблица, без разбиения")
         return [doc]
     
-    # Row-block chunking for large tables
-    log_message(f"  📋 Таблица {table_num}: {len(data_rows)} строк → row-block chunking")
+    log_message(f"  📋 {full_table_id}: {len(data_rows)} строк → chunking")
     
     header_size = len(table_header)
-    available_size = chunk_size - header_size - 100  # Reserve space
+    available_size = chunk_size - header_size - 200  # More reserve for anchor
     
     text_chunks = []
     current_chunk_rows = []
@@ -137,28 +122,25 @@ def chunk_table_document(doc, chunk_size=None, chunk_overlap=None):
     for row in data_rows:
         row_size = len(row) + 1
         
-        # Check if adding this row exceeds limit
         if current_size + row_size > available_size and current_chunk_rows:
-            # Create chunk with header + rows
             chunk_text = table_header + '\n'.join(current_chunk_rows)
             text_chunks.append(chunk_text)
             
-            # Overlap: keep last 2 rows for context continuity
-            overlap_count = min(2, len(current_chunk_rows))
+            # Overlap: keep last 3 rows for better context
+            overlap_count = min(3, len(current_chunk_rows))
             current_chunk_rows = current_chunk_rows[-overlap_count:]
             current_size = sum(len(r) + 1 for r in current_chunk_rows)
         
         current_chunk_rows.append(row)
         current_size += row_size
     
-    # Final chunk
     if current_chunk_rows:
         chunk_text = table_header + '\n'.join(current_chunk_rows)
         text_chunks.append(chunk_text)
     
-    log_message(f"  ✂️ Таблица {table_num} → {len(text_chunks)} чанков")
+    log_message(f"  ✂️ {full_table_id} → {len(text_chunks)} чанков")
     
-    # Create Document objects
+    # Create chunks with strong anchors
     chunked_docs = []
     for i, chunk_text in enumerate(text_chunks):
         chunk_metadata = doc.metadata.copy()
@@ -166,7 +148,12 @@ def chunk_table_document(doc, chunk_size=None, chunk_overlap=None):
             "chunk_id": i,
             "total_chunks": len(text_chunks),
             "chunk_size": len(chunk_text),
-            "is_chunked": True
+            "is_chunked": True,
+            # CRITICAL: Add unique identifiers
+            "full_table_id": full_table_id,
+            "chunk_anchor": f"{full_table_id} | chunk_{i+1}/{len(text_chunks)}",
+            "document_section": section,
+            "table_number_normalized": table_num
         })
         
         chunked_doc = Document(
@@ -177,49 +164,53 @@ def chunk_table_document(doc, chunk_size=None, chunk_overlap=None):
     
     return chunked_docs
 
+
 def table_to_document(table_data, document_id=None):
+    """Convert table data to Document with proper metadata"""
     if not isinstance(table_data, dict):
         return []
     
-    doc_id = (
-        document_id or 
+    # FIXED: Extract sheet-level document_id first
+    sheet_doc_id = (
         table_data.get('document_id') or 
         table_data.get('document') or 
-        table_data.get('Обозначение документа') or
-        'Неизвестно'
+        table_data.get('Обозначение документа')
     )
     
-    if 'НП-104-18' in str(table_data.get('document', '')):
-        doc_id = 'ГОСТ 59023'
+    # Use sheet doc_id if available, otherwise use passed document_id
+    doc_id = sheet_doc_id or document_id or 'Неизвестно'
     
     table_num = table_data.get('table_number', 'Неизвестн��')
     table_title = table_data.get('table_title', 'Неизвестно')
-    section = (
-        table_data.get('section') or 
-        table_data.get('Раздел документа') or
-        'Неизвестно'
-    )
+    section = table_data.get('section', table_data.get('Раздел документа', 'Неизвестно'))
     
     table_rows = table_data.get('data', [])
     if not table_rows:
+        log_message(f"⚠️ Таблица {table_num} ({doc_id}) пропущена: нет данных")
         return []
     
-    content = create_table_content(table_data)
+    content, normalized_num = create_table_content(table_data)
+    content_size = len(content)
     
     base_doc = Document(
         text=content,
         metadata={
             "type": "table",
-            "table_number": str(table_num),
-            "table_title": str(table_title),
-            "document_id": str(doc_id),
-            "section": str(section),
+            "table_number": table_num,
+            "table_number_normalized": normalized_num,
+            "table_title": table_title,
+            "document_id": doc_id,
+            "section": section,
+            "section_id": section,
             "total_rows": len(table_rows),
-            "content_size": len(content)
+            "content_size": content_size,
+            "full_table_id": f"{doc_id} | {section} | {normalized_num}"
         }
     )
     
-    if len(content) > CHUNK_SIZE:
+    if content_size > CHUNK_SIZE:
+        log_message(f"📊 CHUNKING: {doc_id} | {normalized_num} | {content_size} > {CHUNK_SIZE}")
         return chunk_table_document(base_doc)
     else:
+        log_message(f"✓ {doc_id} | {normalized_num} ({content_size} символов)")
         return [base_doc]