Upload 18 files

app.py

@@ -11,7 +11,6 @@ github.com/adobe/react-spectrum), approximated in Gradio CSS:
 from __future__ import annotations
 
 import os
-import re
 import threading
 
 import gradio as gr
@@ -45,11 +44,6 @@ def ui_run_signals(tickers_text, force):
     automation.STATE["signals_df"] = df
     automation.STATE["signals_details"] = details
     automation.STATE["signals_summary"] = summary
-    # Pre-translate every ruling chain to English in the BACKGROUND on the
-    # dedicated rchain sub-agent, so when the user clicks AI summary the English
-    # chain is already cached → faster, and the merge step gets English-only
-    # input (no Chinese can leak into the output).
-    _kick_chain_translation(details)
     choices = sorted(details.keys())
     return (
         df if df is not None else pd.DataFrame(),
@@ -58,50 +52,6 @@ def ui_run_signals(tickers_text, force):
     )
 
 
-def _chain_core(ticker: str) -> str:
-    """The ruling chain minus the huge per-signal diagnostics block."""
-    chain = automation.STATE.get("signals_details", {}).get(ticker, "")
-    return chain.split("日线买卖点逐项诊断")[0].strip()[:2000] if chain else ""
-
-
-def _translate_chain(ticker: str) -> str:
-    """Translate one ruling chain to English on the dedicated rchain sub-agent;
-    cache the result. Returns the English text (or '' if no model/chain)."""
-    cache = automation.STATE.setdefault("chain_en", {})
-    if ticker in cache:
-        return cache[ticker]
-    core = _chain_core(ticker)
-    if not core:
-        return ""
-    if not (llm_local.is_loaded("rchain") or llm_local.is_loaded("translator")):
-        return ""
-    wk = "rchain" if llm_local.is_loaded("rchain") else "translator"
-    prompt = ("Translate this Chinese multi-timeframe Chan-theory decision log "
-              "into concise English. Keep the structure (one line per level: "
-              "yearly / monthly / weekly / daily / 60m / 30m …). Output ENGLISH "
-              "ONLY, no Chinese characters, no commentary.\n\n" + core)
-    en = llm_local.chat(prompt, max_tokens=380, temperature=0.1, worker=wk)
-    if en and not en.startswith(("(", "⏳")):
-        cache[ticker] = en
-        return en
-    return ""
-
-
-def _kick_chain_translation(details: dict):
-    """Background: translate all ruling chains to English right after analysis,
-    so AI summary is instant and English-only later."""
-    import threading
-    automation.STATE["chain_en"] = {}   # reset for the new run
-
-    def _run():
-        for tk in list(details.keys()):
-            try:
-                _translate_chain(tk)
-            except Exception:
-                pass
-    threading.Thread(target=_run, daemon=True).start()
-
-
 def ui_show_detail(ticker):
     if not ticker:
         return "Select a ticker after running the analysis."
@@ -116,42 +66,28 @@ def ui_explain_detail(ticker):
     if not raw:
         yield "Run the analysis and select a ticker first."
         return
-    # Use the pre-translated English ruling chain (translated in the background
-    # right after Run analysis). If it isn't ready yet, translate it now on the
-    # rchain sub-agent. Both the fact line AND the chain are now English, so the
-    # merge step cannot leak Chinese into the output.
-    chain_en = automation.STATE.get("chain_en", {}).get(ticker or "")
-    if not chain_en:
-        yield "🤖 _Translating the multi-timeframe ruling chain to English…_"
-        chain_en = _translate_chain(ticker or "")
+    # The full Chan ruling chain (Chinese) is kept BACKSTAGE in STATE and fed to
+    # the model alongside the English raw read, so the summary reflects the real
+    # multi-timeframe reasoning — but the chain is never shown and output is
+    # English only. (This restores the merged raw-read + ruling-chain logic.)
+    chain = automation.STATE.get("signals_details", {}).get(ticker or "", "")
+    chain_core = chain.split("日线买卖点逐项诊断")[0].strip()[:2000] if chain else ""
     prompt = ("You are an equity analyst. Write a SHORT plain-English summary "
               "(≤100 words) for a long-term holder of a US stock: the situation "
               "today, whether to act or wait, and the key price levels.\n"
-              "Base it on the FACT LINE (numbers) and the REASONING (an English "
-              "translation of the multi-timeframe Chan-theory verdict). Output "
-              "ENGLISH ONLY, do not quote the inputs, no disclaimers.\n\n"
+              "Use the FACT LINE for the numbers, and the RULING CHAIN (a "
+              "Chinese multi-timeframe Chan-theory decision log) for the reasoning "
+              "— translate and synthesize it; output ENGLISH ONLY, no Chinese "
+              "characters, do not quote the log, no disclaimers.\n\n"
               f"FACT LINE:\n{raw}")
