new function for should keep table whole for some files

app.py

@@ -80,11 +80,14 @@ def create_interface():
         ask_btn = gr.Button("Найти ответ", variant="primary")
 
         gr.Examples(
-            examples=[
-                "О чем таблица А.12 в ГОСТ Р 59023.4-2020?",
-                "Какая температура подогрева для стали 20 толщиной до 100 мм?",
-                "Что показано на рисунке Л.2 в ГОСТ Р 50.04.07-2022?"
-            ],
+                    examples=[
+                            "О чем этот рисунок: ГОСТ Р 50.04.07-2022 Приложение Л. Л.1.5 Рисунок Л.2",
+                            "Л.9 Формула в ГОСТ Р 50.04.07 - 2022 что и о чем там?", 
+                            "Какой стандарт устанавливает порядок признания протоколов испытаний продукции в области использования атомной энергии?",
+                            "Кто несет ответственность за организацию и проведение признания протоколов испытаний продукции?",
+                            "В каких случаях могут быть признаны протоколы испытаний, проведенные лабораториями?",
+                            "В какой таблице можно найти информацию о методы исследований при аттестационных испытаниях технологии термической обработки заготовок из легированных сталей? Какой документ и какой раздел?"
+                        ],
             inputs=question
         )
 

documents_prep.py

@@ -5,6 +5,7 @@ from huggingface_hub import hf_hub_download, list_repo_files
 from llama_index.core import Document
 from llama_index.core.text_splitter import SentenceSplitter
 from my_logging import log_message
+import re
 
 # Configuration
 CHUNK_SIZE = 1500
@@ -37,14 +38,32 @@ def chunk_text_documents(documents):
     
     return chunked
 
+def should_keep_table_whole(doc_id):
+    """Check if document should be kept as single chunk"""
+    special_patterns = [
+        r'НП\s*068-05',
+        r'НП-068-05',
+        r'59023',
+        r'ГОСТ\s*Р?\s*59023'
+    ]
+    
+    for pattern in special_patterns:
+        if re.search(pattern, doc_id, re.IGNORECASE):
+            return True
+    return False
 
-def chunk_table_by_rows(table_data, doc_id, rows_per_chunk=20, max_chars=2000):
+def chunk_table_by_rows(table_data, doc_id, rows_per_chunk=3, max_chars=2000):
     headers = table_data.get('headers', [])
     rows = table_data.get('data', [])
     table_num = str(table_data.get('table_number', 'unknown')).strip()
     table_title = table_data.get('table_title', '')
     section = table_data.get('section', '')
     
+    # CHECK FOR SPECIAL FILES - NO CHUNKING
+    if should_keep_table_whole(doc_id):
+        log_message(f"  📊 FULL TABLE (special file): {doc_id} - {table_num}")
+        return create_full_table_chunk(table_data, doc_id)
+    
     # Section-aware identifier (keep your existing logic)
     import re
     if 'приложени' in section.lower():
@@ -57,9 +76,6 @@ def chunk_table_by_rows(table_data, doc_id, rows_per_chunk=20, max_chars=2000):
     else:
         table_identifier = table_num
     
-    if not rows:
-        return []
-    
     log_message(f"  📊 Processing: {doc_id} - {table_identifier} ({len(rows)} rows)")
     
     # Build base header (compact version)
@@ -149,6 +165,74 @@ def chunk_table_by_rows(table_data, doc_id, rows_per_chunk=20, max_chars=2000):
     return chunks
 
 
