task_units/task_131/workspace/main.py

"""
The Query Answering Pipeline
"""

import os
import re
import json
import glob
import pickle

from tqdm import tqdm
from loguru import logger

from query.primitive_pipeline import *
from table2tree.extract_excel import *
from table2tree.feature_tree import *
from utils.constants import DELIMITER


def answer_question(
    qa_pair: dict,                          # A single QA pair
    table_file: str,                        # Original table file path
    pkl_dir: str,                           # Path for storing HO-Tree intermediate results
    enable_query_decompose: bool = True,    # Whether to enable query decomposition
    enable_emebdding: bool = True,          # Whether to enable the embedding mechanism
    log_dir: str = LOG_DIR                  # Log directory
):
    
    qid = qa_pair["id"]
    tid = qa_pair['table_id']
    query = qa_pair["query"]

    ##### Create a log file named table_id_question_id.log
    log_file = os.path.join(log_dir, f'{tid}_{qid}.log')
    log_file_handler = logger.add(log_file)

    logger.info(f"{DELIMITER} Start answering the question {DELIMITER}")

    start_time = time.time()

    logger.info(f"Question ID: {qid}")
    logger.info(f"Table ID: {tid}")
    logger.info(f"Question: {query}")

    ##### Load the HO-Tree
    pkl_file = os.path.join(pkl_dir, f'{tid}.pkl')
    embedding_cache_file = os.path.join(pkl_dir, f'{tid}_embedding.json')
    with open(pkl_file, 'rb') as file:
        ho_tree = pickle.load(file)

    logger.info(f"Loading PKL File: {pkl_file}")
    logger.info(f"Loading Embedding Cache File: {embedding_cache_file}")

    final_answer, _, reliability = qa_RWP(
        query=query,
        ho_tree=ho_tree,
        table_file=table_file,
        embedding_cache_file=embedding_cache_file,
        enable_emebdding=enable_emebdding,
        enable_query_decompose=enable_query_decompose,
    )
    qa_pair["reliability"] = reliability
    qa_pair["model_output"] = final_answer

    end_time = time.time()

    logger.info(f"{DELIMITER} Question answered successfully! {DELIMITER}")
    logger.info(f"Cost time: {end_time - start_time}")
    
    logger.remove(log_file_handler)
    
    return qa_pair

