Update app.py

app.py

@@ -1,174 +1,168 @@
 import gradio as gr
 import pandas as pd
-import requests
 from pathlib import Path
 from zipfile import ZipFile
+import io
+import contextlib
 
-# ------------------
-# Data prep
-# ------------------
-def download_file(url: str, output_path: Path):
-    if output_path.exists():
-        print(f"Skipping {output_path.name}, already exists.")
-        return
-    print(f"Downloading {url}")
-    response = requests.get(url)
-    response.raise_for_status()
-    output_path.write_bytes(response.content)
-    print(f"Saved to {output_path}")
-
-
-# Download files
-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"))
-
-# Assume `names.zip` is already in the repo
-if not Path("names").exists():
-    print("Unzipping local names.zip...")
-    with ZipFile("names.zip", 'r') as zip_ref:
-        zip_ref.extractall("names")
-else:
-    print("SSA name files already extracted.")
-
-# Define where to find SSA name files
-ssa_name_txt_files = list(Path("names").glob("yob*.txt"))
-
-# ------------------
-# Load Data
-# ------------------
+# --- 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()
+
+# --- Load datasets ---
+ssa_name_txt_files = sorted(Path(".").glob("yob*.txt"))
 
 def load_ssa_names():
-    ssa_dfs = []
-    for names_file in ssa_name_txt_files:
-        yob = int(names_file.name.split(".")[0].replace("yob", ""))
-        df = pd.read_csv(names_file, names=["name", "sex", "count"])
-        df["year"] = yob
-        ssa_dfs.append(df)
-    ssa_names_df = pd.concat(ssa_dfs)
-    ssa_names_aggregated_df = (
-        ssa_names_df
+    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(by="count", ascending=False)
+        .sort_values("count", ascending=False)
     )
-    return ssa_names_df, ssa_names_aggregated_df
-
-def load_bible_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"
-    )
-    return bible_names_personlabel_df
+    return full_df, agg_df
 
-# Load data on startup
 ssa_names_df, ssa_names_aggregated_df = load_ssa_names()
-bible_names_df = load_bible_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")
 
+# --- Name generation logic ---
+import random
 
-# -----------------------
-# filtering and picking 
-# -----------------------
+last_names = ["Smith", "Johnson", "Williams", "Taylor", "Brown"]
 
 def get_normal_and_bible(
-    ssa_names_df,
+    ssa_names_aggregated_df,
     bible_names_df,
-    min_length_ssa=1,
-    max_length_ssa=None,
-    min_length_bible=1,
-    max_length_bible=None,
-    ssa_popularity_percentile=None,
+    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,
+    debug=False,
 ):
-    filtered_ssa_df = ssa_names_df
-
-    if ssa_popularity_percentile is not None:
-        low, high = ssa_popularity_percentile
-        name_counts = (
-            ssa_names_df.groupby("name", as_index=False)["count"]
-            .sum()
-            .sort_values(by="count", ascending=True)
-        )
-        total = len(name_counts)
-        selected_names = name_counts.iloc[int(low * total):int(high * total)]["name"]
-        filtered_ssa_df = ssa_names_df[ssa_names_df["name"].isin(selected_names)]
+    if forbidden_names is None:
+        forbidden_names = set()
 
+    filtered_ssa = ssa_names_aggregated_df.copy()
+    filtered_ssa = filtered_ssa[
+        filtered_ssa["name"].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)["name"].values[0]
+
+    filtered_bible = bible_names_df.copy()
+    filtered_bible = filtered_bible[
+        filtered_bible["name"].str.len().between(min_length_bible, max_length_bible)
+    ]
     if sex:
-        filtered_ssa_df = filtered_ssa_df[filtered_ssa_df["sex"] == sex]
-        bible_names_df = bible_names_df[bible_names_df["sex"] == sex]
-
-    if forbidden_names:
-        filtered_ssa_df = filtered_ssa_df[~filtered_ssa_df["name"].isin(forbidden_names)]
-        bible_names_df = bible_names_df[~bible_names_df["english_label"].isin(forbidden_names)]
-
-    ssa_mask = filtered_ssa_df["name"].str.len() >= min_length_ssa
-    if max_length_ssa is not None:
-        ssa_mask &= filtered_ssa_df["name"].str.len() <= max_length_ssa
-    normal_names = filtered_ssa_df[ssa_mask]["name"].unique().tolist()
-
-    bible_mask = bible_names_df["english_label"].str.len() >= min_length_bible
-    if max_length_bible is not None:
-        bible_mask &= bible_names_df["english_label"].str.len() <= max_length_bible
-    bible_names = bible_names_df[bible_mask]["english_label"].unique().tolist()
-
-    if not normal_names or not bible_names:
-        raise ValueError("No names found with given constraints")
-
-    return random.choice(normal_names), random.choice(bible_names)
-
-def generate_names(n, sex, min_len, max_len, min_bible_len, max_bible_len, pop_low, pop_high, last="Smith"):
-    names = []
-    for _ in range(n):
-        try:
-            normal, bible = get_normal_and_bible(
-                ssa_names_aggregated_df,
-                bible_names_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
-            )
-            names.append(f"{bible} {normal} {last}")
-        except Exception as e:
-            names.append(f"[Error: {e}]")
-    return "\n".join(names)
-
-# ------------------
-# Gradio Interface
-# ------------------
+        filtered_bible = filtered_bible[filtered_bible["sex"] == sex]
+    filtered_bible = filtered_bible[~filtered_bible["name"].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)["name"].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):
+    results = []
+    debug_output = io.StringIO()
+    with contextlib.redirect_stdout(debug_output):
+        for _ in range(n):
+            try:
+                normal, bible = get_normal_and_bible(
+                    ssa_names_aggregated_df,
+                    bible_names_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,
+                    debug=debug_flag,
+                )
+                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("## 📜 Bible + SSA Name Generator")
+    gr.Markdown("# 📜 Random Bible + SSA Name Generator")
 
     with gr.Row():
-        n_slider = gr.Slider(1, 100, value=10, label="Number of names")
+        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():
-        pop_low_slider = gr.Slider(0.0, 1.0, value=0.0, step=0.01, label="Popularity Percentile Min (SSA)")
-        pop_high_slider = gr.Slider(0.0, 1.0, value=1.0, step=0.01, label="Popularity Percentile Max (SSA)")
-
+        ssa_len = gr.Slider(3, 12, value=3, step=1, label="SSA name min length")
+        ssa_max_len = gr.Slider(3, 12, value=8, step=1, label="SSA name max length")
 
     with gr.Row():
-        ssa_len = gr.Slider(1, 15, value=1, label="SSA Name Length (min)")
-        ssa_max_len = gr.Slider(1, 15, value=10, label="SSA Name Length (max)")
+        bible_len = gr.Slider(3, 12, value=3, step=1, label="Bible name min length")
+        bible_max_len = gr.Slider(3, 12, value=8, step=1, label="Bible name max length")
 
     with gr.Row():
-        bible_len = gr.Slider(1, 15, value=4, label="Bible Name Length (min)")
-        bible_max_len = gr.Slider(1, 15, value=10, label="Bible Name Length (max)")
+        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")
+
+    debug_checkbox = gr.Checkbox(label="Show debug output", value=True)
+
+    generate_btn = gr.Button("🔀 Generate Names")
 
-    generate_btn = gr.Button("Generate Names")
-    output_box = gr.Textbox(label="Generated Names", lines=15)
+    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],
-        outputs=output_box
+        inputs=[
+            n_slider,
+            sex_choice,
+            ssa_len,
+            ssa_max_len,
+            bible_len,
+            bible_max_len,
+            pop_low_slider,
+            pop_high_slider,
+            debug_checkbox
+        ],
+        outputs=[output_box, debug_box],
     )
 
 demo.launch()