+def create_full_table_chunk(table_data, doc_id):
+    """Create a single chunk for entire table (no splitting)"""
+    headers = table_data.get('headers', [])
+    rows = table_data.get('data', [])
+    table_num = str(table_data.get('table_number', 'unknown')).strip()
+    table_title = table_data.get('table_title', '')
+    section = table_data.get('section', '')
+    
+    # Section-aware identifier
+    import re
+    if 'приложени' in section.lower():
+        appendix_match = re.search(r'приложени[еия]\s*(\d+|[а-яА-Я])', section.lower())
+        if appendix_match:
+            appendix_num = appendix_match.group(1).upper()
+            table_identifier = f"{table_num} Приложение {appendix_num}"
+        else:
+            table_identifier = table_num
+    else:
+        table_identifier = table_num
+    
+    # Build full content
+    content = f"ДОКУМЕНТ: {doc_id} | ТАБЛИЦА: {table_identifier}\n"
+    if table_title:
+        content += f"НАЗВАНИЕ: {table_title}\n"
+    content += f"РАЗДЕЛ: {section}\n"
+    content += f"{'='*60}\n"
+    
+    if headers:
+        header_str = ' | '.join(str(h) for h in headers)
+        content += f"ЗАГОЛОВКИ: {header_str}\n\n"
+    
+    content += "ДАННЫЕ (ПОЛНАЯ ТАБЛИЦА):\n"
+    
+    for i, row in enumerate(rows, 1):
+        row_text = format_single_row(row, i)
+        if row_text:
+            content += row_text
+    
+    content += f"\n[Полная таблица: {len(rows)} строк]\n"
+    
+    # Embed metadata in text
+    content += f"\n\n--- МЕТАДАННЫЕ ---\n"
+    content += f"Документ: {doc_id}\n"
+    content += f"Таблица: {table_identifier}\n"
+    content += f"Название таблицы: {table_title}\n"
+    content += f"Раздел: {section}\n"
+    content += f"Всего строк: {len(rows)}\n"
+    
+    metadata = {
+        'type': 'table',
+        'document_id': doc_id,
+        'table_number': table_num,
+        'table_identifier': table_identifier,
+        'table_title': table_title,
+        'section': section,
+        'chunk_id': 0,
+        'row_start': 0,
+        'row_end': len(rows),
+        'total_rows': len(rows),
+        'chunk_size': len(content),
+        'is_complete_table': True,
+        'chunking_strategy': 'full_table',
+        'rows_in_chunk': len(rows)
+    }
+    
+    return [Document(text=content, metadata=metadata)]
+
+
 def _create_chunk(base_header, batch, table_identifier, doc_id, 
                   table_num, table_title, section, total_rows, 
                   chunk_num, is_complete):
@@ -289,6 +373,14 @@ def load_table_documents(repo_id, hf_token, table_dir):
     table_files = [f for f in files if f.startswith(table_dir) and f.endswith('.json')]
     
     all_chunks = []
