app.py

import gradio as gr
import pandas as pd
from pathlib import Path
from zipfile import ZipFile
import io
import contextlib
import requests

FORBIDDEN_NAMES =["Judas",
                  "Maher-shalal-hash-baz",
                  "Bathsheba",
                  "Jephthah",
                  "Jehoshaphat",
                  "Tiebreaker",
                  "Boanerges",
                  "Jezebel",
                  "Gomorrah",
                  "Hymenaeus",
                  "Herod",
                  "Pilate",
                  "Doeg",
                  "Ziph",
                  "Phygelus",
                  "Hermogenes",
                  "Philetus",
                  "Balaam",
                  "Achan",
                  "Caiaphas",
                  "Pontius",
                  "Ahab",
                  "Manasseh",
                  "Rehoboam",
                  "Nebuchadnezzar",
                  "Delilah",
                  "Lo-ammi",
                  "Lo-ruhamah",
                  "Beelzebub",
                  "Ichabod",
                  "Saphira",
                  "Jushab-hesed",
                  "Benjarman",
                  "Cain",
                  "Esau",
                  "Machiavelli", # found
                  "Barabbas",
                  "Sapphira",
                  "Shur",
                 ]
def download_file(url: str, dest_path: Path):
    if dest_path.exists():
        print(f"{dest_path.name} already exists. Skipping download.")
        return
    print(f"Downloading {url}")
    response = requests.get(url)
    response.raise_for_status()
    with open(dest_path, "wb") as f:
        f.write(response.content)
    print(f"Saved to {dest_path}")


# --- File download & setup ---
def extract_names_zip():
    zip_path = Path("names.zip")
    if not zip_path.exists():
        raise FileNotFoundError("names.zip not found. Please upload it manually to the repo.")
    with ZipFile(zip_path, 'r') as zip_ref:
        zip_ref.extractall(".")
        print("Unzipped names.zip")

extract_names_zip()


# Download Bible CSVs if missing
download_file(
    "https://raw.githubusercontent.com/BradyStephenson/bible-data/refs/heads/main/BibleData-Person.csv",
    Path("BibleData-Person.csv"),
)
download_file(
    "https://raw.githubusercontent.com/BradyStephenson/bible-data/refs/heads/main/BibleData-PersonLabel.csv",
    Path("BibleData-PersonLabel.csv"),
)


# --- Load datasets ---
ssa_name_txt_files = sorted(Path(".").glob("yob*.txt"))

def load_ssa_names():
    dfs = []
    for f in ssa_name_txt_files:
        year = int(f.stem.replace("yob", ""))
        df = pd.read_csv(f, names=["name", "sex", "count"])
        df["year"] = year
        dfs.append(df)
    full_df = pd.concat(dfs, ignore_index=True)
    agg_df = (
        full_df
        .groupby(["name", "sex"], as_index=False)["count"]
        .sum()
        .sort_values("count", ascending=False)
    )
    return full_df, agg_df

ssa_names_df, ssa_names_aggregated_df = load_ssa_names()
bible_names_df = pd.read_csv("BibleData-Person.csv")
bible_names_personlabel_df = pd.read_csv("BibleData-PersonLabel.csv")
bible_names_personlabel_df = bible_names_personlabel_df.merge(bible_names_df[["person_id", "sex"]], on="person_id", how="left")
bible_names_personlabel_df = bible_names_personlabel_df[bible_names_personlabel_df["label_type"] == "proper name"]
bible_names_personlabel_df["sex"] = bible_names_personlabel_df["sex"].replace({"male": "M", "female": "F"})

# --- Name generation logic ---
import random

last_names = ["Smith", "Johnson", "Williams", "Taylor", "Brown"]