def benchmark(
    table_dir: str,                     # Directory containing table files, where each filename is the unique table identifier
    input_jsonl: str,                   # JSONL file that stores input QA pairs; each record requires id, table_id, query, and label
    output_jsonl: str,                  # File for saving QA pair model inference results
    pkl_dir: str,                       # Path for saving converted HO-Tree intermediates and the embedding cache
    enable_emebdding: bool = True,      # Whether to enable the embedding mechanism, corresponding to two-stage forward verification
    cache_dir: str = CACHE_DIR,         # Cache storage path
    log_dir: str = LOG_DIR,             # Log storage path
    process_from_scratch: bool = False, # Whether to rerun HO-Tree generation and preprocessing
    qa_from_scratch: bool = False,      # Whether to rerun QA from scratch
):

    if not os.path.exists(pkl_dir): os.makedirs(pkl_dir)
    if not os.path.exists(cache_dir): os.makedirs(cache_dir)
    if not os.path.exists(log_dir): os.makedirs(log_dir)

    ##### Load QA pairs to be processed
    input_list = []
    with open(input_jsonl, "r", encoding="utf-8") as file:
        for line in file:
            input_list.append(json.loads(line))
    input_list.sort(key=lambda x: x["table_id"])    # Sort by table_id

    ##### Load the full list of table files
    table_files = sorted(glob.glob(table_dir + "/*"))

    # Process different input formats by converting them all to Excel format
    new_table_files = []
    for table_file in table_files:
        last_dot_idx = os.path.basename(table_file).rfind('.')
        new_table_file = os.path.join(table_dir, os.path.basename(table_file)[:last_dot_idx] + '.xlsx')

        if table_file.endswith(".xlsx"):
            pass
        elif table_file.endswith(".csv"):
            df = pd.read_csv(new_table_file)
            df.to_excel(new_table_file, index=False, engine='openpyxl')
        elif table_file.endswith(".html"):
            html_content = open(table_file).read()
            html2workbook(html_content).save(new_table_file)
        elif table_file.endswith(".md"):
            markdown_content = open(table_file).read()
            table = extract_markdown_tables(markdown_content)
            with pd.ExcelWriter(new_table_file, engine='openpyxl') as writer:
                sheet_name = f'sheet'
                df = pd.DataFrame(table[1:], columns=table[0])
                df.to_excel(writer, sheet_name=sheet_name, index=False)
        
        new_table_files.append(new_table_file)
    table_files = new_table_files

    ##### Load already processed QA pairs
    output_data = []
    qid_set = set()
    if not qa_from_scratch and os.path.exists(output_jsonl):
        with open(output_jsonl, 'r', encoding='utf-8') as file:
            for line in file:
                output_data.append(json.loads(line))
        qid_set = set([r['id'] for r in output_data])

    ##### Try to load HO-Tree intermediate files
    pkl_files = []
    embedding_cache_files = []
    if not process_from_scratch and pkl_dir is not None:
        pkl_files = sorted(glob.glob(pkl_dir + "/*.pkl"))
        embedding_cache_files = sorted(glob.glob(pkl_dir + "/*_embedding.json"))

    ##### Process each table one by one
    for table_file in table_files:
        table_id = os.path.basename(table_file).split('.')[0]

        ##### Table preprocessing: Table -> HO-Tree
        if os.path.join(pkl_dir, f'{table_id}.pkl') not in pkl_files:
            try:
                ho_tree = get_excel_feature_tree(table_file, log_dir=log_dir, vlm_cache=False)
                
                tree_json = ho_tree.__json__()
                tree_str = ho_tree.__str__([1])

                with open(os.path.join(pkl_dir, f"{table_id}.pkl"), "wb") as f:
                    pickle.dump(ho_tree, f)
                with open(os.path.join(pkl_dir, f"{table_id}.txt"), "w", encoding='utf-8') as f:
                    f.write(tree_str)
                with open(os.path.join(pkl_dir, f"{table_id}.json"), "w", encoding='utf-8') as f:
                    json.dump(tree_json, f, indent=4, ensure_ascii=False)
            except Exception as e:
                import traceback; traceback.print_exc()
                logger.error(f"File: {table_file} Error: {e}")
                continue
        else:
            logger.info(f"File: {table_file} has already been converted into an HO-Tree!!!")

        ##### Generate embeddings for table content
        if os.path.join(pkl_dir, f'{table_id}_embedding.json') not in embedding_cache_files:
            embedding_dict = EmbeddingModel().get_embedding_dict(ho_tree.all_value_list())

            with open(os.path.join(pkl_dir, f"{table_id}_embedding.json"), "w", encoding='utf-8') as f:
                json.dump(embedding_dict, f, ensure_ascii=False)

    ##### Process each question one by one
    for qa_pair in input_list:
        table_id = qa_pair['table_id']
        
        ##### Prevent duplicate question answering
        if not qa_from_scratch and qa_pair['id'] in qid_set:
            continue

        ##### Execute question answering #####
        record = answer_question(
            qa_pair=qa_pair,
            table_file=table_file,
            pkl_dir=pkl_dir,
            enable_emebdding=enable_emebdding,
            log_dir=log_dir
        )

        ##### Save QA results
        output_data.append(record)
        qid_set.add(record['id'])
        with open(output_jsonl, "a", encoding="utf-8") as file:
            file.write(f"{json.dumps(record, ensure_ascii=False)}\n")

def main():
    ##### Update these paths as needed
    input_jsonl ="data/SSTQA-en/test.jsonl"
    table_dir = "data/SSTQA-en/table"
    pkl_dir = "data/SSTQA-en/pkl"
    output_jsonl = "SSTQA-en/output.jsonl"
    log_dir = "data/SSTQA-en/log"

    benchmark(
        table_dir=table_dir,
        input_jsonl=input_jsonl,
        output_jsonl=output_jsonl,
        pkl_dir=pkl_dir,
        cache_dir=CACHE_DIR,
        log_dir=log_dir,
    )

if __name__ == "__main__":
    main()
    # run()