pip install requests streamlit python-dotenv

import os
import json

INSTRUCTION_FILE = "spider2-snow.jsonl"
instruction_map = {}

with open(INSTRUCTION_FILE, 'r', encoding="utf-8") as f:
		for line in f:
			  entry = json.loads(line)
				instruction_id = entry.get("instance_id")
				instruction = entry.get("instruction")
				database = entry.get("db_id")
				if instruction_id and instruction:
				instruction_map[instruction_id] = (instruction, database)

from sqlglot import transpile
import sqlglot.errors
from sqlglot import exp
from sqlglot.helper import logger as helper_logger

def custom_transformer(node):
    if isinstance(node, exp.ToNumber):
        return exp.Cast(this=node.this, to=exp.DataType(this=exp.DataType.Type.DECIMAL))
    if isinstance(node, exp.RegexpExtract):
        return exp.RegexpExtract(
            this=node.this,
            expression=node.expression,
            position=None,
            occurrence=None,
            parameters=None
        )
    return node

output_data = []
SQL_DIR = "sql"
for filename in os.listdir(SQL_DIR):
if not filename.endswith(".sql"):
	continue

instance_id = os.path.splitext(filename)[0]
if instance_id not in instruction_map:
    continue

sql_path = os.path.join(SQL_DIR, filename)
try:
    with open(sql_path, "r", encoding="utf-8") as sql_file:
        original_sql = sql_file.read().strip()
except Exception:
    continue
    
try:
    transpiled_sql_list = transpile(
        sql=original_sql,
        read="snowflake",
        write="trino",
        identity=True,
        error_level=sqlglot.errors.ErrorLevel.WARN,
        transforms=[custom_transformer]
    )
    transpiled_sql = transpiled_sql_list[0] if transpiled_sql_list else original_sql
except Exception:
    transpiled_sql = original_sql

instruction, database = instruction_map[instance_id]

output_data.append({
    "sql_query": transpiled_sql,
    "instruction": instruction,
    "database": database,
    "result-file": instance_id
})

OUTPUT_FILE = "output.json"
with open(OUTPUT_FILE, "w", encoding="utf-8") as out_file:
json.dump(output_data, out_file, indent=2, ensure_ascii=False)

import os
import json
import requests
import time
from dotenv import load_dotenv
import os

load_dotenv()

API_TOKEN = os.getenv("PEAKA_API_KEY")
GET_URL= "[https://partner.peaka.studio/api/v1/info](https://partner.peaka.studio/api/v1/info)"
POST_URL = "[https://partner.peaka.studio/api/v1/ai-agent/{project_id}/chat](https://partner.peaka.studio/api/v1/ai-agent/%7Bproject_id%7D/chat)"
INPUT_FILE= "output.json"
OUTPUT_FILE= "results.json"

headers = {
"Authorization": f"Bearer {API_TOKEN}",
"Content-Type": "application/json"
}

with open(INPUT_FILE, 'r') as f:
data = json.load(f)

response= requests.get(GET_URL, headers=headers)
project_info= response.json()
project_id = project_info.get("projectId")

results = []
target_databases = {"AIRLINES"}
if database not in target_databases:
    continue

body = {"message": question}

start_time = time.time()
response = requests.post(
	POST_URL.format(project_id=project_id),
	headers=headers,
	json=body
)
end_time = time.time()
elapsed_time = round(end_time - start_time)

reply = response.json()
content_raw = reply["result"]["messages"][1]["kwargs"]["content"]
results.append({
	"database": item.get("database"),
	"question": question,
	"result": content_raw,
	"response_time": elapsed_time})

with open("results.json", "w", encoding="utf-8") as f:
json.dump(results, f, indent=2, ensure_ascii=False)

streamlit run streamlit.py