-    if chain_en:
-        prompt += f"\n\nREASONING:\n{chain_en}"
+    if chain_core:
+        prompt += f"\n\nRULING CHAIN (translate & synthesize, don't quote):\n{chain_core}"
     yield "🤖 _Translator sub-agent (Qwen3-1.7B · llama.cpp) is summarizing…_"
     final = ""
-    for acc in llm_local.chat_stream(prompt, max_tokens=240, temperature=0.2,
+    for acc in llm_local.chat_stream(prompt, max_tokens=260, temperature=0.2,
                                      worker="translator"):
         final = acc
         yield "🤖 **AI narrative (Translator sub-agent · Qwen3-1.7B):**\n\n" + acc
-    # English-only guarantee: if the model still slipped in Chinese, re-run once
-    # asking for a strict English rewrite.
-    if re.search(r"[\u4e00-\u9fff]", final):
-        fix = ("Rewrite the following as an English-only equity summary "
-               "(≤100 words). Remove ALL Chinese characters, keep the meaning "
-               "and numbers, no disclaimers:\n\n" + final)
-        fixed = ""
-        for acc in llm_local.chat_stream(fix, max_tokens=240, temperature=0.1,
-                                         worker="translator"):
-            fixed = acc
-            yield "🤖 **AI narrative (Translator sub-agent · Qwen3-1.7B):**\n\n" + acc
-        if fixed:
-            final = fixed
     # capture (raw read → narrative) as a fine-tuning pair (🎯 Well-Tuned)
     try:
         import finetune_data

llm_local.py

@@ -36,11 +36,10 @@ MODEL_ZOO = {
     # 🎯 Well-Tuned: after you publish your LoRA-merged GGUF, uncomment and edit
     # this line (repo = your HF id, filename = the .gguf you uploaded). It will
     # then appear in the Model tab as the fast Translator sub-agent.
-    "Chan-Tuned Qwen3-1.7B · my fine-tune": (
-        "ranranrunforit/chan-compass-qwen3-1.7b-gguf", "chan-qwen3-1.7b-q8_0.gguf"),
+    # "Chan-Tuned Qwen3-1.7B · my fine-tune": (
+    #     "ranranrunforit/chan-compass-qwen3-1.7b-gguf", "chan-qwen3-1.7b-q8_0.gguf"),
 }
-# FAST_MODEL = "Qwen3-1.7B · Tiny Titan (≤4B award class)"
-FAST_MODEL = "Chan-Tuned Qwen3-1.7B · my fine-tune"
+FAST_MODEL = "Qwen3-1.7B · Tiny Titan (≤4B award class)"
 DEFAULT_MODEL = "Qwen3-4B  · default — fast + smart, still ≤4B"
 
 _THINK_RE = re.compile(r"<think>.*?</think>", re.S)
@@ -52,7 +51,6 @@ _NCPU = max(2, (os.cpu_count() or 4))
 # the 4B Analyst writes reports. Total ≈ 9 GB on a 32 GB Space.
 WORKER_LABEL = {
     "translator": "Translator sub-agent (Signals · Explain)",
-    "rchain":     "Ruling-Chain Translator sub-agent (中文→EN)",
     "narrator":   "Narrator sub-agent (Sector Rotation)",
     "reporter":   "Reporter sub-agent (News · Research support)",
     "analyst":    "Analyst sub-agent (Auto Research)",
@@ -66,7 +64,6 @@ def _mk(model):
 
 WORKERS = {
     "translator": _mk(FAST_MODEL),
-    "rchain":     _mk(FAST_MODEL),
     "narrator":   _mk(FAST_MODEL),
     "reporter":   _mk(FAST_MODEL),
     "analyst":    _mk(DEFAULT_MODEL),
@@ -209,7 +206,7 @@ def load_model(name: str, worker: str = "analyst") -> str:
 def auto_load_all():
     """Startup: tiny agents first (one small GGUF download serves all three),
     then the Analyst. Runs in a background thread."""
-    for key in ("translator", "rchain", "narrator", "reporter", "analyst"):
+    for key in ("translator", "narrator", "reporter", "analyst"):
         load_model(WORKERS[key]["model"], worker=key)
 
 
@@ -222,7 +219,7 @@ def is_loaded(worker: str = None) -> bool:
 
 def status() -> str:
     lines = []
-    for key in ("translator", "rchain", "narrator", "reporter", "analyst"):
+    for key in ("translator", "narrator", "reporter", "analyst"):
         w = WORKERS[key]
         label = WORKER_LABEL[key]
         if w["llm"] is not None:
@@ -300,7 +297,7 @@ def quick_test() -> str:
     """Sanity check both sub-agents."""
     import time
     outs = []
-    for key in ("translator", "rchain", "narrator", "reporter", "analyst"):
+    for key in ("translator", "narrator", "reporter", "analyst"):
         if WORKERS[key]["llm"] is None:
             outs.append(f"{WORKER_LABEL[key]}: not loaded ({WORKERS[key]['stage']})")
             continue