def get_normal_and_bible(
    ssa_names_aggregated_df,
    bible_names_df,
    min_length_ssa=3,
    max_length_ssa=8,
    min_length_bible=3,
    max_length_bible=8,
    ssa_popularity_percentile=(0.95, 1.0),
    sex=None,
    forbidden_names=None,
    ssa_names_col="name",
    bible_names_col="english_label",
    debug=False,
    
):
    if forbidden_names is None:
        forbidden_names = set()

    filtered_ssa = ssa_names_aggregated_df.copy()
    filtered_ssa = filtered_ssa[
        filtered_ssa[ssa_names_col].str.len().between(min_length_ssa, max_length_ssa)
    ]
    if sex:
        filtered_ssa = filtered_ssa[filtered_ssa["sex"] == sex]
    if debug:
        print(f"SSA names after length/sex filter: {len(filtered_ssa)}")

    total = len(filtered_ssa)
    filtered_ssa = filtered_ssa.sort_values("count")
    low, high = ssa_popularity_percentile
    idx_start = int(total * low)
    idx_end = int(total * high)
    filtered_ssa = filtered_ssa.iloc[idx_start:idx_end]
    if debug:
        print(f"SSA names after popularity percentile slice: {len(filtered_ssa)}")

    ssa_name = filtered_ssa.sample(1)[ssa_names_col].values[0]

    filtered_bible = bible_names_df.copy()
    filtered_bible = filtered_bible[
        filtered_bible[bible_names_col].str.len().between(min_length_bible, max_length_bible)
    ]
    if sex:
        filtered_bible = filtered_bible[filtered_bible["sex"] == sex]
    filtered_bible = filtered_bible[~filtered_bible[bible_names_col].isin(forbidden_names)]
    if debug:
        print(f"Bible names after filtering: {len(filtered_bible)}")

    if len(filtered_bible) == 0 or len(filtered_ssa) == 0:
        raise ValueError("No valid names found after filtering.")

    bible_name = filtered_bible.sample(1)[bible_names_col].values[0]

    return ssa_name, bible_name

# --- Gradio app ---
def generate_names(n, sex, min_len, max_len, min_bible_len, max_bible_len, pop_low, pop_high, debug_flag, last, forbidden_names_text):
    results = []
    debug_output = io.StringIO()
    forbidden_names = set(name.strip() for name in forbidden_names_text.split(",") if name.strip())
    with contextlib.redirect_stdout(debug_output):
        for i in range(n):
            try:
                normal, bible = get_normal_and_bible(
                    ssa_names_aggregated_df,
                    bible_names_personlabel_df,
                    min_length_ssa=min_len,
                    max_length_ssa=max_len,
                    min_length_bible=min_bible_len,
                    max_length_bible=max_bible_len,
                    ssa_popularity_percentile=(pop_low, pop_high),
                    sex=sex if sex in {"M", "F"} else None,
                    forbidden_names=forbidden_names,
                    debug=(i==0),
                )
                if last is None: 
                    last = random.choice(last_names)
                results.append(f"{bible} {normal} {last}")
            except Exception as e:
                results.append(f"[Error: {e}]")

    return "\n".join(results), debug_output.getvalue()


with gr.Blocks() as demo:
    gr.Markdown("# 📜 Random Bible + SSA Name Generator")

    with gr.Row():
        n_slider = gr.Slider(1, 20, value=5, step=1, label="How many names?")
        sex_choice = gr.Radio(["M", "F", "Any"], label="Sex", value="Any")

    with gr.Row():
        ssa_len = gr.Slider(3, 40, value=3, step=1, label="SSA name min length")
        ssa_max_len = gr.Slider(3, 40, value=8, step=1, label="SSA name max length")

    with gr.Row():
        bible_len = gr.Slider(3, 40, value=3, step=1, label="Bible name min length")
        bible_max_len = gr.Slider(3, 40, value=8, step=1, label="Bible name max length")

    with gr.Row():
        pop_low_slider = gr.Slider(0.0, 1.0, value=0.95, step=0.01, label="SSA Popularity: Low Percentile")
        pop_high_slider = gr.Slider(0.0, 1.0, value=1.0, step=0.01, label="SSA Popularity: High Percentile")
    with gr.Row():
        last_name_input = gr.Textbox(label="Last Name")

    with gr.Row():
        forbidden_names_input = gr.Textbox(label="FORBIDDEN NAMES (comma-separated)", value=FORBIDDEN_NAMES)
        


    debug_checkbox = gr.Checkbox(label="Show debug output", value=True)

    generate_btn = gr.Button("🔀 Generate Names")

    output_box = gr.Textbox(label="Generated Names", lines=10)
    debug_box = gr.Textbox(label="Debug Output", lines=10)

    generate_btn.click(
        fn=generate_names,
        inputs=[
            n_slider,
            sex_choice,
            ssa_len,
            ssa_max_len,
            bible_len,
            bible_max_len,
            pop_low_slider,
            pop_high_slider,
            debug_checkbox,
            last_name_input,
            forbidden_names_input,
        ],
        outputs=[output_box, debug_box],
    )

demo.launch()