fix: ui.py — fix dry run button by loading .env before subprocess and handling async properly"

alpha_factory/ui.py

@@ -4,11 +4,19 @@ View generated alphas, copy expressions, run new batches.
 
 Run: uv run python -m alpha_factory.ui
 """
+import os
+import sys
+import subprocess
 import duckdb
 import gradio as gr
 from pathlib import Path
-from datetime import datetime
 
+# Load .env so HF_TOKEN is available
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
 
 DB_PATH = Path("factor_store/alphas.duckdb")
 
@@ -44,35 +52,66 @@ def get_alphas_from_db(limit=50):
 def get_alpha_cards():
     rows = get_alphas_from_db()
     if not rows:
-        return []
+        return [["No alphas yet", "", "", "", "", "", "", "Run a batch first"]]
     data = []
     for row in rows:
         alpha_id, submitted_at, expression, theme, archetype, tag, neutral, decay, fields, verdict = row
         timestamp = submitted_at.strftime("%Y-%m-%d %H:%M") if submitted_at else "?"
         verdict_str = {"promote": "PASS", "iterate": "PENDING", "kill": "FAIL"}.get(verdict or "", "NEW")
-        expr_preview = (expression[:100] + "...") if expression and len(expression) > 100 else (expression or "")
-        data.append([timestamp, alpha_id[:10], theme or "", archetype or "", tag or "", decay or 0, verdict_str, expr_preview])
+        expr_preview = (expression[:80] + "...") if expression and len(expression) > 80 else (expression or "")
+        data.append([timestamp, alpha_id[:10], theme or "", archetype or "", tag or "", str(decay or 0), verdict_str, expr_preview])
     return data
 
 
 def get_full_expression(evt: gr.SelectData):
     rows = get_alphas_from_db()
     if not rows or evt.index is None:
-        return ""
+        return "Click a row above to see the full expression"
     row_idx = evt.index[0] if isinstance(evt.index, (list, tuple)) else evt.index
     if row_idx < len(rows):
         return rows[row_idx][2] or ""
     return ""
 
 
-def run_batch_and_refresh(batch_size):
-    import subprocess, sys
-    result = subprocess.run(
-        [sys.executable, "-m", "alpha_factory.run", "--dry-run", "--batch-size", str(int(batch_size))],
-        capture_output=True, text=True, encoding="utf-8", errors="replace"
-    )
-    log = result.stdout[-3000:] if result.stdout else result.stderr[-3000:]
-    return get_alpha_cards(), log
+def run_batch(batch_size):
+    """Run pipeline as subprocess and return log."""
+    env = os.environ.copy()
+    # Ensure HF_TOKEN passes to subprocess
+    if "HF_TOKEN" not in env:
+        token = os.getenv("HF_TOKEN", "")
+        if token:
+            env["HF_TOKEN"] = token
+
+    try:
+        result = subprocess.run(
+            [sys.executable, "-m", "alpha_factory.run", "--dry-run", "--batch-size", str(int(batch_size))],
+            capture_output=True,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=env,
+            timeout=120,
+            cwd=str(Path.cwd()),
+        )
+        log = ""
+        if result.stdout:
+            log += result.stdout[-3000:]
+        if result.returncode != 0 and result.stderr:
+            log += "\n\n--- ERRORS ---\n" + result.stderr[-2000:]
+        if not log.strip():
+            log = f"Process exited with code {result.returncode}"
+        return log
+    except subprocess.TimeoutExpired:
+        return "ERROR: Pipeline timed out after 120 seconds"
+    except Exception as e:
+        return f"ERROR: {str(e)}"
+
+
+def generate_and_refresh(batch_size):
+    """Run batch then refresh the table."""
+    log = run_batch(batch_size)
+    table = get_alpha_cards()
+    return table, log
 
 
 def build_ui():
@@ -84,13 +123,14 @@ def build_ui():
 
         with gr.Row():
             with gr.Column(scale=1):
-                batch_size_input = gr.Number(value=5, label="Batch Size", minimum=1, maximum=20)
-                generate_btn = gr.Button("🚀 Generate New Batch (Dry Run)", variant="primary")
+                batch_size_input = gr.Number(value=3, label="Batch Size", minimum=1, maximum=20)
+                generate_btn = gr.Button("🚀 Generate New Batch", variant="primary")
                 refresh_btn = gr.Button("🔄 Refresh Table")
+                gr.Markdown("*Dry run mode — no BRAIN submissions*")
             with gr.Column(scale=3):
-                gr.Markdown("Click any row below to see the **full expression** with copy support.")
+                stats_md = gr.Markdown(f"**Alphas in store:** {len(get_alphas_from_db())}")
 
-        gr.Markdown("### 📋 Generated Alphas")
+        gr.Markdown("### 📋 Click any row to see full expression")
 
         alpha_table = gr.Dataframe(
             value=get_alpha_cards(),
@@ -99,20 +139,24 @@ def build_ui():
             wrap=True,
         )
 
-        gr.Markdown("### 📝 Full Expression — select all & copy (Ctrl+A, Ctrl+C)")
+        gr.Markdown("### 📝 Full Expression — Ctrl+A then Ctrl+C to copy")
         full_expr = gr.Textbox(
             label="Full Expression",
             lines=6,
-            interactive=False,
+            interactive=True,  # So user can select & copy
         )
 
         gr.Markdown("### 📜 Pipeline Log")
-        pipeline_log = gr.Textbox(label="Last Run Output", lines=12, interactive=False)
+        pipeline_log = gr.Textbox(label="Output", lines=15, interactive=False)
 
         # Events
         alpha_table.select(get_full_expression, outputs=[full_expr])
-        refresh_btn.click(lambda: get_alpha_cards(), outputs=[alpha_table])
-        generate_btn.click(run_batch_and_refresh, inputs=[batch_size_input], outputs=[alpha_table, pipeline_log])
+        refresh_btn.click(get_alpha_cards, outputs=[alpha_table])
+        generate_btn.click(
+            generate_and_refresh,
+            inputs=[batch_size_input],
+            outputs=[alpha_table, pipeline_log],
+        )
 
     return app