Update app.py

app.py

@@ -1,32 +1,20 @@
-import math
-from typing import Dict, List, Optional
-
 import gradio as gr
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
+from typing import Dict, List, Optional
 from periodictable import elements
 
-# -----------------------------
-# Helpers
-# -----------------------------
+# ---------- helpers ----------
 def to_float(x):
-    """Coerce periodictable numeric (incl. uncertainties) to plain float, else NaN."""
     if x is None:
         return np.nan
+    v = getattr(x, "nominal_value", x)  # handles uncertainties.UFloat
     try:
-        # uncertainties.UFloat has .nominal_value
-        v = getattr(x, "nominal_value", x)
         return float(v)
     except Exception:
-        try:
-            return float(x)
-        except Exception:
-            return np.nan
+        return np.nan
 
-# -----------------------------
-# Data
-# -----------------------------
 NUMERIC_PROPS = [
     ("mass", "Atomic mass (u)"),
     ("density", "Density (g/cm^3)"),
@@ -38,42 +26,40 @@ NUMERIC_PROPS = [
 ]
 
 CURATED_FACTS: Dict[str, List[str]] = {
-    "H": ["Lightest element; ~74% of the visible universe by mass is hydrogen in stars."],
-    "He": ["Inert, used in cryogenics and balloons; second lightest element."],
-    "Li": ["Batteries MVP: lithium-ion cells power phones and EVs."],
-    "C": ["Backbone of life; diamond and graphite are pure carbon with wildly different properties."],
-    "N": ["~78% of Earth's atmosphere is nitrogen (mostly N₂)."],
-    "O": ["Essential for respiration; ~21% of Earth's atmosphere."],
-    "Na": ["Sodium metal reacts violently with water—handle only under oil or inert gas."],
-    "Mg": ["Burns with a bright white flame; used in flares and fireworks."],
-    "Al": ["Light and strong; forms a protective oxide layer that resists corrosion."],
-    "Si": ["Silicon is the basis of modern electronics—hello, semiconductors."],
-    "Cl": ["Powerful disinfectant; elemental chlorine is toxic, compounds are widely useful."],
-    "Ar": ["Argon is used to provide inert atmospheres for welding and 3D printing."],
-    "Fe": ["Core of steel; iron is essential in hemoglobin for oxygen transport."],
-    "Cu": ["Excellent electrical conductor; iconic blue-green patina (verdigris)."],
-    "Ag": ["Highest electrical conductivity of all metals; historically used as currency."],
-    "Au": ["Very unreactive ('noble'); prized for electronics and jewelry."],
-    "Hg": ["Only metal that's liquid at room temperature; toxic—use with care."],
-    "Pb": ["Dense and malleable; toxicity led to phase-out from gasoline and paints."],
-    "U": ["Radioactive; used as nuclear reactor fuel (U-235)."],
-    "Pu": ["Man-made in quantity; key in certain nuclear technologies."],
-    "F": ["Most electronegative element; extremely reactive."],
-    "Ne": ["Neon glows striking red-orange in discharge tubes—classic signs."],
-    "Xe": ["Xenon makes bright camera flashes and high-intensity lamps."],
+    "H": ["Lightest element; ~74% of visible matter is H in stars."],
+    "He": ["Inert and super light; cryogenics & balloons."],
+    "Li": ["Lithium-ion batteries power phones & EVs."],
+    "C": ["Diamond vs graphite = same element, different structure."],
+    "N": ["~78% of Earth's atmosphere is N₂."],
+    "O": ["~21% of air; essential for respiration."],
+    "Na": ["Reacts violently with water."],
+    "Mg": ["Bright white flame in flares."],
+    "Si": ["Semiconductor backbone."],
+    "Cl": ["Disinfectant; elemental Cl₂ is toxic."],
+    "Fe": ["Steel core; oxygen transport in blood (heme)."],
+    "Cu": ["Great conductor; forms green patina."],
+    "Ag": ["Highest electrical conductivity."],
+    "Au": ["Very unreactive; great for electronics/jewelry."],
+    "Hg": ["Liquid metal at room temp; toxic."],
+    "Pb": ["Dense, malleable; toxic—phase-out in fuels/paints."],
+    "U": ["Reactor fuel (U-235)."],
+    "Pu": ["Man-made in quantity; nuclear uses."],
+    "F": ["Most electronegative; extremely reactive."],
+    "Ne": ["Classic red-orange neon glow."],
+    "Xe": ["Used in bright flashes/HID lamps."],
 }
 
 GROUP_FACTS = {
-    "alkali": "Alkali metal: very reactive soft metal; forms +1 cations and reacts with water.",
-    "alkaline-earth": "Alkaline earth metal: reactive (less than Group 1); forms +2 cations.",
-    "transition": "Transition metal: often good catalysts, colorful compounds, multiple oxidation states.",
-    "post-transition": "Post-transition metal: softer metals with lower melting points than transition metals.",
-    "metalloid": "Metalloid: properties between metals and nonmetals; often semiconductors.",
-    "nonmetal": "Nonmetal: tends to form covalent compounds; wide range of roles in biology and materials.",
-    "halogen": "Halogen: very reactive nonmetals; form salts with metals and −1 oxidation state.",
-    "noble-gas": "Noble gas: chemically inert under most conditions; monatomic gases.",
-    "lanthanide": "Lanthanide: f-block rare earths; notable for magnets, lasers, and phosphors.",
-    "actinide": "Actinide: radioactive f-block; includes nuclear fuel materials.",
+    "alkali": "Alkali metal: very reactive; forms +1 cations; reacts with water.",
+    "alkaline-earth": "Alkaline earth metal: reactive; forms +2 cations.",
+    "transition": "Transition metal: catalysts, colorful compounds, multiple oxidation states.",
+    "post-transition": "Post-transition metal: softer, lower melting than transition metals.",
+    "metalloid": "Metalloid: between metals and nonmetals; often semiconductors.",
+    "nonmetal": "Nonmetal: forms covalent compounds; huge biological roles.",
+    "halogen": "Halogen: very reactive nonmetals; −1 state; forms salts.",
+    "noble-gas": "Noble gas: inert, monatomic gases.",
+    "lanthanide": "Lanthanide: rare earths; magnets, lasers, phosphors.",
+    "actinide": "Actinide: radioactive; nuclear materials.",
 }
 
 def classify_category(el) -> str:
@@ -82,12 +68,12 @@ def classify_category(el) -> str:
             return "alkali"
         if el.block == "s" and el.group == 2:
             return "alkaline-earth"
+        if el.block == "d":
+            return "transition"
         if el.block == "p" and el.group == 17:
             return "halogen"
         if el.block == "p" and el.group == 18:
             return "noble-gas"
-        if el.block == "d":
-            return "transition"
         if el.block == "f" and 57 <= el.number <= 71:
             return "lanthanide"
         if el.block == "f" and 89 <= el.number <= 103:
@@ -106,12 +92,12 @@ def build_elements_df() -> pd.DataFrame:
         el = elements[Z]
         if el is None:
             continue
-        data = {
+        rows.append({
             "Z": el.number,
             "symbol": el.symbol,
             "name": el.name.title(),
             "period": getattr(el, "period", None),
-            "group": getattr(el, "group", None),  # may be None for many
+            "group": getattr(el, "group", None),
             "block": getattr(el, "block", None),
             "mass": to_float(getattr(el, "mass", None)),
             "density": to_float(getattr(el, "density", None)),
@@ -122,54 +108,35 @@ def build_elements_df() -> pd.DataFrame:
             "covalent_radius": to_float(getattr(el, "covalent_radius", None)),
             "category": classify_category(el),
             "is_radioactive": bool(getattr(el, "radioactive", False)),
-        }
-        rows.append(data)
+        })
     return pd.DataFrame(rows).sort_values("Z").reset_index(drop=True)
 
 DF = build_elements_df()
 
-# -----------------------------
-# Build a robust grid (no reliance on group from the lib)
-# Rules: s->groups 1-2, d->3..12, p->13..18; period 1 special (H at 1, He at 18)
-# f-block shown separately.
-# -----------------------------
-MAX_GROUP = 18
-MAX_PERIOD = 7
-GRID: List[List[Optional[int]]] = [[None for _ in range(MAX_GROUP)] for _ in range(MAX_PERIOD)]
-
-for period in range(1, MAX_PERIOD + 1):
-    rows = DF[DF["period"] == period].sort_values("Z")
-    s = rows[rows["block"] == "s"]["Z"].tolist()
-    d = rows[rows["block"] == "d"]["Z"].tolist()
-    p = rows[rows["block"] == "p"]["Z"].tolist()
-    # Period 1 special case
-    if period == 1:
-        # Expect H then He
-        if len(s) >= 1:
-            GRID[0][0] = int(s[0])  # H -> group 1
-        if len(p) >= 1:
-            GRID[0][17] = int(p[-1])  # He -> group 18
-        continue
-    # s-block (usually 2)
-    if len(s) >= 1:
-        GRID[period - 1][0] = int(s[0])     # group 1
-    if len(s) >= 2:
-        GRID[period - 1][1] = int(s[1])     # group 2
-    # d-block (10 wide), only in periods >= 4
-    for i, z in enumerate(d):
-        if i < 10:
-            GRID[period - 1][2 + i] = int(z)  # groups 3..12
-    # p-block (6 wide)
-    for i, z in enumerate(p[-6:]):  # last 6 p-block in order
-        GRID[period - 1][12 + i] = int(z)     # groups 13..18
+# ---------- hardcoded main-grid layout (periods 1–7, groups 1–18) ----------
+# None = empty cell; numbers = atomic numbers
+GRID = [
+    # P1
+    [1, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, 2],
+    # P2
+    [3, 4, None, None, None, None, None, None, None, None, None, None, 5, 6, 7, 8, 9, 10],
+    # P3
+    [11, 12, None, None, None, None, None, None, None, None, None, None, 13, 14, 15, 16, 17, 18],
+    # P4
+    [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36],
+    # P5
+    [37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54],
+    # P6 (La shown at group 3)
+    [55, 56, 57, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86],
+    # P7 (Ac shown at group 3)
+    [87, 88, 89, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118],
+]
 
-# f-block lists (lanthanides/actinides)
-LAN = [int(z) for z in DF["Z"] if 57 <= int(z) <= 71]
-ACT = [int(z) for z in DF["Z"] if 89 <= int(z) <= 103]
+# f-block lists we display separately (omit La & Ac because they’re in the main grid)
+LAN = list(range(58, 72))   # Ce..Lu
+ACT = list(range(90, 104))  # Th..Lr
 
-# -----------------------------
-# Plotting (Matplotlib -> gr.Plot)
-# -----------------------------
+# ---------- plotting ----------
 def plot_trend(trend_df: pd.DataFrame, prop_key: str, Z: int, symbol: str):
     fig, ax = plt.subplots()
     ax.scatter(trend_df["Z"], trend_df[prop_key])
@@ -185,9 +152,10 @@ def plot_trend(trend_df: pd.DataFrame, prop_key: str, Z: int, symbol: str):
 
 def plot_heatmap(property_key: str):
     prop_label = dict(NUMERIC_PROPS)[property_key]
-    grid_vals = np.full((MAX_PERIOD, MAX_GROUP), np.nan, dtype=float)
-    for r in range(MAX_PERIOD):
-        for c in range(MAX_GROUP):
+    max_period, max_group = len(GRID), len(GRID[0])
+    grid_vals = np.full((max_period, max_group), np.nan, dtype=float)
+    for r in range(max_period):
+        for c in range(max_group):
             z = GRID[r][c]
             if z is None:
                 continue
@@ -196,10 +164,10 @@ def plot_heatmap(property_key: str):
                 grid_vals[r, c] = float(val)
     fig, ax = plt.subplots()
     im = ax.imshow(grid_vals, origin="upper", aspect="auto")
-    ax.set_xticks(range(MAX_GROUP))
-    ax.set_xticklabels([str(i) for i in range(1, MAX_GROUP + 1)])
-    ax.set_yticks(range(MAX_PERIOD))
-    ax.set_yticklabels([str(i) for i in range(1, MAX_PERIOD + 1)])
+    ax.set_xticks(range(max_group))
+    ax.set_xticklabels([str(i) for i in range(1, max_group + 1)])
+    ax.set_yticks(range(max_period))
+    ax.set_yticklabels([str(i) for i in range(1, max_period + 1)])
     ax.set_xlabel("Group")
     ax.set_ylabel("Period")
     ax.set_title(f"Periodic heatmap: {prop_label}")
@@ -207,9 +175,7 @@ def plot_heatmap(property_key: str):
     fig.tight_layout()
     return fig
 
-# -----------------------------
-# Callbacks
-# -----------------------------
+# ---------- callbacks ----------
 def element_info(z_or_symbol: str):
     try:
         if z_or_symbol.isdigit():
@@ -229,18 +195,19 @@ def element_info(z_or_symbol: str):
     facts.append(GROUP_FACTS.get(row["category"], None))
     facts = [f for f in facts if f]
 
+    def show(v):  # nicer NaN -> —
+        return v if (v is not None and not pd.isna(v)) else "—"
+
     props_lines = [
         f"{row['name']} ({symbol}), Z = {Z}",
         f"Period {int(row['period']) if not pd.isna(row['period']) else '—'}, "
         f"Group {row['group'] if row['group'] is not None else '—'}, "
         f"Block {row['block']} | Category: {row['category'].replace('-', ' ').title()}",
-        f"Atomic mass: {row['mass'] if not pd.isna(row['mass']) else '—'} u",
-        f"Density: {row['density'] if not pd.isna(row['density']) else '—'} g/cm³",
-        f"Electronegativity: {row['electronegativity'] if not pd.isna(row['electronegativity']) else '—'} (Pauling)",
-        f"Melting point: {row['melting_point'] if not pd.isna(row['melting_point']) else '—'} K | "
-        f"Boiling point: {row['boiling_point'] if not pd.isna(row['boiling_point']) else '—'} K",
-        f"vdW radius: {row['vdw_radius'] if not pd.isna(row['vdw_radius']) else '—'} pm | "
-        f"Covalent radius: {row['covalent_radius'] if not pd.isna(row['covalent_radius']) else '—'} pm",
+        f"Atomic mass: {show(row['mass'])} u",
+        f"Density: {show(row['density'])} g/cm³",
+        f"Electronegativity: {show(row['electronegativity'])} (Pauling)",
+        f"Melting point: {show(row['melting_point'])} K | Boiling point: {show(row['boiling_point'])} K",
+        f"vdW radius: {show(row['vdw_radius'])} pm | Covalent radius: {show(row['covalent_radius'])} pm",
         f"Radioactive: {'Yes' if row['is_radioactive'] else 'No'}",
     ]
     info_text = "\n".join(props_lines)
@@ -249,7 +216,6 @@ def element_info(z_or_symbol: str):
     prop_key = "electronegativity" if not pd.isna(row["electronegativity"]) else "mass"
     trend_df = DF[["Z", "symbol", prop_key]].dropna()
     fig = plot_trend(trend_df, prop_key, Z, symbol)
-
     return info_text, facts_text, fig
 
 def handle_button_click(z: int):
@@ -261,14 +227,12 @@ def search_element(query: str):
         return gr.update(), gr.update(), gr.update()
     return element_info(query)
 
-# -----------------------------
-# UI (Gradio 4.29.0 compatible)
-# -----------------------------
+# ---------- UI ----------
 with gr.Blocks(title="Interactive Periodic Table") as demo:
-    gr.Markdown("# 🧪 Interactive Periodic Table\nClick an element or search by symbol/name/atomic number.")
+    gr.Markdown("Click an element or search by symbol/name/atomic number.")
 
     with gr.Row():
-        # Inspector first so buttons can target these outputs
+        # Inspector
         with gr.Column(scale=1):
             gr.Markdown("### Inspector")
             search = gr.Textbox(label="Search (symbol/name/Z)", placeholder="e.g., C, Iron, 79")
@@ -283,16 +247,15 @@ with gr.Blocks(title="Interactive Periodic Table") as demo:
             prop.change(lambda k: plot_heatmap(k), inputs=[prop], outputs=[heat])
             demo.load(lambda: plot_heatmap("electronegativity"), outputs=[heat])
 
+        # Main table
         with gr.Column(scale=2):
             gr.Markdown("### Main Table")
-            # Group headers (1..18)
             with gr.Row():
                 for g in range(1, 19):
                     gr.Markdown(f"**{g}**")
-            # Grid of element buttons
-            for r in range(MAX_PERIOD):
+            for r in range(len(GRID)):
                 with gr.Row():
-                    for c in range(MAX_GROUP):
+                    for c in range(len(GRID[0])):
                         z = GRID[r][c]
                         if z is None:
                             gr.Button("", interactive=False)
@@ -306,15 +269,13 @@ with gr.Blocks(title="Interactive Periodic Table") as demo:
             with gr.Row():
                 for z in LAN:
                     sym = DF.loc[DF["Z"] == z, "symbol"].values[0]
-                    btn = gr.Button(sym)
-                    btn.click(handle_button_click, inputs=[gr.Number(z, visible=False)],
-                              outputs=[info, facts, trend])
+                    gr.Button(sym).click(handle_button_click, inputs=[gr.Number(z, visible=False)],
+                                         outputs=[info, facts, trend])
             with gr.Row():
                 for z in ACT:
                     sym = DF.loc[DF["Z"] == z, "symbol"].values[0]
-                    btn = gr.Button(sym)
-                    btn.click(handle_button_click, inputs=[gr.Number(z, visible=False)],
-                              outputs=[info, facts, trend])
+                    gr.Button(sym).click(handle_button_click, inputs=[gr.Number(z, visible=False)],
+                                         outputs=[info, facts, trend])
 
 if __name__ == "__main__":
     demo.launch()