Upload folder using huggingface_hub

criteria_search_terms.csv

@@ -0,0 +1,63 @@
+term
+quality
+helpfulness
+harmlessness
+safety
+groundedness
+honesty
+truthfulness
+hallucinations
+empathy
+politeness
+relevance
+verbosity
+component
+aggregation
+ranking
+weighting
+tradeoffs
+other
+nonspecific
+grice
+specific
+otherframework
+conversations
+humanai
+annotation
+separate
+naturalistic
+hybrid
+synthetic
+datasetname
+datasetsource
+dialogs
+annotators
+context
+annotator
+single
+multi
+prerecorded
+realtime
+scales
+binary
+validated
+notes
+named
+unspecified
+family
+rlhf
+partial
+collected
+reward
+policy
+stage
+benchmark
+judge
+comparators
+winrate
+strategy
+gains
+losses
+inconsistent
+unchanged
+quantified

filterlm_previous.py

@@ -0,0 +1,1714 @@
+import os
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+# API Key Configuration - Set your API keys here or as environment variables
+MISTRAL_API_KEY = os.environ.get("MISTRAL_API_KEY", "")
+OPENAI_API_KEY = os.environ.get("OPENAI_API_KEY", "")
+NEBIUS_API_KEY = os.environ.get("NEBIUS_API_KEY", "")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY", "")
+ANTHROPIC_API_KEY = os.environ.get("ANTHROPIC_API_KEY", "")
+GROK_API_KEY = os.environ.get("GROK_API_KEY", "")
+HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
+
+# Import pandas for table display
+try:
+    import pandas as pd
+except ImportError:
+    pd = None
+
+# Import API libraries
+try:
+    import openai
+    from openai import OpenAI
+except ImportError:
+    openai = None
+    OpenAI = None
+
+try:
+    import google.generativeai as genai
+except ImportError:
+    genai = None
+
+try:
+    from mistralai import Mistral
+    MISTRAL_AVAILABLE = True
+except ImportError as e:
+    Mistral = None
+    MISTRAL_AVAILABLE = False
+    print(f"Mistral import failed: {e}")
+    print("Please install mistralai package with: pip install mistralai")
+except Exception as e:
+    Mistral = None
+    MISTRAL_AVAILABLE = False
+    print(f"Mistral import error: {e}")
+
+try:
+    import anthropic
+except ImportError:
+    anthropic = None
+
+import datetime
+import functools
+import traceback
+from typing import List, Optional, Any, Dict
+import re
+import time
+import threading
+import uuid
+import csv
+import requests
+import mimetypes
+import tempfile
+try:
+    from pdfminer.high_level import extract_text
+except ImportError:
+    # Fallback for older pdfminer versions
+    from pdfminer.pdfinterp import PDFResourceManager, PDFPageInterpreter
+    from pdfminer.converter import TextConverter
+    from pdfminer.layout import LAParams
+    from pdfminer.pdfpage import PDFPage
+    from io import StringIO
+import statistics
+import glob
+import urllib.parse
+from pathlib import Path
+
+import torch
+import transformers
+from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+from langchain_community.llms import HuggingFacePipeline
+from langchain_community.document_loaders import OnlinePDFLoader, PyPDFLoader
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.vectorstores import FAISS
+from langchain.embeddings import HuggingFaceEmbeddings  
+from langchain_community.retrievers import BM25Retriever
+from langchain.retrievers import EnsembleRetriever
+from langchain.prompts import ChatPromptTemplate
+from langchain.schema import StrOutputParser, Document
+from langchain_core.runnables import RunnableParallel, RunnableLambda
+from transformers.quantizers.auto import AutoQuantizationConfig
+import gradio as gr
+import requests
+from pydantic import PrivateAttr
+import pydantic
+import zipfile
+import mimetypes
+
+from langchain.llms.base import LLM
+from typing import Any, Optional, List
+import typing
+
+# Debug print function
+def debug_print(message):
+    print(f"[DEBUG] {message}")
+
+# Google Drive processing functions
+def get_confirm_token(response):
+    for key, value in response.cookies.items():
+        if key.startswith("download_warning"):
+            return value
+    return None
+
+def download_file_from_google_drive(file_id, destination):
+    """
+    Download a file from Google Drive handling large file confirmation.
+    """
+    URL = "https://docs.google.com/uc?export=download&confirm=1"
+    session = requests.Session()
+    response = session.get(URL, params={"id": file_id}, stream=True)
+    token = get_confirm_token(response)
+    if token:
+        params = {"id": file_id, "confirm": token}
+        response = session.get(URL, params=params, stream=True)
+    save_response_content(response, destination)
+
+def save_response_content(response, destination):
+    CHUNK_SIZE = 32768
+    with open(destination, "wb") as f:
+        for chunk in response.iter_content(CHUNK_SIZE):
+            if chunk:
+                f.write(chunk)
+
+def extract_file_id(drive_link: str) -> str:
+    # Check for /d/ format (including with view?usp=drive_link)
+    match = re.search(r"/d/([a-zA-Z0-9_-]+)", drive_link)
+    if match:
+        return match.group(1)
+    
+    # Check for open?id= format
+    match = re.search(r"open\?id=([a-zA-Z0-9_-]+)", drive_link)
+    if match:
+        return match.group(1)
+        
+    raise ValueError("Could not extract file ID from the provided Google Drive link.")
+
+def load_pdf_from_google_drive(link: str) -> str:
+    """
+    Load a PDF document from a Google Drive link using pdfminer to extract text.
+    Returns the extracted text as a string.
+    """
+    file_id = extract_file_id(link)
+    debug_print(f"Extracted file ID: {file_id}")
+    with tempfile.NamedTemporaryFile(delete=False) as temp_file:
+        temp_path = temp_file.name
+    try:
+        download_file_from_google_drive(file_id, temp_path)
+        debug_print(f"File downloaded to: {temp_path}")
+        try:
+            try:
+                # Try the high-level API first
+                full_text = extract_text(temp_path)
+            except NameError:
+                # Fallback to low-level API if high-level is not available
+                full_text = extract_text_fallback(temp_path)
+            
+            if not full_text.strip():
+                raise ValueError("Extracted text is empty. The PDF might be image-based.")
+            debug_print("Extracted preview text from PDF:")
+            debug_print(full_text[:1000])  # Preview first 1000 characters
+            return full_text
+        except Exception as e:
+            debug_print(f"Could not extract text from PDF: {e}")
+            return ""
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+def extract_text_fallback(pdf_path):
+    """Fallback text extraction for older pdfminer versions"""
+    resource_manager = PDFResourceManager()
+    fake_file_handle = StringIO()
+    converter = TextConverter(resource_manager, fake_file_handle, laparams=LAParams())
+    page_interpreter = PDFPageInterpreter(resource_manager, converter)
+    
+    with open(pdf_path, 'rb') as fh:
+        for page in PDFPage.get_pages(fh, caching=True, check_extractable=True):
+            page_interpreter.process_page(page)
+        text = fake_file_handle.getvalue()
+    
+    converter.close()
+    fake_file_handle.close()
+    return text
+
+def load_file_from_google_drive(link: str) -> str:
+    """
+    Load a document from a Google Drive link, detecting whether it's a PDF or TXT file.
+    Returns the extracted text as a string.
+    """
+    file_id = extract_file_id(link)
+    
+    # Create direct download link
+    download_url = f"https://drive.google.com/uc?export=download&id={file_id}"
+    
+    # First, try to read a small portion of the file to determine its type
+    try:
+        # Use a streaming request to read just the first part of the file
+        response = requests.get(download_url, stream=True)
+        if response.status_code != 200:
+            raise ValueError(f"Failed to download file from Google Drive. Status code: {response.status_code}")
+        
+        # Read just the first 1024 bytes to check file signature
+        file_start = next(response.iter_content(1024))
+        response.close()  # Close the stream
+        
+        # Convert bytes to string for pattern matching
+        file_start_str = file_start.decode('utf-8', errors='ignore')
+        
+        # Check for PDF signature (%PDF-) at the beginning of the file
+        if file_start_str.startswith('%PDF-') or b'%PDF-' in file_start:
+            debug_print(f"Detected PDF file by content signature from Google Drive: {link}")
+            return load_pdf_from_google_drive(link)
+        else:
+            # If not a PDF, try as text
+            debug_print(f"No PDF signature found, treating as TXT file from Google Drive: {link}")
+            
+            # Since we already downloaded part of the file, get the full content
+            response = requests.get(download_url)
+            if response.status_code != 200:
+                raise ValueError(f"Failed to download complete file from Google Drive. Status code: {response.status_code}")
+            
+            content = response.text
+            if not content.strip():
+                raise ValueError(f"TXT file from Google Drive is empty.")
+            
+            return content
+            
+    except UnicodeDecodeError:
+        # If we get a decode error, it's likely a binary file like PDF
+        debug_print(f"Got decode error, likely a binary file. Treating as PDF from Google Drive: {link}")
+        return load_pdf_from_google_drive(link)
+    except Exception as e:
+        debug_print(f"Error detecting file type: {e}")
+        
+        # Fall back to trying both formats
+        debug_print("Falling back to trying both formats for Google Drive file")
+        try:
+            return load_pdf_from_google_drive(link)
+        except Exception as txt_error:
+            debug_print(f"Failed to load as PDF: {txt_error}")
+            try:
+                response = requests.get(download_url)
+                if response.status_code != 200:
+                    raise ValueError(f"Failed to download complete file from Google Drive. Status code: {response.status_code}")
+                content = response.text
+                if not content.strip():
+                    raise ValueError(f"TXT file from Google Drive is empty.")
+                return content
+            except Exception as txt_error2:
+                debug_print(f"Failed to load as TXT: {txt_error2}")
+                raise ValueError(f"Could not load file from Google Drive as either PDF or TXT: {link}")
+
+def extract_folder_id(drive_link: str) -> str:
+    """Extract folder ID from Google Drive folder link"""
+    # Check for /folders/ format
+    match = re.search(r"/folders/([a-zA-Z0-9_-]+)", drive_link)
+    if match:
+        return match.group(1)
+    
+    # Check for open?id= format for folders
+    match = re.search(r"open\?id=([a-zA-Z0-9_-]+)", drive_link)
+    if match:
+        return match.group(1)
+        
+    raise ValueError("Could not extract folder ID from the provided Google Drive folder link.")
+
+def list_files_in_gdrive_folder(folder_link: str) -> List[str]:
+    """
+    List all files in a Google Drive folder and return their direct download links.
+    This uses a simple web scraping approach to get file links from the folder.
+    """
+    try:
+        folder_id = extract_folder_id(folder_link)
+        debug_print(f"Extracted folder ID: {folder_id}")
+        
+        # Create the folder URL
+        folder_url = f"https://drive.google.com/drive/folders/{folder_id}"
+        
+        # Try to get the folder page content
+        response = requests.get(folder_url)
+        if response.status_code != 200:
+            debug_print(f"Failed to access Google Drive folder. Status code: {response.status_code}")
+            return []
+        
+        # Look for file links in the page content
+        # This is a basic approach - Google Drive uses JavaScript to load content
+        # so this might not work for all cases
+        content = response.text
+        
+        # Look for file IDs in the content
+        file_id_pattern = r'data-id="([a-zA-Z0-9_-]+)"'
+        file_ids = re.findall(file_id_pattern, content)
+        
+        # Also look for other patterns that might contain file IDs
+        if not file_ids:
+            # Try alternative patterns
+            alt_patterns = [
+                r'"/file/d/([a-zA-Z0-9_-]+)/"',
+                r'"id":"([a-zA-Z0-9_-]+)"',
+                r'data-id="([a-zA-Z0-9_-]+)"'
+            ]
+            
+            for pattern in alt_patterns:
+                matches = re.findall(pattern, content)
+                if matches:
+                    file_ids.extend(matches)
+                    break
+        
+        if file_ids:
+            # Convert file IDs to direct download links
+            file_links = []
+            for file_id in file_ids:
+                # Skip if it's the same as folder ID
+                if file_id != folder_id:
+                    file_link = f"https://drive.google.com/file/d/{file_id}/view".strip()
+                    file_links.append(file_link)
+                    debug_print(f"Found file: {file_link}")
+            
+            debug_print(f"Found {len(file_links)} files in Google Drive folder")
+            return file_links
+        else:
+            debug_print("No files found in Google Drive folder")
+            debug_print("Note: Google Drive folder listing may not work for all folder types")
+            debug_print("Please provide direct file links instead of folder links for better reliability")
+            return []
+        
+    except Exception as e:
+        debug_print(f"Error listing Google Drive folder: {e}")
+        debug_print("Please provide direct file links instead of folder links")
+        return []
+
+# Error patterns for retry logic
+error_patterns = [
+    r"error generating response:",
+    r"api error occurred:",
+    r"bad gateway",
+    r"cloudflare",
+    r"server disconnected without sending a response",
+    r"getaddrinfo failed"
+]
+
+# Model configurations
+models = [
+    # NEBIUS
+    {"provider": "nebius", "display": "🟦 DeepSeek-R1-0528 (Nebius) (32K)", "backend": "deepseek-ai/DeepSeek-R1-0528", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 DeepSeek-V3-0324 (Nebius) (32K)", "backend": "deepseek-ai/DeepSeek-V3-0324", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 DeepSeek-R1 (Nebius) (32K)", "backend": "deepseek-ai/DeepSeek-R1", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 DeepSeek-V3 (Nebius) (32K)", "backend": "deepseek-ai/DeepSeek-V3", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 DeepSeek-R1-Distill-Llama-70B (Nebius) (32K)", "backend": "deepseek-ai/DeepSeek-R1-Distill-Llama-70B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Meta-Llama-3.3-70B-Instruct (Nebius) (32K)", "backend": "meta-llama/Llama-3.3-70B-Instruct", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Meta-Llama-3.1-8B-Instruct (Nebius) (32K)", "backend": "meta-llama/Meta-Llama-3.1-8B-Instruct", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Meta-Llama-3.1-70B-Instruct (Nebius) (32K)", "backend": "meta-llama/Meta-Llama-3.1-70B-Instruct", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Meta-Llama-3.1-405B-Instruct (Nebius) (32K)", "backend": "meta-llama/Meta-Llama-3.1-405B-Instruct", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 NVIDIA Llama-3_1-Nemotron-Ultra-253B-v1 (Nebius) (32K)", "backend": "nvidia/Llama-3_1-Nemotron-Ultra-253B-v1", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 NVIDIA Llama-3_3-Nemotron-Super-49B-v1 (Nebius) (32K)", "backend": "nvidia/Llama-3_3-Nemotron-Super-49B-v1", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Mistral-Nemo-Instruct-2407 (Nebius) (32K)", "backend": "mistralai/Mistral-Nemo-Instruct-2407", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Microsoft phi-4 (Nebius) (32K)", "backend": "microsoft/phi-4", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen3-235B-A22B (Nebius) (32K)", "backend": "Qwen/Qwen3-235B-A22B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen3-30B-A3B (Nebius) (32K)", "backend": "Qwen/Qwen3-30B-A3B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen3-32B (Nebius) (32K)", "backend": "Qwen/Qwen3-32B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen3-14B (Nebius) (32K)", "backend": "Qwen/Qwen3-14B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen3-4B-fast (Nebius) (32K)", "backend": "Qwen/Qwen3-4B-fast", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 QwQ-32B (Nebius) (32K)", "backend": "Qwen/QwQ-32B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Google Gemma-2-2b-it (Nebius) (32K)", "backend": "google/gemma-2-2b-it", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Google Gemma-2-9b-it (Nebius) (32K)", "backend": "google/gemma-2-9b-it", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Hermes-3-Llama-405B (Nebius) (32K)", "backend": "NousResearch/Hermes-3-Llama-405B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Llama3-OpenBioLLM-70B (Nebius, Medical) (32K)", "backend": "aaditya/Llama3-OpenBioLLM-70B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen2.5-72B-Instruct (Nebius, Code) (32K)", "backend": "Qwen/Qwen2.5-72B-Instruct", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen2.5-Coder-7B (Nebius, Code) (32K)", "backend": "Qwen/Qwen2.5-Coder-7B", "max_tokens": 32768},
+    {"provider": "nebius", "display": "🟦 Qwen2.5-Coder-32B-Instruct (Nebius, Code) (32K)", "backend": "Qwen/Qwen2.5-Coder-32B-Instruct", "max_tokens": 32768},
+    
+    # HuggingFace
+    {"provider": "hf_inference", "display": "🤗 Remote Meta-Llama-3 (HuggingFace) (32K)", "backend": "meta-llama/Meta-Llama-3-8B-Instruct", "max_tokens": 32768},
+    {"provider": "hf_inference", "display": "🤗 SciFive PubMed Classifier (HuggingFace) (32K)", "backend": "razent/SciFive-base-Pubmed_PMC", "max_tokens": 32768},
+    {"provider": "hf_inference", "display": "🤗 Tiny GPT-2 Classifier (HuggingFace) (32K)", "backend": "ydshieh/tiny-random-GPT2ForSequenceClassification", "max_tokens": 32768},
+    {"provider": "hf_inference", "display": "🤗 ArabianGPT QA (0.4B) (HuggingFace) (32K)", "backend": "gp-tar4/QA_FineTuned_ArabianGPT-03B", "max_tokens": 32768},
+    {"provider": "hf_inference", "display": "🤗 Tiny Mistral Classifier (HuggingFace) (32K)", "backend": "xshubhamx/tiny-mistral", "max_tokens": 32768},
+    {"provider": "hf_inference", "display": "🤗 Hallucination Scorer (HuggingFace) (32K)", "backend": "tcapelle/hallu_scorer", "max_tokens": 32768},
+    
+    # Mistral
+    {"provider": "mistral", "display": "🇪🇺 Mistral-API (Mistral) (32K)", "backend": "mistral-small-latest", "max_tokens": 32768},
+    
+    # OpenAI
+    {"provider": "openai", "display": "🇺🇸 GPT-3.5 (OpenAI) (16K)", "backend": "gpt-3.5-turbo", "max_tokens": 16384},
+    {"provider": "openai", "display": "🇺🇸 GPT-4o (OpenAI) (128K)", "backend": "gpt-4o", "max_tokens": 131072},
+    {"provider": "openai", "display": "🇺🇸 GPT-4o mini (OpenAI) (128K)", "backend": "gpt-4o-mini", "max_tokens": 131072},
+    {"provider": "openai", "display": "🇺🇸 o1-mini (OpenAI) (128K)", "backend": "o1-mini", "max_tokens": 131072},
+    {"provider": "openai", "display": "🇺🇸 o3-mini (OpenAI) (128K)", "backend": "o3-mini", "max_tokens": 131072},
+    
+    # Grok (xAI)
+    {"provider": "grok", "display": "🦾 Grok 2 (xAI) (32K)", "backend": "grok-2", "max_tokens": 32768},
+    {"provider": "grok", "display": "🦾 Grok 3 (xAI) (32K)", "backend": "grok-3", "max_tokens": 32768},
+    
+    # Anthropic
+    {"provider": "anthropic", "display": "🟧 Sonnet 4 (Anthropic) (200K)", "backend": "sonnet-4", "max_tokens": 204800},
+    {"provider": "anthropic", "display": "🟧 Sonnet 3.7 (Anthropic) (200K)", "backend": "sonnet-3.7", "max_tokens": 204800},
+    
+    # Gemini (Google)
+    {"provider": "gemini", "display": "🔷 Gemini 2.5 Pro (Google) (1M)", "backend": "gemini-2.5-pro", "max_tokens": 1048576},
+    {"provider": "gemini", "display": "🔷 Gemini 2.5 Flash (Google) (1M)", "backend": "gemini-2.5-flash", "max_tokens": 1048576},
+    {"provider": "gemini", "display": "🔷 Gemini 2.5 Flash Lite Preview (Google) (1M)", "backend": "gemini-2.5-flash-lite-preview-06-17", "max_tokens": 1048576},
+    {"provider": "gemini", "display": "🔷 Gemini 2.0 Flash (Google) (1M)", "backend": "gemini-2.0-flash", "max_tokens": 1048576},
+    {"provider": "gemini", "display": "🔷 Gemini 2.0 Flash Preview Image Gen (Text+Image) (Google) (1M)", "backend": "gemini-2.0-flash-preview-image-generation", "max_tokens": 1048576},
+    {"provider": "gemini", "display": "🔷 Gemini 2.0 Flash Lite (Google) (1M)", "backend": "gemini-2.0-flash-lite", "max_tokens": 1048576},
+]
+
+# Global variables for job management
+jobs = {}
+last_job_id = None
+
+def get_pdf_files_from_source(source_path):
+    """Get list of PDF files from folder or URL(s)"""
+    pdf_files = []
+    
+    if not source_path or source_path.strip() == "":
+        # Use current directory if no path specified
+        source_path = "."
+    
+    # Check if it's a comma-separated list of URLs
+    if ',' in source_path and any(url.strip().startswith(('http://', 'https://')) or 'drive.google.com' in url.strip() for url in source_path.split(',')):
+        # Multiple URLs - split by comma and process each
+        urls = [url.strip() for url in source_path.split(',') if url.strip()]
+        for url in urls:
+            if url.startswith(('http://', 'https://')) or 'drive.google.com' in url:
+                # Check if it's a Google Drive folder
+                if '/folders/' in url or ('drive.google.com' in url and '/d/' not in url and 'open?id=' not in url):
+                    debug_print(f"Detected Google Drive folder: {url}")
+                    folder_files = list_files_in_gdrive_folder(url)
+                    pdf_files.extend(folder_files)
+                    debug_print(f"Added {len(folder_files)} files from folder")
+                else:
+                    pdf_files.append(url)
+                    debug_print(f"Added URL: {url}")
+            else:
+                debug_print(f"Skipping non-URL: {url}")
+    elif source_path.startswith(('http://', 'https://')) or 'drive.google.com' in source_path:
+        # Single URL source
+        if '/folders/' in source_path or ('drive.google.com' in source_path and '/d/' not in source_path and 'open?id=' not in source_path):
+            debug_print(f"Detected Google Drive folder: {source_path}")
+            folder_files = list_files_in_gdrive_folder(source_path)
+            pdf_files.extend(folder_files)
+            debug_print(f"Added {len(folder_files)} files from folder")
+        else:
+            pdf_files.append(source_path)
+            debug_print(f"Added single URL: {source_path}")
+    else:
+        # Local folder or file source
+        if os.path.isdir(source_path):
+            # Search for PDF files in the directory
+            pdf_pattern = os.path.join(source_path, "**", "*.pdf")
+            pdf_files = glob.glob(pdf_pattern, recursive=True)
+            debug_print(f"Found {len(pdf_files)} PDF files in directory: {source_path}")
+        elif os.path.isfile(source_path) and source_path.lower().endswith('.pdf'):
+            # Single PDF file
+            pdf_files.append(source_path)
+            debug_print(f"Added single PDF file: {source_path}")
+        else:
+            debug_print(f"Source path not found or not a PDF: {source_path}")
+    
+    debug_print(f"Total PDF files to process: {len(pdf_files)}")
+    return pdf_files
+
+def load_pdf_content(pdf_path):
+    """Load content from a PDF file"""
+    try:
+        if 'drive.google.com' in pdf_path:
+            # Google Drive PDF - handle directly to avoid pdfminer import issues
+            try:
+                full_text = load_file_from_google_drive(pdf_path)
+                if not full_text.strip():
+                    debug_print(f"Empty content from Google Drive PDF: {pdf_path}")
+                    return None
+                return full_text
+            except Exception as e:
+                debug_print(f"Error loading Google Drive PDF {pdf_path}: {e}")
+                return None
+        elif pdf_path.startswith(('http://', 'https://')):
+            # Online PDF - use OnlinePDFLoader for non-Google Drive URLs
+            try:
+                loader = OnlinePDFLoader(pdf_path)
+                documents = loader.load()
+                # Combine all pages into a single text
+                full_text = "\n\n".join([doc.page_content for doc in documents])
+                return full_text
+            except Exception as e:
+                debug_print(f"Error loading online PDF {pdf_path}: {e}")
+                return None
+        else:
+            # Local PDF
+            loader = PyPDFLoader(pdf_path)
+        documents = loader.load()
+        # Combine all pages into a single text
+        full_text = "\n\n".join([doc.page_content for doc in documents])
+        return full_text
+    except Exception as e:
+        debug_print(f"Error loading PDF {pdf_path}: {e}")
+        return None
+
+def submit_query_updated(query, model, temperature, top_p, top_k, max_tokens):
+    """Submit query to the specified model"""
+    debug_print(f"Submitting query to {model}")
+    
+    try:
+        # Find the model configuration to determine provider
+        model_config = next((m for m in models if m["backend"] == model), None)
+        if not model_config:
+            # Fallback to pattern matching if model not found in config
+            if model.startswith("gpt-") or model.startswith("o1-") or model.startswith("o3-"):
+                return call_openai_api(query, model, temperature, top_p, top_k, max_tokens)
+            elif model.startswith("gemini-"):
+                return call_gemini_api(query, model, temperature, top_p, top_k, max_tokens)
+            elif model.startswith("mistral-") or model.startswith("nemo-"):
+                return call_mistral_api(query, model, temperature, top_p, top_k, max_tokens)
+            elif model.startswith("claude-") or model.startswith("sonnet-"):
+                return call_anthropic_api(query, model, temperature, top_p, top_k, max_tokens)
+            elif model.startswith("grok-"):
+                return call_grok_api(query, model, temperature, top_p, top_k, max_tokens)
+            else:
+                return call_generic_api(query, model, temperature, top_p, top_k, max_tokens)
+        
+        # Route based on provider
+        provider = model_config["provider"]
+        if provider == "openai":
+            return call_openai_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif provider == "gemini":
+            return call_gemini_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif provider == "mistral":
+            return call_mistral_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif provider == "anthropic":
+            return call_anthropic_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif provider == "grok":
+            return call_grok_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif provider == "nebius":
+            return call_nebius_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif provider == "hf_inference":
+            return call_huggingface_api(query, model, temperature, top_p, top_k, max_tokens)
+        else:
+            return call_generic_api(query, model, temperature, top_p, top_k, max_tokens)
+    
+    except Exception as e:
+        debug_print(f"Error calling API for {model}: {e}")
+        # Return error response
+        error_response = f"Error calling {model}: {str(e)}"
+        return error_response, None, len(query.split()), len(error_response.split())
+
+def call_openai_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call OpenAI API"""
+    try:
+        if openai is None:
+            raise Exception("OpenAI library not installed. Install with: pip install openai")
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        response = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": query}],
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=min(max_tokens, 131072)  # Cap at 128K
+        )
+        
+        content = response.choices[0].message.content
+        input_tokens = response.usage.prompt_tokens
+        output_tokens = response.usage.completion_tokens
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"OpenAI API error: {e}")
+
+def call_gemini_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call Google Gemini API"""
+    try:
+        if genai is None:
+            raise Exception("Google Generative AI library not installed. Install with: pip install google-generativeai")
+        genai.configure(api_key=GEMINI_API_KEY)
+        
+        # Map model names to Gemini model names
+        model_mapping = {
+            "gemini-2.5-pro": "gemini-2.0-flash-exp",
+            "gemini-2.5-flash": "gemini-2.0-flash-exp", 
+            "gemini-2.5-flash-lite-preview-06-17": "gemini-2.0-flash-exp",
+            "gemini-2.0-flash": "gemini-2.0-flash-exp",
+            "gemini-2.0-flash-preview-image-generation": "gemini-2.0-flash-exp",
+            "gemini-2.0-flash-lite": "gemini-2.0-flash-exp"
+        }
+        
+        gemini_model_name = model_mapping.get(model, "gemini-2.0-flash-exp")
+        
+        # Configure generation parameters
+        generation_config = genai.types.GenerationConfig(
+            temperature=temperature,
+            top_p=top_p,
+            top_k=top_k,
+            max_output_tokens=min(max_tokens, 1048576)  # Cap at 1M
+        )
+        
+        # Get the model
+        model_instance = genai.GenerativeModel(gemini_model_name)
+        
+        # Generate content
+        response = model_instance.generate_content(
+            query,
+            generation_config=generation_config
+        )
+        
+        content = response.text
+        # Estimate tokens (rough approximation
+        input_tokens = len(query.split())
+        output_tokens = len(content.split())
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"Gemini API error: {e}")
+
+def call_mistral_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call Mistral API"""
+    try:
+        if not MISTRAL_AVAILABLE or Mistral is None:
+            raise Exception("Mistral AI library not installed. Install with: pip install mistralai")
+        
+        client = Mistral(api_key=MISTRAL_API_KEY)
+        
+        # Map model names
+        model_mapping = {
+            "mistral-small-latest": "mistral-small-latest"
+        }
+        
+        mistral_model = model_mapping.get(model, "mistral-small-latest")
+        
+        response = client.chat.complete(
+            model=mistral_model,
+            messages=[{"role": "user", "content": query}],
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=min(max_tokens, 32768)
+        )
+        
+        content = response.choices[0].message.content
+        input_tokens = response.usage.prompt_tokens
+        output_tokens = response.usage.completion_tokens
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"Mistral API error: {e}")
+
+def call_anthropic_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call Anthropic API"""
+    try:
+        if anthropic is None:
+            raise Exception("Anthropic library not installed. Install with: pip install anthropic")
+        
+        client = anthropic.Anthropic(api_key=ANTHROPIC_API_KEY)
+        
+        # Map model names
+        model_mapping = {
+            "sonnet-4": "claude-3-5-sonnet-20241022",
+            "sonnet-3.7": "claude-3-5-sonnet-20241022"
+        }
+        
+        anthropic_model = model_mapping.get(model, "claude-3-5-sonnet-20241022")
+        
+        response = client.messages.create(
+            model=anthropic_model,
+            max_tokens=min(max_tokens, 204800),
+            temperature=temperature,
+            messages=[{"role": "user", "content": query}]
+        )
+        
+        content = response.content[0].text
+        input_tokens = response.usage.input_tokens
+        output_tokens = response.usage.output_tokens
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"Anthropic API error: {e}")
+
+def call_grok_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call Grok API"""
+    try:
+        if not GROK_API_KEY:
+            raise Exception("Grok API key not set. Please set GROK_API_KEY environment variable.")
+        
+        headers = {
+            "Authorization": f"Bearer {GROK_API_KEY}",
+            "Content-Type": "application/json"
+        }
+        data = {
+            "model": model,
+            "messages": [{"role": "user", "content": query}],
+            "temperature": temperature,
+            "top_p": top_p,
+            "max_tokens": min(max_tokens, 32768)
+        }
+        
+        response = requests.post("https://api.x.ai/v1/chat/completions", headers=headers, json=data, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+        
+        content = result["choices"][0]["message"]["content"]
+        # Estimate tokens (rough approximation)
+        input_tokens = len(query.split())
+        output_tokens = len(content.split())
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"Grok API error: {e}")
+
+def call_nebius_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call Nebius API"""
+    try:
+        if not NEBIUS_API_KEY:
+            raise Exception("Nebius API key not set. Please set NEBIUS_API_KEY environment variable.")
+        
+        if OpenAI is None:
+            raise Exception("OpenAI library not installed. Install with: pip install openai")
+        
+        client = OpenAI(base_url="https://api.studio.nebius.com/v1/", api_key=NEBIUS_API_KEY)
+        
+        response = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": query}],
+            temperature=temperature,
+            top_p=top_p,
+            max_tokens=min(max_tokens, 32768)
+        )
+        
+        content = response.choices[0].message.content
+        input_tokens = response.usage.prompt_tokens
+        output_tokens = response.usage.completion_tokens
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"Nebius API error: {e}")
+
+def call_huggingface_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call HuggingFace Inference API"""
+    try:
+        if not HF_API_TOKEN:
+            raise Exception("HuggingFace API token not set. Please set HF_API_TOKEN environment variable.")
+        
+        headers = {
+            "Authorization": f"Bearer {HF_API_TOKEN}",
+            "Content-Type": "application/json"
+        }
+        
+        data = {
+            "inputs": query,
+            "parameters": {
+                "temperature": temperature,
+                "top_p": top_p,
+                "max_new_tokens": min(max_tokens, 32768),
+                "return_full_text": False
+            }
+        }
+        
+        # Use the HuggingFace Inference API
+        api_url = f"https://api-inference.huggingface.co/models/{model}"
+        
+        response = requests.post(api_url, headers=headers, json=data, timeout=60)
+        response.raise_for_status()
+        result = response.json()
+        
+        # Handle different response formats
+        if isinstance(result, list) and len(result) > 0:
+            if "generated_text" in result[0]:
+                content = result[0]["generated_text"]
+            elif "text" in result[0]:
+                content = result[0]["text"]
+            else:
+                content = str(result[0])
+        else:
+            content = str(result)
+        
+        # Estimate tokens (rough approximation)
+        input_tokens = len(query.split())
+        output_tokens = len(content.split())
+        
+        return content, None, input_tokens, output_tokens
+        
+    except Exception as e:
+        raise Exception(f"HuggingFace API error: {e}")
+
+def call_generic_api(query, model, temperature, top_p, top_k, max_tokens):
+    """Call generic API (for HuggingFace, Nebius, etc.)"""
+    try:
+        # Determine provider based on model backend
+        if "nebius" in model.lower() or any(provider in model for provider in ["deepseek-ai", "meta-llama", "nvidia", "mistralai", "microsoft", "Qwen", "google", "NousResearch", "aaditya"]):
+            return call_nebius_api(query, model, temperature, top_p, top_k, max_tokens)
+        elif "hf_inference" in model.lower() or any(provider in model for provider in ["razent", "ydshieh", "gp-tar4", "xshubhamx", "tcapelle"]):
+            return call_huggingface_api(query, model, temperature, top_p, top_k, max_tokens)
+        else:
+            # Fallback for unknown models
+            response = f"Generic API call to {model} - provider not recognized"
+            input_tokens = len(query.split())
+            output_tokens = len(response.split())
+            return response, None, input_tokens, output_tokens
+    except Exception as e:
+        debug_print(f"Error in generic API call: {e}")
+        return f"Error: {e}", None, 0, 0
+
+def extract_columns_from_query(query):
+    """Extract column names from the query text"""
+    import re
+    
+    columns = []
+    
+    # Look for the pattern "following columns" and extract everything after it
+    # This handles multi-line column lists - updated to handle single newlines too
+    following_pattern = r'following\s+columns?[:\s]*\n(.*?)(?:\n\n|\Z)'
+    match = re.search(following_pattern, query, re.IGNORECASE | re.DOTALL)
+    
+    if match:
+        # Extract the column list
+        column_text = match.group(1).strip()
+        # Split by newlines and clean up each line
+        lines = column_text.split('\n')
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith('Extract') and not line.startswith('Query'):
+                # Remove any leading numbers, bullets, or special characters
+                line = re.sub(r'^\s*[-•\d\.\)\s]*', '', line)
+                if line and len(line) > 1:  # Make sure it's not just a single character
+                    columns.append(line)
+    
+    # If no columns found with double newline pattern, try single newline pattern
+    if not columns:
+        # Look for pattern that captures everything after "following columns" until end or next major section
+        single_newline_pattern = r'following\s+columns?[:\s]*\n(.*?)(?:\n\s*[A-Z][a-z]*\s*[A-Z]|\Z)'
+        match = re.search(single_newline_pattern, query, re.IGNORECASE | re.DOTALL)
+        
+        if match:
+            # Extract the column list
+            column_text = match.group(1).strip()
+            # Split by newlines and clean up each line
+            lines = column_text.split('\n')
+            for line in lines:
+                line = line.strip()
+                if line and not line.startswith('Extract') and not line.startswith('Query'):
+                    # Remove any leading numbers, bullets, or special characters
+                    line = re.sub(r'^\s*[-•\d\.\)\s]*', '', line)
+                    if line and len(line) > 1:  # Make sure it's not just a single character
+                        columns.append(line)
+    
+    # If still no columns found, try a more aggressive approach - capture everything after "following columns"
+    if not columns:
+        # Look for "following columns" and capture everything after it until the end
+        aggressive_pattern = r'following\s+columns?[:\s]*\n(.*)'
+        match = re.search(aggressive_pattern, query, re.IGNORECASE | re.DOTALL)
+    
+    if match:
+        # Extract the column list
+        column_text = match.group(1).strip()
+        # Split by newlines and clean up each line
+        lines = column_text.split('\n')
+        for line in lines:
+            line = line.strip()
+            if line and not line.startswith('Extract') and not line.startswith('Query'):
+                # Remove any leading numbers, bullets, or special characters
+                line = re.sub(r'^\s*[-•\d\.\)\s]*', '', line)
+                if line and len(line) > 1:  # Make sure it's not just a single character
+                    columns.append(line)
+    
+    # If no columns found with the main pattern, try alternative patterns
+    if not columns:
+        # Look for patterns like "columns:" followed by a list
+        column_patterns = [
+            r'columns?[:\s]*\n(.*?)(?:\n\n|\Z)',
+            r'(?:extract|get|find).*?columns?[:\s]*\n(.*?)(?:\n\n|\Z)',
+        ]
+        
+        for pattern in column_patterns:
+            matches = re.findall(pattern, query, re.IGNORECASE | re.DOTALL)
+            for match in matches:
+                # Split by newlines and clean up
+                lines = match.strip().split('\n')
+                for line in lines:
+                    line = line.strip()
+                    if line and not line.startswith('Extract') and not line.startswith('Query'):
+                        # Remove any leading numbers or bullets
+                        line = re.sub(r'^\s*[-•\d\.\)\s]*', '', line)
+                        if line and len(line) > 1:
+                            columns.append(line)
+                if columns:  # If we found columns, break out of the loop
+                    break
+            if columns:  # If we found columns, break out of the outer loop
+                break
+    
+    # If still no columns found, try to find individual column mentions
+    if not columns:
+        # Look for common column names in the query
+        common_columns = [
+            'Title', 'Authors', 'Journal', 'Year', 'Analysis Method', 
+            'Methodology Detail', 'Performance Parameters', 'Study Population', 
+            'Study Type', 'Results', 'Metrics from Results', 'Quantitative Data', 
+            'Qualitative Data', 'Abstract', 'Keywords', 'DOI', 'Volume', 'Issue',
+            'Pages', 'Publisher', 'Language', 'Country', 'Institution'
+        ]
+        
+        for col in common_columns:
+            if col.lower() in query.lower():
+                columns.append(col)
+    
+    # Remove duplicates while preserving order
+    seen = set()
+    unique_columns = []
+    for col in columns:
+        if col not in seen:
+            seen.add(col)
+            unique_columns.append(col)
+    
+    # Always add Raw Response
+    if 'Raw Response' not in unique_columns:
+        unique_columns.append('Raw Response')
+    
+    return unique_columns
+
+def parse_structured_response(response, query, pdf_content=None):
+    """Parse LLM response to extract structured data based on query instructions"""
+    # Extract columns from query dynamically
+    columns = extract_columns_from_query(query)
+    
+    # Create default structure with dynamic columns
+    default_structure = {col: '' for col in columns}
+    # Ensure Raw Response is always included (no truncation)
+    default_structure['Raw Response'] = response
+    
+    try:
+        # Check if the query asks for specific CSV columns
+        if any(keyword in query.lower() for keyword in ['csv', 'columns', 'title', 'authors', 'journal', 'year']):
+            # Try to extract structured data from the response
+            lines = response.split('\n')
+            structured_data = {}
+            
+            # Look for key-value pairs in the response
+            for line in lines:
+                line = line.strip()
+                if ':' in line:
+                    # Try to find the best split point for key-value pairs
+                    # Look for patterns where the key might be a full column name
+                    best_split = None
+                    best_score = 0
+                    
+                    # Try different split points
+                    for i, char in enumerate(line):
+                        if char == ':':
+                            potential_key = line[:i].strip()
+                            potential_value = line[i+1:].strip()
+                            
+                            # Score this split based on how well the key matches our expected columns
+                            key_lower = potential_key.lower()
+                            score = 0
+                            
+                            for expected_col in columns:
+                                expected_lower = expected_col.lower()
+                                if key_lower == expected_lower:
+                                    score = 100  # Exact match
+                                    break
+                                elif key_lower in expected_lower or expected_lower in key_lower:
+                                    # Partial match - score based on overlap
+                                    overlap = len(set(key_lower.split()) & set(expected_lower.split()))
+                                    score = max(score, overlap * 10)
+                            
+                            if score > best_score:
+                                best_score = score
+                                best_split = (potential_key, potential_value)
+                    
+                    if best_split and best_score > 5:  # Minimum threshold
+                        key, value = best_split
+                    else:
+                        # Fallback to simple first colon split
+                        if len(line.split(':', 1)) == 2:
+                            key, value = line.split(':', 1)
+                            key = key.strip()
+                            value = value.strip()
+                        else:
+                            continue
+                    
+                    # Clean up value - remove any duplicate key information
+                    # Sometimes the LLM includes the key again in the value
+                    if value.startswith(key + ':'):
+                        value = value[len(key) + 1:].strip()
+                    
+                    # Try to match the key to one of our expected columns (case insensitive)
+                    key_lower = key.lower().strip()
+                    matched_column = None
+                    
+                    # First try exact matches
+                    for expected_col in columns:
+                        if expected_col.lower() == key_lower:
+                            matched_column = expected_col
+                            break
+                    
+                    # If no exact match and we used fallback split, try to find the best matching column
+                    if not matched_column and best_split is None:
+                        # This means we used the fallback split, so try to find the best match
+                        best_match = None
+                        best_score = 0
+                        
+                        for expected_col in columns:
+                            expected_lower = expected_col.lower()
+                            score = 0
+                            
+                            # Check if the key is a significant part of the expected column
+                            if key_lower in expected_lower:
+                                score = (len(key_lower) / len(expected_lower)) * 50
+                                # Bonus for common important fields
+                                if key_lower in ['title', 'authors', 'journal', 'year', 'results', 'study', 'context', 'setting', 'language', 'population', 'concept']:
+                                    score += 30
+                            elif expected_lower in key_lower:
+                                score = (len(expected_lower) / len(key_lower)) * 40
+                                if key_lower in ['title', 'authors', 'journal', 'year', 'results', 'study', 'context', 'setting', 'language', 'population', 'concept']:
+                                    score += 30
+                            
+                            if score > best_score and score > 15:  # Higher threshold for fallback
+                                best_score = score
+                                best_match = expected_col
+                        
+                        if best_match:
+                            matched_column = best_match
+                    
+                    # If no exact match, try partial matches with better scoring
+                    if not matched_column:
+                        best_match = None
+                        best_score = 0
+                        
+                        for expected_col in columns:
+                            expected_lower = expected_col.lower()
+                            score = 0
+                            
+                            # Exact match gets highest score
+                            if key_lower == expected_lower:
+                                score = 100
+                            # Key is contained in expected column
+                            elif key_lower in expected_lower:
+                                # Score based on how much of the key matches
+                                score = (len(key_lower) / len(expected_lower)) * 50
+                                # Bonus for common important fields
+                                if key_lower in ['title', 'authors', 'journal', 'year', 'results']:
+                                    score += 20
+                            # Expected column is contained in the key (reverse case)
+                            elif expected_lower in key_lower:
+                                # Score based on how much of the expected column matches
+                                score = (len(expected_lower) / len(key_lower)) * 40
+                                # Bonus for common important fields
+                                if key_lower in ['title', 'authors', 'journal', 'year', 'results', 'study', 'context', 'setting']:
+                                    score += 20
+                            # Expected column key words are in the response key
+                            else:
+                                expected_words = [word for word in expected_lower.split() if len(word) > 3]
+                                matching_words = sum(1 for word in expected_words if word in key_lower)
+                                if matching_words > 0:
+                                    score = (matching_words / len(expected_words)) * 30
+                            
+                            if score > best_score and score > 10:  # Minimum threshold
+                                best_score = score
+                                best_match = expected_col
+                        
+                        if best_match:
+                            matched_column = best_match
+                    
+                    if matched_column:
+                        structured_data[matched_column] = value
+            
+            # Also try to extract from the PDF content itself if the LLM didn't format properly
+            if not structured_data:
+                # Look for common patterns in the PDF content
+                pdf_content_start = response.find("PDF Content:")
+                if pdf_content_start != -1:
+                    pdf_content = response[pdf_content_start:].split('\n')
+                    
+                    # Try to extract title (usually first line after "PDF Content:")
+                    for i, line in enumerate(pdf_content[1:6]):  # Check first 5 lines
+                        line = line.strip()
+                        if line and not line.startswith('Vol.:') and not line.startswith('RESEARCH ARTICLE') and not line.startswith('You are'):
+                            structured_data['Title'] = line
+                            break
+                    
+                    # Look for authors (often contains "et al" or multiple names)
+                    for line in pdf_content:
+                        if 'et al' in line.lower() or (',' in line and len(line.split(',')) > 2):
+                            structured_data['Authors'] = line.strip()
+                            break
+                    
+                    # Look for year (4-digit number)
+                    import re
+                    year_match = re.search(r'\b(19|20)\d{2}\b', response)
+                    if year_match:
+                        structured_data['Year'] = year_match.group()
+                
+                # If still no structured data, try to extract from the original PDF content
+                if not structured_data and 'pdf_content' in locals():
+                    # Try to extract basic information from the PDF content directly
+                    lines = pdf_content.split('\n') if isinstance(pdf_content, str) else pdf_content
+                    
+                    # Look for title (first substantial line)
+                    for line in lines[:10]:
+                        line = line.strip()
+                        if line and len(line) > 10 and not line.startswith('Vol.:') and not line.startswith('RESEARCH ARTICLE'):
+                            structured_data['Title'] = line
+                            break
+                    
+                    # Look for authors
+                    for line in lines:
+                        if 'et al' in line.lower() or (',' in line and len(line.split(',')) > 2):
+                            structured_data['Authors'] = line.strip()
+                            break
+                    
+                    # Look for year
+                    year_match = re.search(r'\b(19|20)\d{2}\b', pdf_content if isinstance(pdf_content, str) else ' '.join(pdf_content))
+                    if year_match:
+                        structured_data['Year'] = year_match.group()
+            
+            # If we found some structured data, use it
+            if structured_data:
+                # Fill in missing fields with empty strings
+                for key in default_structure:
+                    if key not in structured_data and key != 'Raw Response':
+                        structured_data[key] = ''
+                structured_data['Raw Response'] = response
+                return structured_data
+        
+        # If no structured data found or query doesn't ask for it, return default
+        return default_structure
+        
+    except Exception as e:
+        debug_print(f"Error parsing structured response: {e}")
+        return default_structure
+
+def process_pdf_with_llm(pdf_content, pdf_name, query, model, temperature, top_p, top_k, max_tokens):
+    """Process PDF content with LLM to extract information"""
+    # Check if the query asks for structured data extraction
+    is_structured_query = any(keyword in query.lower() for keyword in ['csv', 'columns', 'title', 'authors', 'journal', 'year'])
+    
+    if is_structured_query:
+        # Extract columns from query dynamically
+        columns = extract_columns_from_query(query)
+        
+        # Build the prompt with dynamic columns
+        column_prompts = []
+        for col in columns:
+            if col != 'Raw Response':  # Don't include Raw Response in the prompt
+                column_prompts.append(f"{col}: [value here]")
+        
+        columns_text = "\n".join(column_prompts)
+        
+        # Enhanced prompt for structured data extraction
+        full_prompt = f"""
+Extract the following information from the PDF and respond ONLY with this exact format:
+
+{columns_text}
+
+PDF Content:
+{pdf_content}
+
+CRITICAL INSTRUCTIONS:
+1. Your response must start with the first column name and contain only the structured data above. No other text.
+2. For the Context column about "dark moves": If you find evidence of lying, misleading, manipulation, or other deceptive practices by the AI, describe them specifically. If you find NO dark moves, you MUST provide a detailed explanation of WHY there are none, including specific evidence from the paper (e.g., "No dark moves found because the study explicitly tested for deception and found none" or "The AI was designed with transparency measures that prevented misleading responses").
+3. Be thorough and specific in your analysis - don't just say "no dark moves" without explaining the reasoning.
+4. In the column include / exclude recommendation - consider all the criteria above and provide an answer based on the other columns. If a "must" column is not met, then exclude.
+"""
+    else:
+        # Standard prompt for general queries
+        full_prompt = f"""
+PDF Content:
+{pdf_content}
+
+Query/Instructions:
+{query}
+
+Please extract the requested information from the PDF content above and format it according to the instructions.
+"""
+    
+    response, _, input_tokens, output_tokens = submit_query_updated(
+        full_prompt, model, temperature, top_p, top_k, max_tokens
+    )
+    
+    # Calculate token sufficiency information
+    total_input_tokens = len(full_prompt.split())  # Rough estimate
+    token_sufficiency = "Sufficient" if total_input_tokens <= max_tokens else "Truncated"
+    token_info = f"Input tokens: {total_input_tokens}/{max_tokens} ({token_sufficiency})"
+    
+    # Debug: Print the actual response for structured queries
+    if is_structured_query:
+        debug_print(f"Structured query response for {pdf_name}: {response[:1000]}...")
+        debug_print(f"Response starts with: {response[:100]}")
+        debug_print(f"Token usage: {token_info}")
+    
+    return response, input_tokens, output_tokens, token_info
+
+def process_pdf_batch_job(job_id, source_path, query, selected_models, temperature, top_p, top_k, max_tokens, csv_prefix):
+    """Process all PDFs with selected models and save results to CSV"""
+    global jobs
+    
+    try:
+        # Get list of PDF files
+        pdf_files = get_pdf_files_from_source(source_path)
+        debug_print(f"Found {len(pdf_files)} PDF files: {[os.path.basename(f) for f in pdf_files]}")
+        debug_print(f"Selected models: {selected_models}")
+        
+        if not pdf_files:
+            jobs[job_id]["status"] = "completed"
+            jobs[job_id]["error"] = "No PDF files found in the specified source"
+            return
+        
+        if not selected_models:
+            jobs[job_id]["status"] = "completed"
+            jobs[job_id]["error"] = "No models selected"
+            return
+        
+        results = []
+        total_processed = 0
+        total_to_process = len(pdf_files) * len(selected_models)
+        debug_print(f"Total to process: {total_to_process} (PDFs: {len(pdf_files)}, Models: {len(selected_models)})")
+        
+        # Initialize job progress
+        jobs[job_id]["partial_results"] = {
+            "num_done": 0,
+            "total": total_to_process,
+            "current_pdf": "Starting...",
+            "current_model": ""
+        }
+        
+        for pdf_path in pdf_files:
+            # Extract proper PDF name from Google Drive URLs
+            if 'drive.google.com' in pdf_path:
+                try:
+                    file_id = extract_file_id(pdf_path)
+                    pdf_name = f"gdrive_{file_id}.pdf"
+                except:
+                    pdf_name = os.path.basename(pdf_path)
+            else:
+                pdf_name = os.path.basename(pdf_path)
+            
+            debug_print(f"Processing PDF: {pdf_name}")
+            debug_print(f"Full URL: {pdf_path}")
+            
+            # Load PDF content
+            pdf_content = load_pdf_content(pdf_path)
+            if pdf_content is None:
+                debug_print(f"Failed to load content from {pdf_name} (URL: {pdf_path})")
+                # Still count this as processed to maintain progress accuracy
+                for model_display in selected_models:
+                    total_processed += 1
+                    jobs[job_id]["partial_results"] = {
+                        "num_done": total_processed,
+                        "total": total_to_process,
+                        "current_pdf": pdf_name,
+                        "current_model": f"Failed to load PDF"
+                    }
+                continue
+            
+            for model_display in selected_models:
+                # Find the model configuration
+                model_config = next((m for m in models if m["display"] == model_display), None)
+                if not model_config:
+                    debug_print(f"Model configuration not found for {model_display}")
+                    total_processed += 1
+                    jobs[job_id]["partial_results"] = {
+                        "num_done": total_processed,
+                        "total": total_to_process,
+                        "current_pdf": pdf_name,
+                        "current_model": f"Model not found: {model_display}"
+                    }
+                    continue
+                
+                # Use model-specific max_tokens if available, otherwise use the slider value
+                model_max_tokens = model_config.get("max_tokens", max_tokens)
+                model_backend = model_config["backend"]
+                
+                debug_print(f"Processing {pdf_name} with {model_display} (backend: {model_backend}, max_tokens: {model_max_tokens})")
+                
+                # Process PDF with LLM
+                response, input_tokens, output_tokens, token_info = process_pdf_with_llm(
+                    pdf_content, pdf_name, query, model_backend, temperature, top_p, top_k, model_max_tokens
+                )
+                
+                # Parse structured response
+                structured_data = parse_structured_response(response, query, pdf_content)
+                
+                # Store result with structured data
+                result = {
+                    'pdf_name': pdf_name,
+                    'pdf_path': pdf_path,
+                    'model': model_display,
+                    'model_backend': model_backend,
+                    'query': query,
+                    'input_tokens': input_tokens,
+                    'output_tokens': output_tokens,
+                    'token_sufficiency': token_info,
+                    'timestamp': datetime.datetime.now().isoformat()
+                }
+                
+                # Add structured fields
+                result.update(structured_data)
+                
+                results.append(result)
+                
+                total_processed += 1
+                
+                # Update job progress
+                jobs[job_id]["partial_results"] = {
+                    "num_done": total_processed,
+                    "total": total_to_process,
+                    "current_pdf": pdf_name,
+                    "current_model": model_display
+                }
+        
+        # Save results to CSV
+        sanitize = lambda s: re.sub(r'[^A-Za-z0-9_-]+', '', str(s).replace(' ', '_'))
+        safe_prefix = sanitize(csv_prefix) if csv_prefix else 'pdf_results'
+        date_str = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
+        filename = f"{safe_prefix}_{date_str}.csv"
+        
+        with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
+            if results:
+                fieldnames = results[0].keys()
+                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+                writer.writeheader()
+                writer.writerows(results)
+        
+        jobs[job_id]["status"] = "completed"
+        jobs[job_id]["csv_file"] = filename
+        jobs[job_id]["results"] = results
+        
+    except Exception as e:
+        debug_print(f"Error in process_pdf_batch_job: {e}")
+        jobs[job_id]["status"] = "error"
+        jobs[job_id]["error"] = str(e)
+
+def process_in_background(job_id, func, args):
+    """Process job in background thread"""
+    try:
+        func(*args)
+    except Exception as e:
+        debug_print(f"Background job {job_id} failed: {e}")
+        jobs[job_id]["status"] = "error"
+        jobs[job_id]["error"] = str(e)
+
+def get_job_list():
+    """Get formatted job list for display"""
+    if not jobs:
+        return "No jobs submitted yet."
+    
+    job_list = "### Submitted Jobs\n\n"
+    for job_id, job_info in jobs.items():
+        status = job_info.get("status", "unknown")
+        job_type = job_info.get("type", "unknown")
+        start_time = job_info.get("start_time", 0)
+        
+        if start_time:
+            elapsed = time.time() - start_time
+            elapsed_str = f"{elapsed:.1f}s"
+        else:
+            elapsed_str = "N/A"
+        
+        job_list += f"**Job {job_id[:8]}...** ({job_type})\n"
+        job_list += f"- Status: {status}\n"
+        job_list += f"- Elapsed: {elapsed_str}\n"
+        
+        if "partial_results" in job_info:
+            partial = job_info["partial_results"]
+            job_list += f"- Progress: {partial.get('num_done', 0)}/{partial.get('total', 0)}\n"
+            if "current_pdf" in partial:
+                job_list += f"- Current: {partial['current_pdf']} ({partial.get('current_model', '')})\n"
+        
+        job_list += "\n"
+    
+    return job_list
+
+def submit_pdf_processing_job(source_path, query, selected_models, temperature, top_p, top_k, max_tokens, csv_prefix):
+    """Submit PDF processing job"""
+    global last_job_id
+    
+    if not query.strip():
+        return "Please enter a query/prompt", "", get_job_list()
+    
+    if not selected_models:
+        return "Please select at least one model", "", get_job_list()
+    
+    job_id = str(uuid.uuid4())
+    last_job_id = job_id
+    
+    # Start background job
+    threading.Thread(
+        target=process_in_background,
+        args=(job_id, process_pdf_batch_job, [job_id, source_path, query, selected_models, temperature, top_p, top_k, max_tokens, csv_prefix])
+    ).start()
+    
+    # Store job info
+    jobs[job_id] = {
+        "status": "processing",
+        "type": "pdf_processing",
+        "start_time": time.time(),
+        "query": query,
+        "source_path": source_path,
+        "models": selected_models,
+        "params": {
+            "temperature": temperature,
+            "top_p": top_p,
+            "top_k": top_k,
+            "max_tokens": max_tokens,
+            "csv_prefix": csv_prefix
+        }
+    }
+    
+    return f"PDF processing job submitted. Job ID: {job_id}", job_id, get_job_list()
+
+def load_csv_data_for_table(csv_file):
+    """Load CSV data and format it for the table display"""
+    if not csv_file or not os.path.exists(csv_file):
+        return None
+    
+    if pd is None:
+        debug_print("Pandas not available for table display")
+        return None
+    
+    try:
+        df = pd.read_csv(csv_file)
+        
+        # Select only the data columns (exclude technical columns for display)
+        display_columns = []
+        for col in df.columns:
+            if col not in ['pdf_path', 'model_backend', 'query', 'input_tokens', 'output_tokens', 'timestamp', 'Raw Response']:
+                display_columns.append(col)
+        
+        # Create a simplified dataframe for display
+        display_df = df[display_columns].copy()
+        
+        # Ensure all values are strings and handle NaN values
+        for col in display_df.columns:
+            display_df[col] = display_df[col].astype(str).fillna('')
+        
+        # Create HTML table with proper styling
+        html_table = create_html_table(display_df, display_columns)
+        return html_table
+        
+    except Exception as e:
+        debug_print(f"Error loading CSV for table: {e}")
+        return None
+
+def create_html_table(df, columns):
+    """Create an HTML table with proper styling for the CSV data"""
+    html = """
+    <div style="max-height: 600px; overflow-y: auto; border: 1px solid #ddd; border-radius: 5px;">
+        <table style="width: 100%; border-collapse: collapse; font-size: 11px; font-family: Arial, sans-serif;">
+            <thead>
+                <tr style="background-color: #f5f5f5; position: sticky; top: 0; z-index: 10;">
+    """
+    
+    # Add headers
+    for col in columns:
+        html += f'<th style="padding: 8px; border: 1px solid #ddd; text-align: left; font-weight: bold; white-space: nowrap; min-width: 100px; color: #333; background-color: #f5f5f5;">{col}</th>'
+    
+    html += """
+                </tr>
+            </thead>
+            <tbody>
+    """
+    
+    # Add data rows
+    for _, row in df.iterrows():
+        html += '<tr style="border-bottom: 1px solid #eee;">'
+        for col in columns:
+            value = str(row[col]) if pd.notna(row[col]) else ''
+            # Escape HTML characters
+            value = value.replace('&', '&amp;').replace('<', '&lt;').replace('>', '&gt;').replace('"', '&quot;')
+            html += f'<td style="padding: 6px; border: 1px solid #ddd; word-wrap: break-word; white-space: pre-wrap; max-width: 300px; vertical-align: top;">{value}</td>'
+        html += '</tr>'
+    
+    html += """
+            </tbody>
+        </table>
+    </div>
+    """
+    
+    return html
+
+def check_job_status(job_id):
+    """Check status of a specific job"""
+    if not job_id or job_id not in jobs:
+        return "Job not found", "", "", get_job_list(), None
+    
+    job_info = jobs[job_id]
+    status = job_info.get("status", "unknown")
+    
+    if status == "completed":
+        csv_file = job_info.get("csv_file", "")
+        results = job_info.get("results", [])
+        
+        # Create summary
+        summary = f"Job completed successfully!\n"
+        summary += f"Processed {len(results)} PDF-model combinations\n"
+        summary += f"CSV file: {csv_file}\n"
+        
+        # Create download link
+        if csv_file and os.path.exists(csv_file):
+            rel_path = os.path.relpath(csv_file, ".")
+            download_link = f'<a href="/file={rel_path}" download target="_blank">{os.path.basename(csv_file)}</a>'
+        else:
+            download_link = "File not found"
+        
+        # Load CSV data for table
+        html_table = load_csv_data_for_table(csv_file)
+        
+        return summary, download_link, csv_file, get_job_list(), html_table
+    
+    elif status == "error":
+        error_msg = job_info.get("error", "Unknown error")
+        return f"Job failed: {error_msg}", "", "", get_job_list(), None
+    
+    else:
+        # Job still processing
+        partial = job_info.get("partial_results", {})
+        progress = f"Processing... {partial.get('num_done', 0)}/{partial.get('total', 0)}"
+        if "current_pdf" in partial:
+            progress += f" - {partial['current_pdf']} ({partial.get('current_model', '')})"
+        
+        return progress, "", "", get_job_list(), None
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="FilterLM") as interface:
+        gr.Markdown("# FilterLM")
+        gr.Markdown("Extract structured information from PDFs using multiple LLMs and save results to CSV")
+        
+        with gr.Tab("PDF Processing"):
+            with gr.Row():
+                source_path_input = gr.Textbox(
+                    label="PDF Source (Folder Path, URL, or Google Drive Link)",
+                    placeholder="Enter local folder path, single URL, comma-separated URLs, Google Drive file links, or Google Drive folder links (e.g., url1.pdf,url2.pdf,https://drive.google.com/file/d/1234567890/view,https://drive.google.com/drive/folders/1234567890). Leave empty for current directory.",
+                    lines=2
+                )
+            
+            with gr.Row():
+                csv_prefix_input = gr.Textbox(
+                    label="CSV Filename Prefix",
+                    placeholder="Enter prefix for CSV filename (optional)",
+                    lines=1
+                )
+            
+            with gr.Row():
+                default_query = """Extract from every paper in a CSV the following columns
+Title
+Authors
+Journal
+Year
+Publication status - check journal to be peer-reviewed and exclude proceedings or theoretical papers
+Language: English only
+Study type: What kind of empirical research is it? (i.e., quantitative, qualitative, mixed-methods). No reviews, no theoretical papers
+Population: - must be only humans
+Concept - what type of conversational AI is it?
+Context: What type of „dark moves" done by AI chatbots / LLMs ? example of dark moves in communication: lying or misleading. REQUIRED: If there are no dark moves, you MUST provide a detailed explanation of WHY there are none, including specific evidence or reasoning from the study
+Setting: domain (e.g., medicine, educational, general population, etc.) 
+Results - must include perceptions or attitudes of people 
+ Include / Exclude Recommendation - if all criteria above have been complete, then Include
+ Raw Response"""
+                
+                query_input = gr.Textbox(
+                    label="Query/Prompt for Information Extraction",
+                    value=default_query,
+                    placeholder="Enter your prompt here...",
+                    lines=8
+                )
+            
+            with gr.Row():
+                # Create a single radio button group with all models, organized by provider with separators
+                all_models = []
+                
+                # Add Mistral & HuggingFace models
+                mistral_hf_models = [m["display"] for m in models if m["provider"] in ("mistral", "hf_inference")]
+                if mistral_hf_models:
+                    all_models.extend(mistral_hf_models)
+                
+                # Add separator
+                if all_models and (nebius_models := [m["display"] for m in models if m["provider"] == "nebius"]):
+                    all_models.append("─────────── Nebius Models ───────────")
+                    all_models.extend(nebius_models)
+                
+                # Add separator for OpenAI/Gemini/Grok/Anthropic models
+                openai_models = [m["display"] for m in models if m["provider"] in ("openai", "gemini", "grok", "anthropic")]
+                if openai_models:
+                    all_models.append("────── OpenAI / Gemini / Grok / Anthropic ──────")
+                    all_models.extend(openai_models)
+                
+                model_radio = gr.Radio(
+                    choices=all_models,
+                    label="Select Model (Single Selection)",
+                    value="🇪🇺 Mistral-API (Mistral) (32K)"
+                )
+            
+            with gr.Row():
+                temperature_slider = gr.Slider(
+                    minimum=0.1, maximum=1.0, value=0.5, step=0.1,
+                    label="Randomness (Temperature)"
+                )
+                top_p_slider = gr.Slider(
+                    minimum=0.1, maximum=0.99, value=0.95, step=0.05,
+                    label="Word Variety (Top-p)"
+                )
+                top_k_slider = gr.Slider(
+                    minimum=1, maximum=100, value=50, step=1,
+                    label="Top-k (Number of tokens to consider)"
+                )
+                max_tokens_slider = gr.Slider(
+                    minimum=64, maximum=1048576, value=32768, step=64,
+                    label="Max Tokens (Response length) - Higher values allow processing larger PDFs"
+                )
+            
+            with gr.Row():
+                submit_button = gr.Button("Start PDF Processing", variant="primary")
+            
+            with gr.Row():
+                status_output = gr.Textbox(
+                    label="Status",
+                    lines=3
+                )
+            
+            with gr.Row():
+                job_id_output = gr.Textbox(
+                    label="Job ID",
+                    interactive=False
+                )
+            
+            with gr.Row():
+                check_button = gr.Button("Check Job Status")
+                auto_refresh = gr.Checkbox(label="Enable Auto Refresh", value=False)
+            
+            with gr.Row():
+                results_output = gr.Textbox(
+                    label="Results",
+                    lines=5
+                )
+                download_html = gr.HTML(label="Download CSV")
+                csv_path_output = gr.Textbox(
+                    label="CSV File Path",
+                    interactive=False
+                )
+            
+            with gr.Row():
+                job_list = gr.Markdown(label="Job List", value=get_job_list())
+                refresh_job_list_button = gr.Button("Refresh Job List")
+            
+            # Add table view for CSV data
+            with gr.Row():
+                csv_table = gr.HTML(
+                    label="CSV Data Preview",
+                    value="<p style='text-align: center; color: #666; padding: 20px;'>No data available. Process some PDFs to see results here.</p>"
+                )
+        
+        # Event handlers
+        def submit_job(source_path, query, selected_model, temperature, top_p, top_k, max_tokens, csv_prefix):
+            # Filter out separator lines (lines with dashes)
+            if selected_model and not selected_model.startswith("─"):
+                selected_models = [selected_model]
+            else:
+                selected_models = []
+            return submit_pdf_processing_job(source_path, query, selected_models, temperature, top_p, top_k, max_tokens, csv_prefix)
+        
+        submit_button.click(
+            submit_job,
+            inputs=[
+                source_path_input,
+                query_input,
+                model_radio,
+                temperature_slider,
+                top_p_slider,
+                top_k_slider,
+                max_tokens_slider,
+                csv_prefix_input
+            ],
+            outputs=[status_output, job_id_output, job_list]
+        )
+        
+        check_button.click(
+            check_job_status,
+            inputs=[job_id_output],
+            outputs=[results_output, download_html, csv_path_output, job_list, csv_table]
+        )
+        
+        refresh_job_list_button.click(
+            lambda: get_job_list(),
+            outputs=[job_list]
+        )
+        
+        # Auto refresh functionality
+        def auto_refresh_job_status():
+            if last_job_id and last_job_id in jobs:
+                return check_job_status(last_job_id)
+            return "No active job", "", "", get_job_list(), None
+        
+        auto_refresh.change(
+            auto_refresh_job_status,
+            outputs=[results_output, download_html, csv_path_output, job_list, csv_table]
+        )
+        
+    
+    return interface
+
+if __name__ == "__main__":
+    interface = create_interface()
+    interface.launch(share=False)

pdf_criteria_search_gui_v1.py

@@ -0,0 +1,844 @@
+"""
+Multi-PDF criteria search GUI using the same quote / text match logic as
+"Add Quotes" in visualize_gui.py (normalization + _fuzzy_match_quote_in_normalized).
+
+No LLMs. Results can be exported to an easy-to-read .docx with page numbers
+and APA-style references from PDF metadata.
+"""
+
+from __future__ import annotations
+
+import csv
+import os
+import re
+import sys
+import threading
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+from typing import Any, Dict, List, Optional, Tuple
+
+# -----------------------------------------------------------------------------
+# Search terms: one basic word (or single token) per rubric *group* (e.g. all
+# "1.1 Overall quality …" variants → "quality"), stored in criteria_search_terms.csv
+# -----------------------------------------------------------------------------
+
+TERMS_CSV_NAME = "criteria_search_terms.csv"
+
+
+def terms_csv_path() -> str:
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), TERMS_CSV_NAME)
+
+
+def default_single_word_terms() -> List[str]:
+    """Fallback list written when the CSV is missing; keep in sync with criteria_search_terms.csv."""
+    return [
+        "quality",
+        "helpfulness",
+        "harmlessness",
+        "safety",
+        "groundedness",
+        "honesty",
+        "truthfulness",
+        "hallucinations",
+        "empathy",
+        "politeness",
+        "relevance",
+        "verbosity",
+        "component",
+        "aggregation",
+        "ranking",
+        "weighting",
+        "tradeoffs",
+        "other",
+        "nonspecific",
+        "grice",
+        "specific",
+        "otherframework",
+        "conversations",
+        "humanai",
+        "annotation",
+        "separate",
+        "naturalistic",
+        "hybrid",
+        "synthetic",
+        "datasetname",
+        "datasetsource",
+        "dialogs",
+        "annotators",
+        "context",
+        "annotator",
+        "single",
+        "multi",
+        "prerecorded",
+        "realtime",
+        "scales",
+        "binary",
+        "validated",
+        "notes",
+        "named",
+        "unspecified",
+        "family",
+        "rlhf",
+        "partial",
+        "collected",
+        "reward",
+        "policy",
+        "stage",
+        "benchmark",
+        "judge",
+        "comparators",
+        "winrate",
+        "strategy",
+        "gains",
+        "losses",
+        "inconsistent",
+        "unchanged",
+        "quantified",
+    ]
+
+
+def ensure_terms_csv(path: str) -> None:
+    if os.path.isfile(path):
+        return
+    write_terms_to_csv(path, default_single_word_terms())
+
+
+def load_terms_from_csv(path: str) -> List[str]:
+    if not os.path.isfile(path):
+        return list(default_single_word_terms())
+    terms: List[str] = []
+    with open(path, newline="", encoding="utf-8") as f:
+        reader = csv.reader(f)
+        rows = list(reader)
+    if not rows:
+        return list(default_single_word_terms())
+    header = [c.strip().lower() for c in rows[0]]
+    col = 0
+    if "term" in header:
+        col = header.index("term")
+    for row in rows[1:]:
+        if col >= len(row):
+            continue
+        t = row[col].strip() if row[col] else ""
+        if t and not t.startswith("#"):
+            terms.append(t)
+    return terms if terms else list(default_single_word_terms())
+
+
+def write_terms_to_csv(path: str, terms: List[str]) -> None:
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(["term"])
+        for t in terms:
+            t = t.strip()
+            if t:
+                w.writerow([t])
+
+
+def parse_terms_text(raw: str) -> List[str]:
+    """One search term per line in the text panel (ignores empty lines and # comments)."""
+    out: List[str] = []
+    for line in raw.splitlines():
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        out.append(s)
+    return out
+
+
+# -----------------------------------------------------------------------------
+# Quote search engine — aligned with visualize_gui.py (Add Quotes PDF verification)
+# -----------------------------------------------------------------------------
+
+
+class QuoteSearchEngine:
+    """Normalizes text and runs the same multi-strategy match used in Add Quotes."""
+
+    def __init__(self) -> None:
+        self._normalized_source_cache: Dict[str, Any] = {}
+
+    def clear_cache(self) -> None:
+        self._normalized_source_cache.clear()
+
+    def _normalize_text_for_search(self, text: str) -> str:
+        import re
+
+        text = re.sub(r"-\s+([a-z])", r"\1", text)
+        text = re.sub(r"-\s*\n\s*([a-z])", r"\1", text)
+        text = re.sub(r"[\r\n]+", " ", text)
+        normalized = re.sub(r"\s+", " ", text)
+        return normalized.strip()
+
+    def _normalize_text_aggressive(self, text: str) -> str:
+        import re
+
+        normalized = self._normalize_text_for_search(text)
+        normalized = normalized.rstrip(".,;:!?")
+        normalized = re.sub(r"\s*([,.;:!?])\s*", r"\1 ", normalized)
+        normalized = re.sub(r"\s+", " ", normalized)
+        return normalized.strip()
+
+    def _fuzzy_match_quote_in_normalized(self, quote_text: str, normalized_data: Optional[Dict]) -> bool:
+        if normalized_data is None:
+            return False
+        normalized_source = normalized_data["normalized_text"]
+        clean_quote = self._normalize_text_for_search(quote_text)
+        if clean_quote in normalized_source:
+            return True
+        if clean_quote.lower() in normalized_source.lower():
+            return True
+        agg_quote = self._normalize_text_aggressive(quote_text)
+        agg_source = self._normalize_text_aggressive(normalized_source)
+        if agg_quote.lower() in agg_source.lower():
+            return True
+        quote_words: List[str] = []
+        for w in clean_quote.split():
+            cleaned = w.strip(".,;:!?()[]{}\"'").lower()
+            if len(cleaned) > 1:
+                quote_words.append(cleaned)
+        source_words: List[str] = []
+        for w in normalized_source.split():
+            cleaned = w.strip(".,;:!?()[]{}\"'").lower()
+            if len(cleaned) > 1:
+                source_words.append(cleaned)
+        if len(quote_words) >= 3:
+            quote_idx = 0
+            consecutive_matches = 0
+            max_consecutive = 0
+            for source_word in source_words:
+                if quote_idx < len(quote_words) and source_word == quote_words[quote_idx]:
+                    quote_idx += 1
+                    consecutive_matches += 1
+                    max_consecutive = max(max_consecutive, consecutive_matches)
+                    if quote_idx == len(quote_words):
+                        return True
+                else:
+                    consecutive_matches = 0
+            if quote_idx >= len(quote_words) * 0.70:
+                return True
+            if max_consecutive >= min(3, len(quote_words) * 0.4):
+                return True
+        if len(quote_words) >= 8:
+            middle_quote_words = quote_words[2:-2]
+            if len(middle_quote_words) >= 3:
+                qidx = 0
+                for source_word in source_words:
+                    if qidx < len(middle_quote_words) and source_word == middle_quote_words[qidx]:
+                        qidx += 1
+                        if qidx == len(middle_quote_words):
+                            return True
+                if qidx >= len(middle_quote_words) * 0.70:
+                    return True
+        if quote_text.startswith("Quote "):
+            parts = quote_text.split(":", 1)
+            if len(parts) > 1:
+                after = parts[1].strip()
+                no_prefix = self._normalize_text_for_search(after)
+                if no_prefix.lower() in normalized_source.lower():
+                    return True
+        return False
+
+    def _load_and_normalize_source(self, source_file_path: str, file_type: str) -> Optional[Dict]:
+        cache_key = f"{source_file_path}_{file_type}"
+        if cache_key in self._normalized_source_cache:
+            return self._normalized_source_cache[cache_key]
+        normalized_data: Optional[Dict] = None
+        if file_type == "PDF":
+            all_text = ""
+            normalized_pages: Dict[int, str] = {}
+            try:
+                import pypdf
+
+                with open(source_file_path, "rb") as file:
+                    pdf_reader = pypdf.PdfReader(file)
+                    for page_num, page in enumerate(pdf_reader.pages, start=1):
+                        page_text = page.extract_text() or ""
+                        all_text += page_text + " "
+                        normalized_pages[page_num] = self._normalize_text_for_search(page_text)
+            except Exception:
+                try:
+                    from pdfminer.high_level import extract_pages
+                    from pdfminer.layout import LTTextContainer
+
+                    for page_num, page_layout in enumerate(extract_pages(source_file_path), start=1):
+                        page_text = ""
+                        for element in page_layout:
+                            if isinstance(element, LTTextContainer):
+                                page_text += element.get_text()
+                        all_text += page_text + " "
+                        normalized_pages[page_num] = self._normalize_text_for_search(page_text)
+                except Exception:
+                    return None
+            normalized_text = self._normalize_text_for_search(all_text)
+            normalized_data = {
+                "normalized_pages": normalized_pages,
+                "normalized_text": normalized_text,
+                "type": "PDF",
+                "num_pages": len(normalized_pages),
+                "original_text": all_text,
+            }
+        if normalized_data:
+            self._normalized_source_cache[cache_key] = normalized_data
+        return normalized_data
+
+    def _find_excerpt_in_normalized(self, page_norm: str, term: str, context: int = 180) -> str:
+        clean = self._normalize_text_for_search(term)
+        low = page_norm.lower()
+        idx = low.find(clean.lower()) if clean else -1
+        if idx < 0:
+            agg = self._normalize_text_aggressive(term)
+            al = self._normalize_text_aggressive(page_norm)
+            idx = al.lower().find(agg.lower()) if agg else -1
+            if idx >= 0:
+                # map approximate position back to page_norm (same length often)
+                idx = min(idx, max(0, len(page_norm) - 1))
+        if idx < 0:
+            return (page_norm[: min(len(page_norm), context * 2)] + "…") if page_norm else ""
+        a = max(0, idx - context)
+        b = min(len(page_norm), idx + len(clean) + context)
+        snippet = page_norm[a:b]
+        if a > 0:
+            snippet = "…" + snippet
+        if b < len(page_norm):
+            snippet = snippet + "…"
+        return snippet.strip()
+
+    def _estimate_page_from_position(self, data: Dict, term: str) -> int:
+        clean_quote = self._normalize_text_for_search(term)
+        normalized_text = data["normalized_text"]
+        position = normalized_text.lower().find(clean_quote.lower())
+        if position == -1:
+            position = len(normalized_text) // 2
+        num_pages = max(1, data.get("num_pages", 1))
+        avg = len(normalized_text) / num_pages
+        est = int(position / max(1e-6, avg)) + 1
+        return min(est, num_pages)
+
+    def search_term_in_pdf(self, pdf_path: str, term: str) -> List[Dict[str, Any]]:
+        """Return one record per page where the term matches; snippet is normalized PDF text window."""
+        data = self._load_and_normalize_source(pdf_path, "PDF")
+        if not data or not self._fuzzy_match_quote_in_normalized(term, data):
+            return []
+        out: List[Dict[str, Any]] = []
+        for page_num, ptxt in data["normalized_pages"].items():
+            sub = {"normalized_text": ptxt, "type": "PDF"}
+            if self._fuzzy_match_quote_in_normalized(term, sub):
+                out.append(
+                    {
+                        "page": page_num,
+                        "excerpt": self._find_excerpt_in_normalized(ptxt, term),
+                        "approximate": False,
+                    }
+                )
+        if not out:
+            est = self._estimate_page_from_position(data, term)
+            ntxt = data["normalized_text"]
+            out.append(
+                {
+                    "page": est,
+                    "excerpt": self._find_excerpt_in_normalized(ntxt, term, context=220),
+                    "approximate": True,
+                }
+            )
+        return out
+
+
+# -----------------------------------------------------------------------------
+# PDF metadata — APA-style line (author, year, title) from document info
+# -----------------------------------------------------------------------------
+
+
+def _parse_pdf_date_year(date_val) -> Optional[str]:
+    if date_val is None:
+        return None
+    s = str(date_val)
+    m = re.search(r"D:(\d{4})", s)
+    if m:
+        return m.group(1)
+    m = re.search(r"(\d{4})", s)
+    if m and 1900 <= int(m.group(1)) <= 2100:
+        return m.group(1)
+    return None
+
+
+def apa_reference_for_pdf(pdf_path: str) -> Tuple[str, str, str, str]:
+    """
+    Returns (author, title, year, apa_one_line).
+    Unknown fields use best-effort defaults suitable for a report.
+    """
+    from pathlib import Path
+
+    author = "Unknown"
+    title = Path(pdf_path).stem.replace("_", " ")
+    year = "n.d."
+    try:
+        import pypdf
+
+        with open(pdf_path, "rb") as f:
+            r = pypdf.PdfReader(f)
+            meta = r.metadata
+            if meta is not None:
+                t = getattr(meta, "title", None)
+                a = getattr(meta, "author", None)
+                if hasattr(meta, "get"):
+                    t = t or meta.get("/Title")  # type: ignore[union-attr]
+                    a = a or meta.get("/Author")  # type: ignore[union-attr]
+                if t and str(t).strip():
+                    title = str(t).strip()
+                if a and str(a).strip():
+                    author = str(a).strip()
+                dt = getattr(meta, "creation_date", None) or getattr(meta, "modification_date", None)
+                if dt is not None and hasattr(dt, "year"):
+                    year = str(dt.year)
+                else:
+                    raw = getattr(meta, "creation_date_raw", None) or getattr(meta, "modification_date_raw", None)
+                    y = _parse_pdf_date_year(raw)
+                    if y:
+                        year = y
+    except Exception:
+        pass
+    if year == "n.d.":
+        m = re.search(r"(20\d{2}|19\d{2})", title)
+        if m:
+            year = m.group(1)
+    apa = f"{author} ({year}). {title}."
+    return author, title, year, apa
+
+
+def first_author_from_metadata_author(author: str) -> str:
+    """First listed author, single cell for the tree: surname or first name segment from PDF metadata."""
+    if not author or not str(author).strip() or str(author).strip() == "Unknown":
+        return "Unknown"
+    a0 = re.split(r"\s*;\s*|\s+and\s+", str(author).strip(), maxsplit=1, flags=re.IGNORECASE)[0].strip()
+    a0 = re.sub(r"^\s*[\(\[]?et\s+al\.[\)\]]?\s*$", "", a0, flags=re.IGNORECASE)
+    if not a0:
+        return "Unknown"
+    if "," in a0:
+        return a0.split(",")[0].strip()
+    parts = a0.split()
+    return parts[0] if parts else a0
+
+
+def get_pdf_title_and_first_author(pdf_path: str) -> Tuple[str, str]:
+    """(document_title, first_author) for display columns."""
+    author, title, _year, _ = apa_reference_for_pdf(pdf_path)
+    return title, first_author_from_metadata_author(author)
+
+
+# -----------------------------------------------------------------------------
+# DOCX export (green highlight for verified match — same idea as Add Quotes in Word)
+# -----------------------------------------------------------------------------
+
+
+def export_docx(
+    output_path: str,
+    folder: str,
+    results_by_term: Dict[str, List[Dict[str, Any]]],
+    criteria_order: List[str],
+) -> None:
+    from docx import Document
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+    from docx.shared import Pt, RGBColor
+
+    doc = Document()
+    doc.add_heading("PDF criteria search report", 0)
+    p = doc.add_paragraph(
+        f"Folder searched: {folder}. "
+        "Each term uses the same normalized-text / fuzzy match logic as 'Add Quotes' in visualize_gui.py. "
+        "Green background indicates a match on the cited page; 'approximate page' is used when the match spans a page break."
+    )
+    p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+
+    for term in criteria_order:
+        hits = results_by_term.get(term, [])
+        doc.add_heading(term, level=2)
+        if not hits:
+            doc.add_paragraph("No matches in any PDF in this folder.")
+            continue
+        for h in hits:
+            pdf = h["pdf_path"]
+            _, _, _, apa = apa_reference_for_pdf(pdf)
+            doc.add_paragraph(apa, style="List Bullet")
+            for occ in h["occurrences"]:
+                page = occ["page"]
+                approx = occ.get("approximate")
+                ex = occ.get("excerpt", "")
+                line = f"p. {page}" + (" (approximate page)" if approx else "")
+                pr = doc.add_paragraph()
+                r0 = pr.add_run(line + " — ")
+                r0.bold = True
+                r0.font.size = Pt(10)
+                r1 = pr.add_run(ex)
+                r1.font.size = Pt(10)
+                r1.font.color.rgb = RGBColor(255, 255, 255)
+                rpr = r1._element.get_or_add_rPr()
+                shd = OxmlElement("w:shd")
+                shd.set(qn("w:fill"), "006400")
+                shd.set(qn("w:val"), "clear")
+                rpr.append(shd)
+            doc.add_paragraph()
+
+    doc.save(output_path)
+
+
+# -----------------------------------------------------------------------------
+# GUI
+# -----------------------------------------------------------------------------
+
+
+class CriteriaSearchApp(tk.Tk):
+    def __init__(self) -> None:
+        super().__init__()
+        self.title("PDF criteria search (Add Quotes matching)")
+        self.geometry("1280x720")
+        self.engine = QuoteSearchEngine()
+        self._search_results: Dict[str, List[Dict[str, Any]]] = {}
+        self._criteria_order: List[str] = []
+        self._pdf_display_cache: Dict[str, Tuple[str, str]] = {}
+        self.group_var = tk.BooleanVar(value=True)
+        self._terms_csv_path = terms_csv_path()
+        ensure_terms_csv(self._terms_csv_path)
+
+        top = ttk.Frame(self, padding=8)
+        top.pack(fill=tk.X)
+        ttk.Label(top, text="Folder with PDFs:").pack(side=tk.LEFT)
+        self.folder_var = tk.StringVar()
+        ttk.Entry(top, textvariable=self.folder_var, width=70).pack(side=tk.LEFT, fill=tk.X, expand=True, padx=4)
+        ttk.Button(top, text="Browse…", command=self._browse).pack(side=tk.LEFT)
+        ttk.Button(top, text="Search", command=self._start_search).pack(side=tk.LEFT, padx=4)
+        ttk.Button(top, text="Export DOCX…", command=self._export).pack(side=tk.LEFT)
+
+        self.progress = ttk.Progressbar(self, mode="indeterminate")
+        self.progress.pack(fill=tk.X, padx=8, pady=(0, 4))
+
+        body = ttk.PanedWindow(self, orient=tk.HORIZONTAL)
+        body.pack(fill=tk.BOTH, expand=True, padx=8, pady=4)
+
+        left = ttk.Frame(body, width=420)
+        body.add(left, weight=1)
+        left_top = ttk.Frame(left)
+        left_top.pack(fill=tk.X)
+        ttk.Label(
+            left_top,
+            text="Search terms (one word or token per line; load/save: criteria_search_terms.csv)",
+            wraplength=400,
+        ).pack(side=tk.LEFT, anchor=tk.W, fill=tk.X, expand=True)
+        ttk.Button(left_top, text="Save to CSV", command=self._save_terms_csv).pack(side=tk.RIGHT)
+        ttk.Label(left, text="Use # for comments", font=("Segoe UI", 8)).pack(anchor=tk.W, pady=(0, 2))
+        self.terms_text = tk.Text(left, width=50, height=24, wrap=tk.WORD, font=("Consolas", 9))
+        ys = ttk.Scrollbar(left, command=self.terms_text.yview)
+        self.terms_text.configure(yscrollcommand=ys.set)
+        self.terms_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        ys.pack(side=tk.RIGHT, fill=tk.Y)
+        for line in load_terms_from_csv(self._terms_csv_path):
+            self.terms_text.insert(tk.END, line + "\n")
+
+        right = ttk.Frame(body, width=640)
+        body.add(right, weight=2)
+        rhead = ttk.Frame(right)
+        rhead.pack(fill=tk.X)
+        ttk.Label(
+            rhead,
+            text="All keywords for one PDF, then the next. Columns: title & first author from PDF metadata.",
+            wraplength=750,
+        ).pack(side=tk.LEFT, fill=tk.X, expand=True, anchor=tk.W)
+        self.group_cb = ttk.Checkbutton(
+            rhead,
+            text="GROUP",
+            variable=self.group_var,
+            command=self._on_group_toggle,
+        )
+        self.group_cb.pack(side=tk.RIGHT)
+        ttk.Label(
+            right,
+            text="(GROUP: one row per PDF + term, preview shows all page hits together)",
+            font=("Segoe UI", 8),
+        ).pack(anchor=tk.W)
+        tree_fr = ttk.Frame(right)
+        tree_fr.pack(fill=tk.BOTH, expand=True)
+        cols = ("term", "title", "first_author", "pdf", "page", "approx")
+        self.tree = ttk.Treeview(tree_fr, columns=cols, show="headings", height=10)
+        self.tree.heading("term", text="Term")
+        self.tree.heading("title", text="Title")
+        self.tree.heading("first_author", text="First author")
+        self.tree.heading("pdf", text="PDF file")
+        self.tree.heading("page", text="Page")
+        self.tree.heading("approx", text="Approx?")
+        self.tree.column("term", width=120)
+        self.tree.column("title", width=220)
+        self.tree.column("first_author", width=110)
+        self.tree.column("pdf", width=150)
+        self.tree.column("page", width=90)
+        self.tree.column("approx", width=60)
+        y2 = ttk.Scrollbar(tree_fr, command=self.tree.yview)
+        self.tree.configure(yscrollcommand=y2.set)
+        self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        y2.pack(side=tk.RIGHT, fill=tk.Y)
+        self.tree.bind("<<TreeviewSelect>>", self._on_tree_select)
+        self._tree_row_meta: Dict[str, Dict[str, Any]] = {}
+
+        ttk.Label(right, text="Preview (excerpts)").pack(anchor=tk.W, pady=(8, 0))
+        prev_fr = ttk.Frame(right)
+        prev_fr.pack(fill=tk.BOTH, expand=True)
+        self.preview = tk.Text(prev_fr, height=10, wrap=tk.WORD, font=("Consolas", 9), state=tk.DISABLED)
+        self.preview.tag_configure("m", background="#006400", foreground="white")
+        pys = ttk.Scrollbar(prev_fr, command=self.preview.yview)
+        self.preview.configure(yscrollcommand=pys.set)
+        self.preview.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        pys.pack(side=tk.RIGHT, fill=tk.Y)
+
+        self.status = ttk.Label(
+            self,
+            text=f"Ready. Terms: {self._terms_csv_path}",
+            anchor=tk.W,
+        )
+        self.status.pack(fill=tk.X, padx=8, pady=4)
+
+    def _browse(self) -> None:
+        d = filedialog.askdirectory()
+        if d:
+            self.folder_var.set(d)
+            self.engine.clear_cache()
+
+    def _read_terms(self) -> List[str]:
+        raw = self.terms_text.get("1.0", tk.END)
+        return parse_terms_text(raw)
+
+    def _save_terms_csv(self) -> None:
+        terms = self._read_terms()
+        if not terms:
+            messagebox.showerror("No terms", "Add at least one line before saving.")
+            return
+        try:
+            write_terms_to_csv(self._terms_csv_path, terms)
+        except OSError as e:
+            messagebox.showerror("Save failed", str(e))
+            return
+        self.status.config(
+            text=f"Saved {len(terms)} terms to {self._terms_csv_path}"
+        )
+        messagebox.showinfo("Saved", f"Wrote {len(terms)} terms to:\n{self._terms_csv_path}")
+
+    def _start_search(self) -> None:
+        folder = self.folder_var.get().strip()
+        if not folder or not os.path.isdir(folder):
+            messagebox.showerror("Invalid folder", "Please choose a folder that contains PDFs.")
+            return
+        terms = self._read_terms()
+        if not terms:
+            messagebox.showerror("No terms", "Add at least one search term.")
+            return
+        self.engine.clear_cache()
+        self._pdf_display_cache.clear()
+        self.progress.start(8)
+        self.status.config(text="Searching…")
+        t = threading.Thread(target=self._search_worker, args=(folder, terms), daemon=True)
+        t.start()
+
+    def _search_worker(self, folder: str, terms: List[str]) -> None:
+        pdfs = sorted(
+            f for f in os.listdir(folder) if f.lower().endswith(".pdf")
+        )
+        full_paths = [os.path.join(folder, f) for f in pdfs]
+        results: Dict[str, List[Dict[str, Any]]] = {t: [] for t in terms}
+        for term in terms:
+            for fp in full_paths:
+                occ = self.engine.search_term_in_pdf(fp, term)
+                if occ:
+                    results[term].append({"pdf_path": fp, "occurrences": occ})
+        self._criteria_order = list(terms)
+        self._search_results = results
+        self.after(0, lambda: self._search_done(len(pdfs), len(terms)))
+
+    def _search_done(self, n_pdf: int, n_term: int) -> None:
+        self.progress.stop()
+        self.status.config(
+            text=f"Done. {n_pdf} PDF file(s), {n_term} term(s). Terms file: {self._terms_csv_path}"
+        )
+        self._fill_tree()
+        if not any(self._search_results.get(t) for t in self._search_results):
+            messagebox.showinfo("Search", "No matches for any term. Try editing terms or another folder.")
+
+    def _on_group_toggle(self) -> None:
+        if self._search_results:
+            self._fill_tree()
+
+    def _get_pdf_display_titles(self, fp: str) -> Tuple[str, str]:
+        if fp not in self._pdf_display_cache:
+            t, fa = get_pdf_title_and_first_author(fp)
+            self._pdf_display_cache[fp] = (t, fa)
+        return self._pdf_display_cache[fp]
+
+    def _build_pdf_to_term_blocks(self) -> Tuple[List[str], Dict[str, List[Tuple[str, Dict[str, Any]]]]]:
+        """
+        List PDFs in sorted name order. For each path, a list of (term, block) in criteria order.
+        """
+        pdf_data: Dict[str, List[Tuple[str, Dict[str, Any]]]] = {}
+        for term in self._criteria_order:
+            for block in self._search_results.get(term, []):
+                fp = block["pdf_path"]
+                pdf_data.setdefault(fp, []).append((term, block))
+        sorted_pdfs = sorted(pdf_data.keys(), key=lambda p: os.path.basename(p).lower())
+        return sorted_pdfs, pdf_data
+
+    def _fill_tree(self) -> None:
+        for i in self.tree.get_children():
+            self.tree.delete(i)
+        self._tree_row_meta.clear()
+        if not self._search_results or not any(self._search_results.get(t) for t in self._criteria_order):
+            return
+        grouped = self.group_var.get()
+        sorted_pdfs, pdf_data = self._build_pdf_to_term_blocks()
+        for fp in sorted_pdfs:
+            tdoc, tauth = self._get_pdf_display_titles(fp)
+            base = os.path.basename(fp)
+            for term, block in pdf_data[fp]:
+                occs = block.get("occurrences", [])
+                if not occs:
+                    continue
+                if grouped:
+                    apx = "yes" if any(o.get("approximate") for o in occs) else "no"
+                    pages = ", ".join(str(o["page"]) for o in occs)
+                    iid = self.tree.insert(
+                        "",
+                        tk.END,
+                        values=(term, tdoc, tauth, base, pages, apx),
+                    )
+                    self._tree_row_meta[iid] = {
+                        "term": term,
+                        "pdf_path": fp,
+                        "grouped": True,
+                        "items": [
+                            {
+                                "page": o["page"],
+                                "excerpt": o.get("excerpt", ""),
+                                "approximate": o.get("approximate", False),
+                            }
+                            for o in occs
+                        ],
+                    }
+                else:
+                    for occ in occs:
+                        apx = "yes" if occ.get("approximate") else "no"
+                        iid = self.tree.insert(
+                            "",
+                            tk.END,
+                            values=(term, tdoc, tauth, base, str(occ["page"]), apx),
+                        )
+                        self._tree_row_meta[iid] = {
+                            "term": term,
+                            "pdf_path": fp,
+                            "grouped": False,
+                            "excerpt": occ.get("excerpt", ""),
+                            "page": occ["page"],
+                            "approximate": occ.get("approximate", False),
+                        }
+
+    def _on_tree_select(self, _e=None) -> None:
+        sel = self.tree.selection()
+        if not sel:
+            return
+        meta = self._tree_row_meta.get(sel[0])
+        if not meta:
+            return
+        term = meta["term"]
+        if meta.get("grouped") and "items" in meta:
+            self._set_preview_hl_list(term, meta["items"])
+        else:
+            self._set_preview_hl(
+                term,
+                meta.get("excerpt", ""),
+            )
+
+    def _insert_excerpt_hl(self, term: str, excerpt: str) -> None:
+        n = self._normalize_for_preview(term)
+        if not excerpt:
+            self.preview.insert(tk.END, "(no excerpt)")
+            return
+        if not n:
+            self.preview.insert(tk.END, excerpt)
+            return
+        low_ex = excerpt.lower()
+        idx = low_ex.find(n.lower())
+        if idx < 0:
+            self.preview.insert(tk.END, excerpt)
+            return
+        self.preview.insert(tk.END, excerpt[:idx])
+        self.preview.insert(tk.END, excerpt[idx : idx + len(n)], "m")
+        self.preview.insert(tk.END, excerpt[idx + len(n) :])
+
+    def _set_preview_hl(self, term: str, excerpt: str) -> None:
+        self.preview.config(state=tk.NORMAL)
+        self.preview.delete("1.0", tk.END)
+        self._insert_excerpt_hl(term, excerpt)
+        self.preview.config(state=tk.DISABLED)
+
+    def _set_preview_hl_list(self, term: str, items: List[Dict[str, Any]]) -> None:
+        self.preview.config(state=tk.NORMAL)
+        self.preview.delete("1.0", tk.END)
+        for i, it in enumerate(items):
+            if i:
+                self.preview.insert(tk.END, "\n\n")
+            p = it.get("page", "")
+            apx = " (approx.)" if it.get("approximate") else ""
+            self.preview.insert(tk.END, f"p. {p}{apx}\n")
+            self._insert_excerpt_hl(term, it.get("excerpt", ""))
+        self.preview.config(state=tk.DISABLED)
+
+    def _normalize_for_preview(self, term: str) -> str:
+        e = self.engine
+        a = e._normalize_text_for_search(term)
+        b = e._normalize_text_aggressive(term)
+        return a if len(a) >= len(b) else b
+
+    def _export(self) -> None:
+        if not self._search_results or not any(self._search_results.values()):
+            messagebox.showinfo("Export", "Run a search with at least one match first.")
+            return
+        try:
+            import docx  # noqa: F401
+        except ImportError:
+            messagebox.showerror("Missing package", "Install python-docx: pip install python-docx")
+            return
+        path = filedialog.asksaveasfilename(
+            defaultextension=".docx",
+            filetypes=[("Word", "*.docx"), ("All", "*.*")],
+        )
+        if not path:
+            return
+        try:
+            export_docx(
+                path,
+                self.folder_var.get().strip(),
+                self._search_results,
+                self._criteria_order,
+            )
+            messagebox.showinfo("Export", f"Saved:\n{path}")
+        except Exception as ex:  # noqa: BLE001
+            messagebox.showerror("Export failed", str(ex))
+
+
+def main() -> int:
+    # pypdf can trigger cryptography’s ARC4 import warning (third-party, harmless for read-only PDFs)
+    import warnings
+
+    try:
+        from cryptography.utils import CryptographyDeprecationWarning
+
+        warnings.filterwarnings("ignore", category=CryptographyDeprecationWarning)
+    except ImportError:
+        warnings.filterwarnings("ignore", message=".*ARC4.*")
+    try:
+        import pypdf  # noqa: F401
+    except ImportError:
+        print("Install pypdf: pip install pypdf", file=sys.stderr)
+        return 1
+    app = CriteriaSearchApp()
+    app.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

pdf_criteria_search_gui_v2.py

@@ -0,0 +1,991 @@
+"""
+Multi-PDF criteria search GUI using the same quote / text match logic as
+"Add Quotes" in visualize_gui.py (normalization + _fuzzy_match_quote_in_normalized).
+
+No LLMs. Results can be exported to an easy-to-read .docx with page numbers
+and APA-style references from PDF metadata.
+"""
+
+from __future__ import annotations
+
+import csv
+import os
+import re
+import sys
+import threading
+import tkinter as tk
+from tkinter import filedialog, messagebox, ttk
+from typing import Any, Dict, List, Optional, Tuple
+
+from search_keywords import (
+    CATEGORY_HEADINGS,
+    CATEGORY_STYLES,
+    KEY_TO_CATEGORY,
+    SEARCH_KEYWORDS,
+    ordered_group_keys,
+)
+
+# -----------------------------------------------------------------------------
+# Search terms: each line is a *group id*; phrases for that group live in
+# search_keywords.py. Optional criteria_search_terms.csv overrides the ordered list.
+# -----------------------------------------------------------------------------
+
+TERMS_CSV_NAME = "criteria_search_terms.csv"
+
+
+def terms_csv_path() -> str:
+    return os.path.join(os.path.dirname(os.path.abspath(__file__)), TERMS_CSV_NAME)
+
+
+def ensure_terms_csv(path: str) -> None:
+    if os.path.isfile(path):
+        return
+    write_terms_to_csv(path, ordered_group_keys())
+
+
+def load_terms_from_csv(path: str) -> List[str]:
+    if not os.path.isfile(path):
+        return list(ordered_group_keys())
+    terms: List[str] = []
+    with open(path, newline="", encoding="utf-8") as f:
+        reader = csv.reader(f)
+        rows = list(reader)
+    if not rows:
+        return list(ordered_group_keys())
+    header = [c.strip().lower() for c in rows[0]]
+    col = 0
+    if "term" in header:
+        col = header.index("term")
+    for row in rows[1:]:
+        if col >= len(row):
+            continue
+        t = row[col].strip() if row[col] else ""
+        if t and not t.startswith("#"):
+            terms.append(t)
+    return terms if terms else list(ordered_group_keys())
+
+
+def write_terms_to_csv(path: str, terms: List[str]) -> None:
+    with open(path, "w", newline="", encoding="utf-8") as f:
+        w = csv.writer(f)
+        w.writerow(["term"])
+        for t in terms:
+            t = t.strip()
+            if t:
+                w.writerow([t])
+
+
+def parse_terms_text(raw: str) -> List[str]:
+    """One group id per line (ignores empty lines and # comment lines, including section headers)."""
+    out: List[str] = []
+    for line in raw.splitlines():
+        s = line.strip()
+        if not s or s.startswith("#"):
+            continue
+        out.append(s)
+    return out
+
+
+def phrases_for_group_key(key: str) -> List[str]:
+    """All PDF search phrases for a group, or a single best-effort phrase for custom keys."""
+    return list(SEARCH_KEYWORDS.get(key, [key.replace("_", " ")]))
+
+
+def sanitize_xml_compatible(text: str) -> str:
+    """
+    Strip characters that are illegal in XML 1.0 / OOXML text runs (e.g. NUL from PDFs).
+    python-docx raises if runs contain bare control characters.
+    """
+    if not text:
+        return ""
+    out: List[str] = []
+    for ch in text:
+        o = ord(ch)
+        if o in (0x9, 0xA, 0xD):
+            out.append(ch)
+        elif 0x20 <= o <= 0xD7FF:
+            out.append(ch)
+        elif 0xE000 <= o <= 0xFFFD:
+            out.append(ch)
+        elif 0x10000 <= o <= 0x10FFFF:
+            out.append(ch)
+    return "".join(out)
+
+
+def _normalize_text_for_search_static(text: str) -> str:
+    """Same normalization as QuoteSearchEngine._normalize_text_for_search (for highlight spans)."""
+    import re
+
+    text = re.sub(r"-\s+([a-z])", r"\1", text)
+    text = re.sub(r"-\s*\n\s*([a-z])", r"\1", text)
+    text = re.sub(r"[\r\n]+", " ", text)
+    normalized = re.sub(r"\s+", " ", text)
+    return normalized.strip()
+
+
+def best_highlight_phrase_for_group(group_key: str, excerpt: str) -> str:
+    """
+    Contiguous substring in excerpt to highlight — same rules as CriteriaSearchApp._best_highlight_phrase
+    (Tk preview): longest matching phrase, else longest token from phrases, else normalized group label.
+    """
+    import re
+
+    if not excerpt:
+        return ""
+    ex_low = excerpt.lower()
+    candidates = list(phrases_for_group_key(group_key))
+
+    for p in sorted(candidates, key=len, reverse=True):
+        p = p.strip()
+        if len(p) < 2:
+            continue
+        lo = ex_low.find(p.lower())
+        if lo >= 0:
+            return excerpt[lo : lo + len(p)]
+
+    tokens: List[str] = []
+    seen_lower: set = set()
+    for p in candidates:
+        for w in re.findall(r"[A-Za-z][A-Za-z0-9\-]{2,}", p):
+            if len(w) >= 3:
+                wl = w.lower()
+                if wl not in seen_lower:
+                    seen_lower.add(wl)
+                    tokens.append(w)
+    tokens.sort(key=len, reverse=True)
+    for w in tokens:
+        lo = ex_low.find(w.lower())
+        if lo >= 0:
+            return excerpt[lo : lo + len(w)]
+
+    n = _normalize_text_for_search_static(group_key.replace("_", " "))
+    if n and len(n) >= 3:
+        lo = ex_low.find(n.lower())
+        if lo >= 0:
+            return excerpt[lo : lo + len(n)]
+    return ""
+
+
+# -----------------------------------------------------------------------------
+# Quote search engine — aligned with visualize_gui.py (Add Quotes PDF verification)
+# -----------------------------------------------------------------------------
+
+
+class QuoteSearchEngine:
+    """Normalizes text and runs the same multi-strategy match used in Add Quotes."""
+
+    def __init__(self) -> None:
+        self._normalized_source_cache: Dict[str, Any] = {}
+
+    def clear_cache(self) -> None:
+        self._normalized_source_cache.clear()
+
+    def _normalize_text_for_search(self, text: str) -> str:
+        import re
+
+        text = re.sub(r"-\s+([a-z])", r"\1", text)
+        text = re.sub(r"-\s*\n\s*([a-z])", r"\1", text)
+        text = re.sub(r"[\r\n]+", " ", text)
+        normalized = re.sub(r"\s+", " ", text)
+        return normalized.strip()
+
+    def _normalize_text_aggressive(self, text: str) -> str:
+        import re
+
+        normalized = self._normalize_text_for_search(text)
+        normalized = normalized.rstrip(".,;:!?")
+        normalized = re.sub(r"\s*([,.;:!?])\s*", r"\1 ", normalized)
+        normalized = re.sub(r"\s+", " ", normalized)
+        return normalized.strip()
+
+    def _fuzzy_match_quote_in_normalized(self, quote_text: str, normalized_data: Optional[Dict]) -> bool:
+        if normalized_data is None:
+            return False
+        normalized_source = normalized_data["normalized_text"]
+        clean_quote = self._normalize_text_for_search(quote_text)
+        if clean_quote in normalized_source:
+            return True
+        if clean_quote.lower() in normalized_source.lower():
+            return True
+        agg_quote = self._normalize_text_aggressive(quote_text)
+        agg_source = self._normalize_text_aggressive(normalized_source)
+        if agg_quote.lower() in agg_source.lower():
+            return True
+        quote_words: List[str] = []
+        for w in clean_quote.split():
+            cleaned = w.strip(".,;:!?()[]{}\"'").lower()
+            if len(cleaned) > 1:
+                quote_words.append(cleaned)
+        source_words: List[str] = []
+        for w in normalized_source.split():
+            cleaned = w.strip(".,;:!?()[]{}\"'").lower()
+            if len(cleaned) > 1:
+                source_words.append(cleaned)
+        if len(quote_words) >= 3:
+            quote_idx = 0
+            consecutive_matches = 0
+            max_consecutive = 0
+            for source_word in source_words:
+                if quote_idx < len(quote_words) and source_word == quote_words[quote_idx]:
+                    quote_idx += 1
+                    consecutive_matches += 1
+                    max_consecutive = max(max_consecutive, consecutive_matches)
+                    if quote_idx == len(quote_words):
+                        return True
+                else:
+                    consecutive_matches = 0
+            if quote_idx >= len(quote_words) * 0.70:
+                return True
+            if max_consecutive >= min(3, len(quote_words) * 0.4):
+                return True
+        if len(quote_words) >= 8:
+            middle_quote_words = quote_words[2:-2]
+            if len(middle_quote_words) >= 3:
+                qidx = 0
+                for source_word in source_words:
+                    if qidx < len(middle_quote_words) and source_word == middle_quote_words[qidx]:
+                        qidx += 1
+                        if qidx == len(middle_quote_words):
+                            return True
+                if qidx >= len(middle_quote_words) * 0.70:
+                    return True
+        if quote_text.startswith("Quote "):
+            parts = quote_text.split(":", 1)
+            if len(parts) > 1:
+                after = parts[1].strip()
+                no_prefix = self._normalize_text_for_search(after)
+                if no_prefix.lower() in normalized_source.lower():
+                    return True
+        return False
+
+    def _load_and_normalize_source(self, source_file_path: str, file_type: str) -> Optional[Dict]:
+        cache_key = f"{source_file_path}_{file_type}"
+        if cache_key in self._normalized_source_cache:
+            return self._normalized_source_cache[cache_key]
+        normalized_data: Optional[Dict] = None
+        if file_type == "PDF":
+            all_text = ""
+            normalized_pages: Dict[int, str] = {}
+            try:
+                import pypdf
+
+                with open(source_file_path, "rb") as file:
+                    pdf_reader = pypdf.PdfReader(file)
+                    for page_num, page in enumerate(pdf_reader.pages, start=1):
+                        page_text = page.extract_text() or ""
+                        all_text += page_text + " "
+                        normalized_pages[page_num] = self._normalize_text_for_search(page_text)
+            except Exception:
+                try:
+                    from pdfminer.high_level import extract_pages
+                    from pdfminer.layout import LTTextContainer
+
+                    for page_num, page_layout in enumerate(extract_pages(source_file_path), start=1):
+                        page_text = ""
+                        for element in page_layout:
+                            if isinstance(element, LTTextContainer):
+                                page_text += element.get_text()
+                        all_text += page_text + " "
+                        normalized_pages[page_num] = self._normalize_text_for_search(page_text)
+                except Exception:
+                    return None
+            normalized_text = self._normalize_text_for_search(all_text)
+            normalized_data = {
+                "normalized_pages": normalized_pages,
+                "normalized_text": normalized_text,
+                "type": "PDF",
+                "num_pages": len(normalized_pages),
+                "original_text": all_text,
+            }
+        if normalized_data:
+            self._normalized_source_cache[cache_key] = normalized_data
+        return normalized_data
+
+    def _find_excerpt_in_normalized(self, page_norm: str, term: str, context: int = 180) -> str:
+        clean = self._normalize_text_for_search(term)
+        low = page_norm.lower()
+        idx = low.find(clean.lower()) if clean else -1
+        if idx < 0:
+            agg = self._normalize_text_aggressive(term)
+            al = self._normalize_text_aggressive(page_norm)
+            idx = al.lower().find(agg.lower()) if agg else -1
+            if idx >= 0:
+                # map approximate position back to page_norm (same length often)
+                idx = min(idx, max(0, len(page_norm) - 1))
+        if idx < 0:
+            return (page_norm[: min(len(page_norm), context * 2)] + "…") if page_norm else ""
+        a = max(0, idx - context)
+        b = min(len(page_norm), idx + len(clean) + context)
+        snippet = page_norm[a:b]
+        if a > 0:
+            snippet = "…" + snippet
+        if b < len(page_norm):
+            snippet = snippet + "…"
+        return snippet.strip()
+
+    def _estimate_page_from_position(self, data: Dict, term: str) -> int:
+        clean_quote = self._normalize_text_for_search(term)
+        normalized_text = data["normalized_text"]
+        position = normalized_text.lower().find(clean_quote.lower())
+        if position == -1:
+            position = len(normalized_text) // 2
+        num_pages = max(1, data.get("num_pages", 1))
+        avg = len(normalized_text) / num_pages
+        est = int(position / max(1e-6, avg)) + 1
+        return min(est, num_pages)
+
+    def search_term_in_pdf(self, pdf_path: str, term: str) -> List[Dict[str, Any]]:
+        """Return one record per page where the term matches; snippet is normalized PDF text window."""
+        data = self._load_and_normalize_source(pdf_path, "PDF")
+        if not data or not self._fuzzy_match_quote_in_normalized(term, data):
+            return []
+        out: List[Dict[str, Any]] = []
+        for page_num, ptxt in data["normalized_pages"].items():
+            sub = {"normalized_text": ptxt, "type": "PDF"}
+            if self._fuzzy_match_quote_in_normalized(term, sub):
+                out.append(
+                    {
+                        "page": page_num,
+                        "excerpt": self._find_excerpt_in_normalized(ptxt, term),
+                        "approximate": False,
+                    }
+                )
+        if not out:
+            est = self._estimate_page_from_position(data, term)
+            ntxt = data["normalized_text"]
+            out.append(
+                {
+                    "page": est,
+                    "excerpt": self._find_excerpt_in_normalized(ntxt, term, context=220),
+                    "approximate": True,
+                }
+            )
+        return out
+
+    def search_group_in_pdf(self, pdf_path: str, phrases: List[str]) -> List[Dict[str, Any]]:
+        """
+        Search all phrases in the group; merge hits by page. Any phrase that matches
+        on a page counts; excerpt prefers the longer span for that page.
+        """
+        if not phrases:
+            return []
+        by_page: Dict[int, Dict[str, Any]] = {}
+        for phrase in phrases:
+            hits = self.search_term_in_pdf(pdf_path, phrase)
+            for h in hits:
+                p = h["page"]
+                prev = by_page.get(p)
+                if prev is None:
+                    by_page[p] = dict(h)
+                    continue
+                e_old = (prev.get("excerpt") or "")
+                e_new = (h.get("excerpt") or "")
+                if len(e_new) > len(e_old):
+                    prev["excerpt"] = e_new
+                if h.get("approximate") is False:
+                    prev["approximate"] = False
+        return [by_page[k] for k in sorted(by_page)]
+
+
+# -----------------------------------------------------------------------------
+# PDF metadata — APA-style line (author, year, title) from document info
+# -----------------------------------------------------------------------------
+
+
+def _parse_pdf_date_year(date_val) -> Optional[str]:
+    if date_val is None:
+        return None
+    s = str(date_val)
+    m = re.search(r"D:(\d{4})", s)
+    if m:
+        return m.group(1)
+    m = re.search(r"(\d{4})", s)
+    if m and 1900 <= int(m.group(1)) <= 2100:
+        return m.group(1)
+    return None
+
+
+def apa_reference_for_pdf(pdf_path: str) -> Tuple[str, str, str, str]:
+    """
+    Returns (author, title, year, apa_one_line).
+    Unknown fields use best-effort defaults suitable for a report.
+    """
+    from pathlib import Path
+
+    author = "Unknown"
+    title = Path(pdf_path).stem.replace("_", " ")
+    year = "n.d."
+    try:
+        import pypdf
+
+        with open(pdf_path, "rb") as f:
+            r = pypdf.PdfReader(f)
+            meta = r.metadata
+            if meta is not None:
+                t = getattr(meta, "title", None)
+                a = getattr(meta, "author", None)
+                if hasattr(meta, "get"):
+                    t = t or meta.get("/Title")  # type: ignore[union-attr]
+                    a = a or meta.get("/Author")  # type: ignore[union-attr]
+                if t and str(t).strip():
+                    title = str(t).strip()
+                if a and str(a).strip():
+                    author = str(a).strip()
+                dt = getattr(meta, "creation_date", None) or getattr(meta, "modification_date", None)
+                if dt is not None and hasattr(dt, "year"):
+                    year = str(dt.year)
+                else:
+                    raw = getattr(meta, "creation_date_raw", None) or getattr(meta, "modification_date_raw", None)
+                    y = _parse_pdf_date_year(raw)
+                    if y:
+                        year = y
+    except Exception:
+        pass
+    if year == "n.d.":
+        m = re.search(r"(20\d{2}|19\d{2})", title)
+        if m:
+            year = m.group(1)
+    apa = f"{author} ({year}). {title}."
+    return author, title, year, apa
+
+
+def first_author_from_metadata_author(author: str) -> str:
+    """First listed author, single cell for the tree: surname or first name segment from PDF metadata."""
+    if not author or not str(author).strip() or str(author).strip() == "Unknown":
+        return "Unknown"
+    a0 = re.split(r"\s*;\s*|\s+and\s+", str(author).strip(), maxsplit=1, flags=re.IGNORECASE)[0].strip()
+    a0 = re.sub(r"^\s*[\(\[]?et\s+al\.[\)\]]?\s*$", "", a0, flags=re.IGNORECASE)
+    if not a0:
+        return "Unknown"
+    if "," in a0:
+        return a0.split(",")[0].strip()
+    parts = a0.split()
+    return parts[0] if parts else a0
+
+
+def get_pdf_title_and_first_author(pdf_path: str) -> Tuple[str, str]:
+    """(document_title, first_author) for display columns."""
+    author, title, _year, _ = apa_reference_for_pdf(pdf_path)
+    return title, first_author_from_metadata_author(author)
+
+
+# -----------------------------------------------------------------------------
+# DOCX export (green highlight for verified match — same idea as Add Quotes in Word)
+# -----------------------------------------------------------------------------
+
+
+def export_docx(
+    output_path: str,
+    folder: str,
+    results_by_term: Dict[str, List[Dict[str, Any]]],
+    criteria_order: List[str],
+) -> None:
+    from docx import Document
+    from docx.enum.text import WD_ALIGN_PARAGRAPH
+    from docx.oxml import OxmlElement
+    from docx.oxml.ns import qn
+    from docx.shared import Pt, RGBColor
+
+    doc = Document()
+    doc.add_heading(sanitize_xml_compatible("PDF criteria search report"), 0)
+    folder_safe = sanitize_xml_compatible(folder or "")
+    p = doc.add_paragraph(
+        sanitize_xml_compatible(
+            f"Folder searched: {folder_safe}. "
+            "Each group key searches a list of related phrases (see search_keywords.py). "
+            "Matching uses the same normalized-text / fuzzy match logic as 'Add Quotes' in visualize_gui.py. "
+            "Green background indicates a match on the cited page; 'approximate page' is used when the match spans a page break."
+        )
+    )
+    p.alignment = WD_ALIGN_PARAGRAPH.JUSTIFY
+
+    for term in criteria_order:
+        hits = results_by_term.get(term, [])
+        doc.add_heading(sanitize_xml_compatible(str(term)), level=2)
+        if not hits:
+            doc.add_paragraph(sanitize_xml_compatible("No matches in any PDF in this folder."))
+            continue
+        for h in hits:
+            pdf = h["pdf_path"]
+            _, _, _, apa = apa_reference_for_pdf(pdf)
+            doc.add_paragraph(sanitize_xml_compatible(apa), style="List Bullet")
+            for occ in h["occurrences"]:
+                page = occ["page"]
+                approx = occ.get("approximate")
+                raw_ex = occ.get("excerpt", "") or ""
+                phrase = best_highlight_phrase_for_group(str(term), raw_ex)
+                line = sanitize_xml_compatible(
+                    f"p. {page}" + (" (approximate page)" if approx else "")
+                )
+                pr = doc.add_paragraph()
+                r0 = pr.add_run(line + " — ")
+                r0.bold = True
+                r0.font.size = Pt(10)
+
+                def add_green_run(txt: str) -> None:
+                    t = sanitize_xml_compatible(txt)
+                    if not t:
+                        return
+                    rr = pr.add_run(t)
+                    rr.font.size = Pt(10)
+                    rr.font.color.rgb = RGBColor(255, 255, 255)
+                    rpr = rr._element.get_or_add_rPr()
+                    shd = OxmlElement("w:shd")
+                    shd.set(qn("w:fill"), "006400")
+                    shd.set(qn("w:val"), "clear")
+                    rpr.append(shd)
+
+                def add_plain_run(txt: str) -> None:
+                    t = sanitize_xml_compatible(txt)
+                    if not t:
+                        return
+                    rr = pr.add_run(t)
+                    rr.font.size = Pt(10)
+
+                if phrase and raw_ex:
+                    lo = raw_ex.lower().find(phrase.lower())
+                    if lo >= 0:
+                        hi = lo + len(phrase)
+                        add_plain_run(raw_ex[:lo])
+                        add_green_run(raw_ex[lo:hi])
+                        add_plain_run(raw_ex[hi:])
+                    else:
+                        add_plain_run(raw_ex)
+                else:
+                    add_plain_run(raw_ex)
+            doc.add_paragraph()
+
+    doc.save(output_path)
+
+
+# -----------------------------------------------------------------------------
+# GUI
+# -----------------------------------------------------------------------------
+
+
+class CriteriaSearchApp(tk.Tk):
+    def __init__(self) -> None:
+        super().__init__()
+        self.title("PDF criteria search (Add Quotes matching)")
+        self.geometry("1280x720")
+        self.engine = QuoteSearchEngine()
+        self._search_results: Dict[str, List[Dict[str, Any]]] = {}
+        self._criteria_order: List[str] = []
+        self._pdf_display_cache: Dict[str, Tuple[str, str]] = {}
+        self.group_var = tk.BooleanVar(value=True)
+        self._terms_csv_path = terms_csv_path()
+        ensure_terms_csv(self._terms_csv_path)
+
+        top = ttk.Frame(self, padding=8)
+        top.pack(fill=tk.X)
+        ttk.Label(top, text="Folder with PDFs:").pack(side=tk.LEFT)
+        self.folder_var = tk.StringVar()
+        ttk.Entry(top, textvariable=self.folder_var, width=70).pack(side=tk.LEFT, fill=tk.X, expand=True, padx=4)
+        ttk.Button(top, text="Browse…", command=self._browse).pack(side=tk.LEFT)
+        ttk.Button(top, text="Search", command=self._start_search).pack(side=tk.LEFT, padx=4)
+        ttk.Button(top, text="Export DOCX…", command=self._export).pack(side=tk.LEFT)
+
+        self.progress = ttk.Progressbar(self, mode="indeterminate")
+        self.progress.pack(fill=tk.X, padx=8, pady=(0, 4))
+
+        body = ttk.PanedWindow(self, orient=tk.HORIZONTAL)
+        body.pack(fill=tk.BOTH, expand=True, padx=8, pady=4)
+
+        left = ttk.Frame(body, width=420)
+        body.add(left, weight=1)
+        left_top = ttk.Frame(left)
+        left_top.pack(fill=tk.X)
+        ttk.Label(
+            left_top,
+            text="Group keys (search_keywords.py): each key searches all listed phrases. Save list: CSV.",
+            wraplength=400,
+        ).pack(side=tk.LEFT, anchor=tk.W, fill=tk.X, expand=True)
+        ttk.Button(left_top, text="Save to CSV", command=self._save_terms_csv).pack(side=tk.RIGHT)
+        ttk.Label(left, text="# = section header. Colors = category.", font=("Segoe UI", 8)).pack(
+            anchor=tk.W, pady=(0, 2)
+        )
+        self.terms_text = tk.Text(left, width=52, height=24, wrap=tk.WORD, font=("Consolas", 9))
+        ys = ttk.Scrollbar(left, command=self.terms_text.yview)
+        self.terms_text.configure(yscrollcommand=ys.set)
+        self.terms_text.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        ys.pack(side=tk.RIGHT, fill=tk.Y)
+        self._setup_term_text_tags()
+        self._insert_keys_colored(load_terms_from_csv(self._terms_csv_path))
+
+        right = ttk.Frame(body, width=640)
+        body.add(right, weight=2)
+        rhead = ttk.Frame(right)
+        rhead.pack(fill=tk.X)
+        ttk.Label(
+            rhead,
+            text="All keywords for one PDF, then the next. Columns: title & first author from PDF metadata.",
+            wraplength=750,
+        ).pack(side=tk.LEFT, fill=tk.X, expand=True, anchor=tk.W)
+        self.group_cb = ttk.Checkbutton(
+            rhead,
+            text="GROUP",
+            variable=self.group_var,
+            command=self._on_group_toggle,
+        )
+        self.group_cb.pack(side=tk.RIGHT)
+        ttk.Label(
+            right,
+            text="(GROUP: one row per PDF + term, preview shows all page hits together)",
+            font=("Segoe UI", 8),
+        ).pack(anchor=tk.W)
+        tree_fr = ttk.Frame(right)
+        tree_fr.pack(fill=tk.BOTH, expand=True)
+        cols = ("term", "title", "first_author", "pdf", "page", "approx")
+        self.tree = ttk.Treeview(tree_fr, columns=cols, show="headings", height=10)
+        self.tree.heading("term", text="Term")
+        self.tree.heading("title", text="Title")
+        self.tree.heading("first_author", text="First author")
+        self.tree.heading("pdf", text="PDF file")
+        self.tree.heading("page", text="Page")
+        self.tree.heading("approx", text="Approx?")
+        self.tree.column("term", width=120)
+        self.tree.column("title", width=220)
+        self.tree.column("first_author", width=110)
+        self.tree.column("pdf", width=150)
+        self.tree.column("page", width=90)
+        self.tree.column("approx", width=60)
+        y2 = ttk.Scrollbar(tree_fr, command=self.tree.yview)
+        self.tree.configure(yscrollcommand=y2.set)
+        self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        y2.pack(side=tk.RIGHT, fill=tk.Y)
+        self.tree.bind("<<TreeviewSelect>>", self._on_tree_select)
+        self._tree_row_meta: Dict[str, Dict[str, Any]] = {}
+        self._configure_tree_category_tags()
+
+        ttk.Label(right, text="Preview (excerpts)").pack(anchor=tk.W, pady=(8, 0))
+        prev_fr = ttk.Frame(right)
+        prev_fr.pack(fill=tk.BOTH, expand=True)
+        self.preview = tk.Text(prev_fr, height=10, wrap=tk.WORD, font=("Consolas", 9), state=tk.DISABLED)
+        self.preview.tag_configure("m", background="#006400", foreground="white")
+        pys = ttk.Scrollbar(prev_fr, command=self.preview.yview)
+        self.preview.configure(yscrollcommand=pys.set)
+        self.preview.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        pys.pack(side=tk.RIGHT, fill=tk.Y)
+        ttk.Label(
+            right,
+            text=(
+                "Highlight: green needs the exact substring in the excerpt. "
+                "Matches without green used fuzzy/word-order logic or an excerpt slice without one whole phrase."
+            ),
+            font=("Segoe UI", 8),
+            wraplength=760,
+            foreground="#444444",
+        ).pack(anchor=tk.W, pady=(4, 0))
+
+        self.status = ttk.Label(
+            self,
+            text=f"Ready. Terms: {self._terms_csv_path}",
+            anchor=tk.W,
+        )
+        self.status.pack(fill=tk.X, padx=8, pady=4)
+
+    def _browse(self) -> None:
+        d = filedialog.askdirectory()
+        if d:
+            self.folder_var.set(d)
+            self.engine.clear_cache()
+
+    def _configure_tree_category_tags(self) -> None:
+        """Match row colors to left-panel category colors (whole row uses category fg/bg)."""
+        for cat_id, (bg, fg) in CATEGORY_STYLES.items():
+            self.tree.tag_configure(f"tcat_{cat_id}", background=bg, foreground=fg)
+        self.tree.tag_configure(
+            "pdf_sep",
+            background="#D5D5D5",
+            foreground="#333333",
+            font=("Segoe UI", 9, "bold"),
+        )
+
+    def _tree_tag_for_term(self, term: str) -> str:
+        cat = KEY_TO_CATEGORY.get(term, "unknown")
+        return f"tcat_{cat}"
+
+    def _setup_term_text_tags(self) -> None:
+        self.terms_text.tag_configure(
+            "header",
+            background="#ECEFF1",
+            foreground="#37474F",
+            font=("Consolas", 9, "bold"),
+        )
+        for cat_id, (bg, fg) in CATEGORY_STYLES.items():
+            self.terms_text.tag_configure(f"cat_{cat_id}", background=bg, foreground=fg)
+
+    def _insert_keys_colored(self, keys: List[str]) -> None:
+        self.terms_text.delete("1.0", tk.END)
+        if not keys:
+            return
+        last_cat: Optional[str] = None
+        for key in keys:
+            cat = KEY_TO_CATEGORY.get(key, "unknown")
+            if cat != last_cat:
+                if last_cat is not None:
+                    self.terms_text.insert(tk.END, "\n")
+                title = CATEGORY_HEADINGS.get(cat, cat)
+                self.terms_text.insert(tk.END, f"# --- {title} ---\n", "header")
+                last_cat = cat
+            self.terms_text.insert(tk.END, f"{key}\n", f"cat_{cat}")
+
+    def _read_terms(self) -> List[str]:
+        raw = self.terms_text.get("1.0", tk.END)
+        return parse_terms_text(raw)
+
+    def _save_terms_csv(self) -> None:
+        terms = self._read_terms()
+        if not terms:
+            messagebox.showerror("No terms", "Add at least one line before saving.")
+            return
+        try:
+            write_terms_to_csv(self._terms_csv_path, terms)
+        except OSError as e:
+            messagebox.showerror("Save failed", str(e))
+            return
+        self._insert_keys_colored(terms)
+        self.status.config(
+            text=f"Saved {len(terms)} terms to {self._terms_csv_path}"
+        )
+        messagebox.showinfo("Saved", f"Wrote {len(terms)} terms to:\n{self._terms_csv_path}")
+
+    def _start_search(self) -> None:
+        folder = self.folder_var.get().strip()
+        if not folder or not os.path.isdir(folder):
+            messagebox.showerror("Invalid folder", "Please choose a folder that contains PDFs.")
+            return
+        terms = self._read_terms()
+        if not terms:
+            messagebox.showerror("No terms", "Add at least one search term.")
+            return
+        self.engine.clear_cache()
+        self._pdf_display_cache.clear()
+        self.progress.start(8)
+        self.status.config(text="Searching…")
+        t = threading.Thread(target=self._search_worker, args=(folder, terms), daemon=True)
+        t.start()
+
+    def _search_worker(self, folder: str, terms: List[str]) -> None:
+        pdfs = sorted(
+            f for f in os.listdir(folder) if f.lower().endswith(".pdf")
+        )
+        full_paths = [os.path.join(folder, f) for f in pdfs]
+        results: Dict[str, List[Dict[str, Any]]] = {t: [] for t in terms}
+        for term in terms:
+            phrases = phrases_for_group_key(term)
+            for fp in full_paths:
+                occ = self.engine.search_group_in_pdf(fp, phrases)
+                if occ:
+                    results[term].append({"pdf_path": fp, "occurrences": occ})
+        self._criteria_order = list(terms)
+        self._search_results = results
+        self.after(0, lambda: self._search_done(len(pdfs), len(terms)))
+
+    def _search_done(self, n_pdf: int, n_term: int) -> None:
+        self.progress.stop()
+        self.status.config(
+            text=f"Done. {n_pdf} PDF file(s), {n_term} term(s). Terms file: {self._terms_csv_path}"
+        )
+        self._fill_tree()
+        if not any(self._search_results.get(t) for t in self._search_results):
+            messagebox.showinfo("Search", "No matches for any term. Try editing terms or another folder.")
+
+    def _on_group_toggle(self) -> None:
+        if self._search_results:
+            self._fill_tree()
+
+    def _get_pdf_display_titles(self, fp: str) -> Tuple[str, str]:
+        if fp not in self._pdf_display_cache:
+            t, fa = get_pdf_title_and_first_author(fp)
+            self._pdf_display_cache[fp] = (t, fa)
+        return self._pdf_display_cache[fp]
+
+    def _build_pdf_to_term_blocks(self) -> Tuple[List[str], Dict[str, List[Tuple[str, Dict[str, Any]]]]]:
+        """
+        List PDFs in sorted name order. For each path, a list of (term, block) in criteria order.
+        """
+        pdf_data: Dict[str, List[Tuple[str, Dict[str, Any]]]] = {}
+        for term in self._criteria_order:
+            for block in self._search_results.get(term, []):
+                fp = block["pdf_path"]
+                pdf_data.setdefault(fp, []).append((term, block))
+        sorted_pdfs = sorted(pdf_data.keys(), key=lambda p: os.path.basename(p).lower())
+        return sorted_pdfs, pdf_data
+
+    def _fill_tree(self) -> None:
+        for i in self.tree.get_children():
+            self.tree.delete(i)
+        self._tree_row_meta.clear()
+        if not self._search_results or not any(self._search_results.get(t) for t in self._criteria_order):
+            return
+        grouped = self.group_var.get()
+        sorted_pdfs, pdf_data = self._build_pdf_to_term_blocks()
+        for fp in sorted_pdfs:
+            tdoc, tauth = self._get_pdf_display_titles(fp)
+            base = os.path.basename(fp)
+            sep_label = f"━━━━ {base} ━━━━"
+            sep_iid = self.tree.insert(
+                "",
+                tk.END,
+                values=(sep_label, "", "", "", "", ""),
+                tags=("pdf_sep",),
+            )
+            self._tree_row_meta[sep_iid] = {"separator": True, "basename": base}
+            for term, block in pdf_data[fp]:
+                occs = block.get("occurrences", [])
+                if not occs:
+                    continue
+                if grouped:
+                    apx = "yes" if any(o.get("approximate") for o in occs) else "no"
+                    pages = ", ".join(str(o["page"]) for o in occs)
+                    iid = self.tree.insert(
+                        "",
+                        tk.END,
+                        values=(term, tdoc, tauth, base, pages, apx),
+                        tags=(self._tree_tag_for_term(term),),
+                    )
+                    self._tree_row_meta[iid] = {
+                        "term": term,
+                        "pdf_path": fp,
+                        "grouped": True,
+                        "items": [
+                            {
+                                "page": o["page"],
+                                "excerpt": o.get("excerpt", ""),
+                                "approximate": o.get("approximate", False),
+                            }
+                            for o in occs
+                        ],
+                    }
+                else:
+                    for occ in occs:
+                        apx = "yes" if occ.get("approximate") else "no"
+                        iid = self.tree.insert(
+                            "",
+                            tk.END,
+                            values=(term, tdoc, tauth, base, str(occ["page"]), apx),
+                            tags=(self._tree_tag_for_term(term),),
+                        )
+                        self._tree_row_meta[iid] = {
+                            "term": term,
+                            "pdf_path": fp,
+                            "grouped": False,
+                            "excerpt": occ.get("excerpt", ""),
+                            "page": occ["page"],
+                            "approximate": occ.get("approximate", False),
+                        }
+
+    def _on_tree_select(self, _e=None) -> None:
+        sel = self.tree.selection()
+        if not sel:
+            return
+        meta = self._tree_row_meta.get(sel[0])
+        if not meta:
+            return
+        if meta.get("separator"):
+            self.preview.config(state=tk.NORMAL)
+            self.preview.delete("1.0", tk.END)
+            self.preview.insert(
+                tk.END,
+                f"[PDF section: {meta.get('basename', '')}] — select a row below for excerpts.",
+            )
+            self.preview.config(state=tk.DISABLED)
+            return
+        term = meta["term"]
+        if meta.get("grouped") and "items" in meta:
+            self._set_preview_hl_list(term, meta["items"])
+        else:
+            self._set_preview_hl(
+                term,
+                meta.get("excerpt", ""),
+            )
+
+    def _best_highlight_phrase(self, group_key: str, excerpt: str) -> str:
+        """Pick a contiguous substring in `excerpt` to highlight (mirror of literal match UX)."""
+        return best_highlight_phrase_for_group(group_key, excerpt)
+
+    def _insert_excerpt_hl(self, group_key: str, excerpt: str) -> None:
+        if not excerpt:
+            self.preview.insert(tk.END, "(no excerpt)")
+            return
+        n = self._best_highlight_phrase(group_key, excerpt)
+        if not n:
+            self.preview.insert(tk.END, excerpt)
+            return
+        low_ex = excerpt.lower()
+        idx = low_ex.find(n.lower()) if n else -1
+        if idx < 0:
+            self.preview.insert(tk.END, excerpt)
+            return
+        self.preview.insert(tk.END, excerpt[:idx])
+        self.preview.insert(tk.END, excerpt[idx : idx + len(n)], "m")
+        self.preview.insert(tk.END, excerpt[idx + len(n) :])
+
+    def _set_preview_hl(self, group_key: str, excerpt: str) -> None:
+        self.preview.config(state=tk.NORMAL)
+        self.preview.delete("1.0", tk.END)
+        self._insert_excerpt_hl(group_key, excerpt)
+        self.preview.config(state=tk.DISABLED)
+
+    def _set_preview_hl_list(self, group_key: str, items: List[Dict[str, Any]]) -> None:
+        self.preview.config(state=tk.NORMAL)
+        self.preview.delete("1.0", tk.END)
+        for i, it in enumerate(items):
+            if i:
+                self.preview.insert(tk.END, "\n\n")
+            p = it.get("page", "")
+            apx = " (approx.)" if it.get("approximate") else ""
+            self.preview.insert(tk.END, f"p. {p}{apx}\n")
+            self._insert_excerpt_hl(group_key, it.get("excerpt", ""))
+        self.preview.config(state=tk.DISABLED)
+
+    def _export(self) -> None:
+        if not self._search_results or not any(self._search_results.values()):
+            messagebox.showinfo("Export", "Run a search with at least one match first.")
+            return
+        try:
+            import docx  # noqa: F401
+        except ImportError:
+            messagebox.showerror("Missing package", "Install python-docx: pip install python-docx")
+            return
+        path = filedialog.asksaveasfilename(
+            defaultextension=".docx",
+            filetypes=[("Word", "*.docx"), ("All", "*.*")],
+        )
+        if not path:
+            return
+        try:
+            export_docx(
+                path,
+                self.folder_var.get().strip(),
+                self._search_results,
+                self._criteria_order,
+            )
+            messagebox.showinfo("Export", f"Saved:\n{path}")
+        except Exception as ex:  # noqa: BLE001
+            messagebox.showerror("Export failed", str(ex))
+
+
+def main() -> int:
+    # pypdf can trigger cryptography’s ARC4 import warning (third-party, harmless for read-only PDFs)
+    import warnings
+
+    try:
+        from cryptography.utils import CryptographyDeprecationWarning
+
+        warnings.filterwarnings("ignore", category=CryptographyDeprecationWarning)
+    except ImportError:
+        warnings.filterwarnings("ignore", message=".*ARC4.*")
+    try:
+        import pypdf  # noqa: F401
+    except ImportError:
+        print("Install pypdf: pip install pypdf", file=sys.stderr)
+        return 1
+    app = CriteriaSearchApp()
+    app.mainloop()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

requirements.txt

@@ -1,52 +1,53 @@
-gradio==3.40.0
-langchain-community==0.0.19
-langchain_core==0.1.22
-langchain-openai==0.0.5
-faiss-cpu==1.7.3
-huggingface-hub==0.24.7
-google-generativeai==0.3.2
-opencv-python==4.9.0.80
-pdf2image==1.17.0
-pdfminer-six==20221105
-pikepdf==8.12.0
-pypdf==4.0.1
-rank-bm25==0.2.2
-replicate==0.23.1
-tiktoken==0.5.2
-unstructured==0.12.3
-unstructured-pytesseract==0.3.12
-unstructured-inference==0.7.23
-
-# generated
-
-# Transformers for the DeepSeek model and cross-encoder reranker
-transformers>=4.34.0
-
-# PyTorch required by DeepSeek and many Hugging Face models
-torch>=2.0.0
-
-# LangChain (the main package) – adjust the version if needed
-langchain>=0.0.200
-
-# LangChain Community components (for document loaders, vector stores, retrievers, etc.)
-langchain-community
-
-# LangChain Core components (for runnables, etc.)
-langchain-core
-
-
-# FAISS for vector storage and similarity search (CPU version)
-faiss-cpu
-
-# PDF parsing (e.g., used by OnlinePDFLoader)
-pdfminer.six
-
-# Pin Pydantic to version 2 for mistralai compatibility
-pydantic>=2.9.0,<3.0.0
-
-sentence-transformers>=2.4.0
-
-mistralai==1.5.0
-google-generativeai
-anthropic
+gradio==3.40.0
+langchain-community==0.0.19
+langchain_core==0.1.22
+langchain-openai==0.0.5
+faiss-cpu==1.7.3
+huggingface-hub==0.24.7
+google-generativeai==0.3.2
+opencv-python==4.9.0.80
+pdf2image==1.17.0
+pdfminer-six==20221105
+pikepdf==8.12.0
+pypdf==4.0.1
+python-docx>=1.1.0
+rank-bm25==0.2.2
+replicate==0.23.1
+tiktoken==0.5.2
+unstructured==0.12.3
+unstructured-pytesseract==0.3.12
+unstructured-inference==0.7.23
+
+# generated
+
+# Transformers for the DeepSeek model and cross-encoder reranker
+transformers>=4.34.0
+
+# PyTorch required by DeepSeek and many Hugging Face models
+torch>=2.0.0
+
+# LangChain (the main package) – adjust the version if needed
+langchain>=0.0.200
+
+# LangChain Community components (for document loaders, vector stores, retrievers, etc.)
+langchain-community
+
+# LangChain Core components (for runnables, etc.)
+langchain-core
+
+
+# FAISS for vector storage and similarity search (CPU version)
+faiss-cpu
+
+# PDF parsing (e.g., used by OnlinePDFLoader)
+pdfminer.six
+
+# Pin Pydantic to version 2 for mistralai compatibility
+pydantic>=2.9.0,<3.0.0
+
+sentence-transformers>=2.4.0
+
+mistralai==1.5.0
+google-generativeai
+anthropic
 requests

search_keywords.py

@@ -0,0 +1,129 @@
+"""
+Phrase lists and category metadata for PDF criteria search (FilterLM / pdf_criteria_search_gui_v2).
+
+Each *group key* maps to one or more literal phrases searched in normalized PDF text.
+Keys and ordering align with ``criteria_search_terms.csv`` when present.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List
+
+# Ordered keys (must match criteria_search_terms.csv “term” column).
+_ORDERED_KEYS: List[str] = [
+    "quality",
+    "helpfulness",
+    "harmlessness",
+    "safety",
+    "groundedness",
+    "honesty",
+    "truthfulness",
+    "hallucinations",
+    "empathy",
+    "politeness",
+    "relevance",
+    "verbosity",
+    "component",
+    "aggregation",
+    "ranking",
+    "weighting",
+    "tradeoffs",
+    "other",
+    "nonspecific",
+    "grice",
+    "specific",
+    "otherframework",
+    "conversations",
+    "humanai",
+    "annotation",
+    "separate",
+    "naturalistic",
+    "hybrid",
+    "synthetic",
+    "datasetname",
+    "datasetsource",
+    "dialogs",
+    "annotators",
+    "context",
+    "annotator",
+    "single",
+    "multi",
+    "prerecorded",
+    "realtime",
+    "scales",
+    "binary",
+    "validated",
+    "notes",
+    "named",
+    "unspecified",
+    "family",
+    "rlhf",
+    "partial",
+    "collected",
+    "reward",
+    "policy",
+    "stage",
+    "benchmark",
+    "judge",
+    "comparators",
+    "winrate",
+    "strategy",
+    "gains",
+    "losses",
+    "inconsistent",
+    "unchanged",
+    "quantified",
+]
+
+
+def _default_phrases(key: str) -> List[str]:
+    """Human-readable phrase plus the raw token; extend SEARCH_KEYWORDS below as needed."""
+    human = key.replace("_", " ")
+    seen: set[str] = set()
+    out: List[str] = []
+    for p in (human, key):
+        low = p.lower()
+        if low not in seen:
+            seen.add(low)
+            out.append(p)
+    return out
+
+
+SEARCH_KEYWORDS: Dict[str, List[str]] = {k: _default_phrases(k) for k in _ORDERED_KEYS}
+
+# Category slices over _ORDERED_KEYS indices [start, end).
+_SLICES = (
+    ("dimensions", 0, 12),
+    ("modeling", 12, 20),
+    ("linguistics", 20, 24),
+    ("corpus", 24, 32),
+    ("dataset_meta", 32, 49),
+    ("training_eval", 49, len(_ORDERED_KEYS)),
+)
+
+KEY_TO_CATEGORY: Dict[str, str] = {}
+for cat_id, a, b in _SLICES:
+    for key in _ORDERED_KEYS[a:b]:
+        KEY_TO_CATEGORY[key] = cat_id
+
+CATEGORY_HEADINGS: Dict[str, str] = {
+    "dimensions": "Evaluation dimensions",
+    "modeling": "Aggregation / modeling",
+    "linguistics": "Discourse & frameworks",
+    "corpus": "Study / corpus types",
+    "dataset_meta": "Dataset & annotation",
+    "training_eval": "Training & metrics",
+}
+
+CATEGORY_STYLES: Dict[str, tuple[str, str]] = {
+    "dimensions": ("#E8F5E9", "#1B5E20"),
+    "modeling": ("#E3F2FD", "#0D47A1"),
+    "linguistics": ("#FFF3E0", "#E65100"),
+    "corpus": ("#F3E5F5", "#6A1B9A"),
+    "dataset_meta": ("#ECEFF1", "#37474F"),
+    "training_eval": ("#FFEBEE", "#B71C1C"),
+}
+
+
+def ordered_group_keys() -> List[str]:
+    return list(_ORDERED_KEYS)