+    stats = {
+        'full_tables': 0,
+        'split_tables': 0,
+        'total_chunks': 0,
+        'full_table_sizes': [],
+        'split_chunk_sizes': []
+    }
+    
     for file_path in table_files:
         try:
             local_path = hf_hub_download(
@@ -306,17 +398,123 @@ def load_table_documents(repo_id, hf_token, table_dir):
             for sheet in data.get('sheets', []):
                 sheet_doc_id = sheet.get('document_id', sheet.get('document', file_doc_id))
                 
-                # USE NEW ADAPTIVE CHUNKING
                 chunks = chunk_table_by_rows(sheet, sheet_doc_id, max_chars=3072)
+                
+                # Track statistics
+                if chunks:
+                    is_full = chunks[0].metadata.get('is_complete_table', False)
+                    chunk_size = chunks[0].metadata.get('chunk_size', 0)
+                    
+                    if is_full:
+                        stats['full_tables'] += 1
+                        stats['full_table_sizes'].append(chunk_size)
+                        log_message(f"  📄 {sheet_doc_id}: FULL TABLE ({chunk_size} chars)")
+                    else:
+                        stats['split_tables'] += 1
+                        for c in chunks:
+                            stats['split_chunk_sizes'].append(c.metadata.get('chunk_size', 0))
+                        log_message(f"  📄 {sheet_doc_id}: {len(chunks)} chunks (split)")
+                    
+                    stats['total_chunks'] += len(chunks)
+                
                 all_chunks.extend(chunks)
-                log_message(f"  📄 {sheet_doc_id}: {len(chunks)} chunks")
+                
         except Exception as e:
             log_message(f"Error loading {file_path}: {e}")
     
-    log_message(f"✓ Loaded {len(all_chunks)} table chunks")
+    # Print final statistics
+    log_message(f"\n{'='*60}")
+    log_message(f"TABLE LOADING STATISTICS:")
+    log_message(f"  Total chunks created: {stats['total_chunks']}")
+    log_message(f"  Full tables (no split): {stats['full_tables']}")
+    log_message(f"  Split tables: {stats['split_tables']}")
+    
+    if stats['full_table_sizes']:
+        avg_full = sum(stats['full_table_sizes']) / len(stats['full_table_sizes'])
+        log_message(f"  Full table avg size: {avg_full:.0f} chars")
+        log_message(f"  Full table size range: {min(stats['full_table_sizes'])} - {max(stats['full_table_sizes'])} chars")
+    
+    if stats['split_chunk_sizes']:
+        avg_split = sum(stats['split_chunk_sizes']) / len(stats['split_chunk_sizes'])
+        log_message(f"  Split chunk avg size: {avg_split:.0f} chars")
+        log_message(f"  Split chunk size range: {min(stats['split_chunk_sizes'])} - {max(stats['split_chunk_sizes'])} chars")
+    
+    log_message(f"{'='*60}\n")
+    
     return all_chunks
 
 
+def create_whole_table_chunk(table_data, doc_id):
+    """Create a single chunk for the entire table (no splitting)"""
+    headers = table_data.get('headers', [])
+    rows = table_data.get('data', [])
+    table_num = str(table_data.get('table_number', 'unknown')).strip()
+    table_title = table_data.get('table_title', '')
+    section = table_data.get('section', '')
+    
+    # Section-aware identifier
+    import re
+    if 'приложени' in section.lower():
+        appendix_match = re.search(r'приложени[еия]\s*(\d+|[а-яА-Я])', section.lower())
+        if appendix_match:
+            appendix_num = appendix_match.group(1).upper()
+            table_identifier = f"{table_num} Приложение {appendix_num}"
+        else:
+            table_identifier = table_num
+    else:
+        table_identifier = table_num
+    
+    if not rows:
+        return []
+    
+    log_message(f"  📊 Creating WHOLE table: {doc_id} - {table_identifier} ({len(rows)} rows)")
+    
+    # Build complete table content
+    content = f"ДОКУМЕНТ: {doc_id} | ТАБЛИЦА: {table_identifier}\n"
+    if table_title:
+        content += f"НАЗВАНИЕ: {table_title}\n"
+    content += f"{'='*60}\n"
+    
+    if headers:
+        header_str = ' | '.join(str(h) for h in headers)
+        content += f"ЗАГОЛОВКИ: {header_str}\n\n"
+    
+    content += "ДАННЫЕ:\n"
+    
+    # Add ALL rows
+    for i, row in enumerate(rows, 1):
+        row_text = format_single_row(row, i)
+        if row_text:
+            content += row_text
+    
+    # Add metadata section
+    content += f"\n\n--- МЕТАДАННЫЕ ---\n"
+    content += f"Документ: {doc_id}\n"
+    content += f"Таблица: {table_identifier}\n"
+    content += f"Название таблицы: {table_title}\n"
+    content += f"Раздел: {section}\n"
+    content += f"Полная таблица: {len(rows)} строк\n"
+    
+    metadata = {
+        'type': 'table',
+        'document_id': doc_id,
+        'table_number': table_num,
+        'table_identifier': table_identifier,
+        'table_title': table_title,
+        'section': section,
+        'chunk_id': 0,
+        'row_start': 0,
+        'row_end': len(rows),
+        'total_rows': len(rows),
+        'chunk_size': len(content),
+        'is_complete_table': True,
+        'rows_in_chunk': len(rows)
+    }
+    
+    log_message(f"    Created 1 chunk with {len(rows)} rows ({len(content)} chars)")
+    
+    return [Document(text=content, metadata=metadata)]
+
 def load_json_documents(repo_id, hf_token, json_dir):
     import zipfile
     import tempfile