alphaengine 0.9.0__tar.gz → 0.9.1__tar.gz

{alphaengine-0.9.0 → alphaengine-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: alphaengine
-Version: 0.9.0
+Version: 0.9.1
 Summary: Validated research tooling for investment strategies: deflation, overfitting detection, and honest trial counts.
 Project-URL: Homepage, https://github.com/quantOSC/alphaengine
 Project-URL: Documentation, https://github.com/quantOSC/alphaengine#readme

{alphaengine-0.9.0 → alphaengine-0.9.1}/src/alphaengine/_version.py

@@ -76,4 +76,8 @@ is what a changed figure costs. The API may still move underneath it.
 # Close fills are unchanged. No golden in tests/test_goldens.py moves. The
 # same release makes the full-screen terminal the only session, and posts each
 # math line's series on `/traces` without putting those series inside figures.
-__version__ = "0.9.0"
+#
+# 0.9.1 IS THE SESSION, NOT THE MATHS. No computed value moved. A signed-in
+# account loads its one stored universe from the portal. `enter model key`
+# takes whichever provider key is pasted. The left pane lists the commands.
+__version__ = "0.9.1"

{alphaengine-0.9.0 → alphaengine-0.9.1}/src/alphaengine/core/risk.py

@@ -129,7 +129,12 @@ def compute_var_cvar(
     record(
         "parametric_var",
         "z * std(r, ddof=1) * sqrt(horizon), z = normsinv(confidence), as a positive percent",
-        inputs={"n_obs": int(n_obs), "confidence": confidence, "horizon_days": int(horizon_days), "z": round(z, 6)},
+        inputs={
+            "n_obs": int(n_obs),
+            "confidence": confidence,
+            "horizon_days": int(horizon_days),
+            "z": round(z, 6),
+        },
         series={"returns": arr},
         result=result["parametric"]["var_pct"],
     )

{alphaengine-0.9.0 → alphaengine-0.9.1}/src/alphaengine/model.py

@@ -328,13 +328,12 @@ def build_think(
         )
 
     raise NoModelConfigured(
-        "No model key found. The agentic path runs under YOUR account, so it "
-        "needs your key in this shell:\n"
-        "    ANTHROPIC_API_KEY=...   or   OPENAI_API_KEY=...\n"
-        "    or GEMINI_API_KEY / GROQ_API_KEY / OPENROUTER_API_KEY /\n"
-        "    AZURE_OPENAI_API_KEY / ALPHAENGINE_API_KEY+ALPHAENGINE_BASE_URL\n"
-        "Nothing here stores it, and the scripted path (`run <workflow>`) needs "
-        "no model at all."
+        "No model key found. In the session, type `enter model key` and paste it.\n"
+        "Or set the key in this shell: ANTHROPIC_API_KEY, OPENAI_API_KEY, "
+        "GEMINI_API_KEY, GROQ_API_KEY, OPENROUTER_API_KEY, "
+        "AZURE_OPENAI_API_KEY, or ALPHAENGINE_API_KEY with ALPHAENGINE_BASE_URL.\n"
+        "Nothing here sends that key to QuantOS, and the scripted path "
+        "(`run <workflow>`) needs no model at all."
     )
 
 

{alphaengine-0.9.0 → alphaengine-0.9.1}/src/alphaengine/tui/app.py

@@ -16,6 +16,28 @@ from .dispatch import Desk, submit
 
 _ANSI = re.compile(r"\x1b\[[0-9;]*m")
 
+_COMMANDS = (
+    "login",
+    "enter model key",
+    "load <name>",
+    "screen",
+    "diagnose",
+    "signal",
+    "validate",
+    "stress",
+    "overlap",
+    "size",
+    "monitor",
+    "run <name>",
+    "workflows",
+    "help",
+    "quit",
+)
+_URL_AFTER = {
+    "AZURE_OPENAI_API_KEY": "AZURE_OPENAI_ENDPOINT",
+    "ALPHAENGINE_API_KEY": "ALPHAENGINE_BASE_URL",
+}
+
 _CSS = """
 Screen { background: #0b0d10; }
 #status {
@@ -27,12 +49,12 @@ Screen { background: #0b0d10; }
 }
 #body { height: 1fr; }
 #rail {
-    width: 26;
-    min-width: 26;
+    width: 28;
+    min-width: 28;
     background: #101318;
     color: #c5cdd6;
     padding: 1 1;
-    overflow: hidden;
+    overflow: auto;
 }
 #transcript {
     width: 1fr;
@@ -106,6 +128,7 @@ class QuantOSApp(App[None]):
             keyed=keyed,
         )
         self._universes: list[str] = []
+        self._stored: set[str] = set()
         self._lines: list[dict[str, Any]] = []
         self.busy = False
         self.rail_text = ""
@@ -133,18 +156,11 @@ class QuantOSApp(App[None]):
         log = self.query_one("#transcript", RichLog)
         log.write("Ask in plain English.")
         log.write("A sentence picks a workflow.  run <name> follows it exactly.")
+        log.write("login signs you in.  enter model key pastes whichever key you use.")
         log.write("")
         log.write("help lists what you can type.  quit leaves.")
         self.query_one(Input).focus()
-        try:
-            rows = self.desk.session.universes()
-        except Exception:  # noqa: BLE001 — the ladder still stands without the list
-            rows = []
-        self._universes = [
-            str(row.get("name") or row.get("id") or "") for row in rows if isinstance(row, dict)
-        ]
-        self._universes = [name for name in self._universes if name]
-        self._refresh_rail()
+        self._sync_account()
 
     def _refresh_rail(self) -> None:
         from ..model import available_models, keys_without_sdk
@@ -158,7 +174,7 @@ class QuantOSApp(App[None]):
         elif keyed and stranded:
             ask_note = "sdk missing"
         elif keyed:
-            ask_note = "add a model key"
+            ask_note = "enter model key"
         else:
             ask_note = "sign in first"
 
@@ -170,7 +186,8 @@ class QuantOSApp(App[None]):
         else:
             loaded = "nothing"
 
-        lines = [
+        lines = ["commands", *[f"  {name}" for name in _COMMANDS], ""]
+        lines += [
             f"{on}  the maths",
             "    offline, always",
             "",
@@ -186,11 +203,13 @@ class QuantOSApp(App[None]):
             "universes",
         ]
         if self._universes:
-            lines.extend(f"  {_fit(name, 20)}" for name in self._universes[:12])
+            for name in self._universes[:12]:
+                mark = " stored" if name in self._stored else ""
+                lines.append(f"  {_fit(name, 20 - len(mark))}{mark}")
         else:
             lines.append("  none in reach")
         if not keyed:
-            lines += ["", "key quantos", "signs you in"]
+            lines += ["", "login", "signs you in"]
         self.rail_text = "\n".join(lines)
         self.query_one("#rail", Static).update(self.rail_text)
 
@@ -213,6 +232,12 @@ class QuantOSApp(App[None]):
         if self.desk.pending_secret:
             self._accept_secret(text)
             return
+        if self.desk.pending_provider:
+            self._accept_provider(text)
+            return
+        if self.desk.pending_url:
+            self._accept_url(text)
+            return
         self.busy = True
         self.query_one("#transcript", RichLog).write(f"> {text}")
 
@@ -231,6 +256,43 @@ class QuantOSApp(App[None]):
         if env is None or not value:
             log.write("nothing entered.")
             return
+        if env == "MODEL_KEY":
+            self._take_model_key(value, log, prompt)
+            return
+        self._store_credential(env, value, log, prompt)
+
+    def _take_model_key(self, value: str, log: RichLog, prompt: Input) -> None:
+        from .dispatch import env_for_model_key
+
+        found = env_for_model_key(value)
+        if found is None:
+            self.desk.held_key = value
+            self.desk.pending_provider = True
+            prompt.password = False
+            prompt.placeholder = "anthropic, openai, gemini, groq, openrouter, azure, gateway"
+            log.write("Which provider is this key for?")
+            return
+        self._store_credential(found, value, log, prompt)
+
+    def _accept_provider(self, text: str) -> None:
+        from ..cli import _KEY_PROMPTS
+
+        which = text.strip().lower()
+        prompt = self.query_one(Input)
+        log = self.query_one("#transcript", RichLog)
+        if which not in _KEY_PROMPTS or which == "quantos":
+            log.write("Try anthropic, openai, gemini, groq, openrouter, azure, or gateway.")
+            return
+        value = self.desk.held_key or ""
+        self.desk.held_key = None
+        self.desk.pending_provider = False
+        prompt.placeholder = "Ask in plain English, or run <workflow>"
+        if not value:
+            log.write("nothing entered.")
+            return
+        self._store_credential(_KEY_PROMPTS[which][0], value, log, prompt)
+
+    def _store_credential(self, env: str, value: str, log: RichLog, prompt: Input) -> None:
         os.environ[env] = value
         if env == "QUANTOS_API_KEY":
             from ..cli import _session
@@ -247,6 +309,96 @@ class QuantOSApp(App[None]):
             log.write(f"{env} accepted.  stored at {path}")
         except (OSError, ValueError) as exc:
             log.write(f"{env} accepted for this process.  ({exc})")
+        follow = _URL_AFTER.get(env)
+        if follow and not os.environ.get(follow):
+            self.desk.pending_url = follow
+            prompt.placeholder = f"paste {follow}"
+            log.write(f"Now paste {follow}. It is not hidden.")
+        elif env != "QUANTOS_API_KEY":
+            self._say_model_ready(log)
+        if env == "QUANTOS_API_KEY":
+            self._sync_account()
+        else:
+            self._refresh_rail()
+
+    def _accept_url(self, value: str) -> None:
+        env = self.desk.pending_url
+        self.desk.pending_url = None
+        prompt = self.query_one(Input)
+        prompt.placeholder = "Ask in plain English, or run <workflow>"
+        log = self.query_one("#transcript", RichLog)
+        if env is None or not value:
+            log.write("nothing entered.")
+            return
+        os.environ[env] = value
+        try:
+            from ..auth import save_key
+
+            save_key(env, value)
+        except (OSError, ValueError):
+            pass
+        log.write(f"{env} set.")
+        self._say_model_ready(log)
+        self._refresh_rail()
+
+    def _say_model_ready(self, log: RichLog) -> None:
+        from ..model import _SDK, available_models, keys_without_sdk
+
+        stranded = keys_without_sdk()
+        ready = available_models()
+        if stranded:
+            installs = " or ".join(f"pip install {_SDK[label]}" for label in stranded)
+            log.write(f"Key stored. The SDK is not installed yet: {installs}")
+            return
+        if ready:
+            label, model = ready[0]
+            log.write(f"Model ready: {label}/{model}. Ask in plain English.")
+
+    def _sync_account(self) -> None:
+        """Refresh portal universes. One stored book loads itself."""
+        from ..cli import _narrow_to_universe, _stored_universes, narration_to
+
+        notes: list[str] = []
+
+        def sink(chunk: str) -> None:
+            notes.append(chunk)
+
+        try:
+            rows = self.desk.session.universes()
+        except Exception:  # noqa: BLE001 — offline or unsigned still boots
+            rows = []
+        self._stored = set()
+        names: list[str] = []
+        for row in rows:
+            if not isinstance(row, dict):
+                continue
+            name = str(row.get("name") or row.get("id") or "")
+            if not name:
+                continue
+            names.append(name)
+            if (row.get("definition") or {}).get("cache_id"):
+                self._stored.add(name)
+        self._universes = names
+
+        if self.desk.data is None and self.desk.keyed:
+            with narration_to(sink):
+                wanted, ready = _stored_universes(self.desk.session)
+                if wanted:
+                    try:
+                        self.desk.data = _narrow_to_universe(self.desk.session, wanted, None)
+                        self.desk.loaded = f"universe:{wanted}"
+                    except Exception as exc:  # noqa: BLE001
+                        notes.append(str(exc))
+                elif len(ready) > 1:
+                    notes.append(
+                        "Stored on your account: " + ", ".join(ready) + ".  Type load <name> to use one."
+                    )
+        log = self.query_one("#transcript", RichLog)
+        for note in notes:
+            plain = _plain(note)
+            if plain.strip():
+                self.transcript.append(plain)
+                log.write(plain)
         self._refresh_rail()
 
     def _run_line(self, text: str) -> None:
@@ -274,7 +426,19 @@ class QuantOSApp(App[None]):
             prompt = self.query_one(Input)
             prompt.password = True
             prompt.placeholder = "paste the key (hidden)"
-        self._refresh_rail()
+        elif self.desk.pending_provider:
+            prompt = self.query_one(Input)
+            prompt.password = False
+            prompt.placeholder = "anthropic, openai, gemini, groq, openrouter, azure, gateway"
+        elif self.desk.pending_url:
+            prompt = self.query_one(Input)
+            prompt.password = False
+            prompt.placeholder = f"paste {self.desk.pending_url}"
+        if self.desk.account_dirty:
+            self.desk.account_dirty = False
+            self._sync_account()
+        else:
+            self._refresh_rail()
         self._load_lines()
         self.busy = False
         if quitting:

{alphaengine-0.9.0 → alphaengine-0.9.1}/src/alphaengine/tui/dispatch.py

@@ -51,6 +51,10 @@ class Desk:
     think: Callable[[str], str] | None = None
     keyed: bool = False
     pending_secret: str | None = None
+    pending_url: str | None = None
+    pending_provider: bool = False
+    held_key: str | None = None
+    account_dirty: bool = False
     pinned_model: str | None = None
     book: Any = None
 
@@ -84,6 +88,11 @@ def submit(desk: Desk, line: str) -> bool:
     if line.startswith("/"):
         line = line[1:].lstrip()
 
+    if line.lower() == "enter model key":
+        desk.pending_secret = "MODEL_KEY"
+        say(dim("Paste the model key. It stays hidden. The provider is read from the key."))
+        return False
+
     verb, _, rest = line.partition(" ")
     if verb in QUESTION_VERBS and not rest:
         verb, rest = "run", QUESTION_VERBS[verb]
@@ -210,28 +219,58 @@ def _ns(desk: Desk, **extra: Any) -> Any:
 def _logout(desk: Desk) -> None:
     import os
 
+    from ..auth import MANAGED
     from ..cli import _session, cmd_logout
 
     cmd_logout(_ns(desk))
-    for name in ("QUANTOS_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY"):
+    for name in MANAGED:
         os.environ.pop(name, None)
     desk.session, desk.url = _session(getattr(desk.args, "url", None), getattr(desk.args, "key", None))
     desk.keyed = False
     desk.pending_secret = None
+    desk.pending_url = None
+    desk.pending_provider = False
+    desk.held_key = None
+    desk.pinned_model = None
+    if str(desk.loaded or "").startswith("universe:"):
+        desk.data = None
+        desk.backtest_fn = None
+        desk.loaded = None
+    desk.account_dirty = True
 
 
 def _key(desk: Desk, rest: str) -> None:
+    from ..cli import _KEY_PROMPTS
+
     which = (rest.split() or [""])[0].lower()
-    names = {
-        "quantos": "QUANTOS_API_KEY",
-        "anthropic": "ANTHROPIC_API_KEY",
-        "openai": "OPENAI_API_KEY",
-    }
-    if which not in names:
-        say(dim("key quantos, key anthropic, or key openai. The next line is the key, and it stays hidden."))
+    if not which:
+        if not desk.keyed:
+            which = "quantos"
+        else:
+            say(dim("Already signed in. Type `enter model key` and paste it."))
+            return
+    if which not in _KEY_PROMPTS:
+        say(dim(f"Unknown {which!r}. Try: {', '.join(_KEY_PROMPTS)}"))
         return
-    desk.pending_secret = names[which]
-    say(dim(f"Paste the {which} key. It is hidden, then stored for this machine."))
+    env, what = _KEY_PROMPTS[which]
+    desk.pending_secret = env
+    say(dim(f"Paste the {which} key. {what} It stays hidden, then this machine keeps it."))
+
+
+def env_for_model_key(value: str) -> str | None:
+    """Which env var this key belongs in, when the prefix says so."""
+    text = value.strip()
+    if text.startswith("sk-ant-"):
+        return "ANTHROPIC_API_KEY"
+    if text.startswith("sk-or-"):
+        return "OPENROUTER_API_KEY"
+    if text.startswith("gsk_"):
+        return "GROQ_API_KEY"
+    if text.startswith("AIza"):
+        return "GEMINI_API_KEY"
+    if text.startswith("sk-"):
+        return "OPENAI_API_KEY"
+    return None
 
 
 def _pin_model(desk: Desk, rest: str) -> None:

{alphaengine-0.9.0 → alphaengine-0.9.1}/tests/test_tui.py

@@ -85,6 +85,8 @@ def test_boot_shows_the_ladder_and_a_stored_universe() -> None:
         app = QuantOSApp(session=_DeskSession(), url="fake://", data=_returns(), keyed=True, think=_think)
         async with app.run_test(size=(140, 42)) as pilot:
             await pilot.pause()
+            assert "enter model key" in app.rail_text
+            assert "load <name>" in app.rail_text
             assert "the maths" in app.rail_text
             assert "sp500" in app.rail_text
             prompt = app.query_one(Input)
@@ -112,6 +114,96 @@ def test_a_scripted_run_opens_the_sharpe_line_at_full_length() -> None:
     asyncio.run(body())
 
 
+class _StoredBook(Session):
+    """One portal universe whose closes were stored with the upload."""
+
+    def __init__(self, names: list[str]) -> None:
+        super().__init__(base_url="fake://", api_key="ae_live_test")
+        self._names = names
+
+    def _get(self, path: str):
+        if path.endswith("/series"):
+            return {"prices": {"AAPL": [10.0, 11.0, 12.0, 13.0]}}
+        if path.endswith("/universes"):
+            return {
+                "universes": [
+                    {
+                        "id": f"u{i}",
+                        "name": name,
+                        "definition": {"cache_id": f"c{i}", "symbols": ["AAPL"]},
+                    }
+                    for i, name in enumerate(self._names)
+                ]
+            }
+        if path.endswith("/workflows"):
+            return {"workflows": []}
+        return {}
+
+    def _post(self, path, body):
+        return {}
+
+
+def test_a_signed_in_account_loads_its_one_stored_universe() -> None:
+    async def body() -> None:
+        app = QuantOSApp(session=_StoredBook(["sp500"]), url="fake://", keyed=True, think=_think)
+        async with app.run_test(size=(140, 42)) as pilot:
+            await pilot.pause()
+            assert app.desk.loaded == "universe:sp500"
+            assert "AAPL" in app.desk.data
+            assert "stored" in app.rail_text
+            assert any("portal" in line for line in app.transcript)
+
+    asyncio.run(body())
+
+
+def test_several_stored_universes_are_named_and_not_guessed() -> None:
+    async def body() -> None:
+        app = QuantOSApp(session=_StoredBook(["sp500", "ndx"]), url="fake://", keyed=True, think=_think)
+        async with app.run_test(size=(140, 42)) as pilot:
+            await pilot.pause()
+            assert app.desk.data is None
+            text = "\n".join(app.transcript)
+            assert "sp500" in text and "ndx" in text
+
+    asyncio.run(body())
+
+
+def test_login_pastes_a_quantos_key_and_login_gemini_pastes_that_provider() -> None:
+    async def body() -> None:
+        app = QuantOSApp(session=_DeskSession(), url="fake://", keyed=False, think=_think)
+        async with app.run_test(size=(140, 42)) as pilot:
+            await pilot.pause()
+            field = app.query_one(Input)
+            field.focus()
+            field.value = "login"
+            await pilot.press("enter")
+            await _wait(pilot, app)
+            assert app.desk.pending_secret == "QUANTOS_API_KEY"
+            assert app.query_one(Input).password is True
+
+            app.desk.pending_secret = None
+            app.desk.keyed = True
+            app.query_one(Input).password = False
+            field.value = "enter model key"
+            await pilot.press("enter")
+            await _wait(pilot, app)
+            assert app.desk.pending_secret == "MODEL_KEY"
+            assert app.query_one(Input).password is True
+
+    asyncio.run(body())
+
+
+def test_a_model_key_prefix_names_the_provider() -> None:
+    from alphaengine.tui.dispatch import env_for_model_key
+
+    assert env_for_model_key("sk-ant-abc") == "ANTHROPIC_API_KEY"
+    assert env_for_model_key("sk-or-abc") == "OPENROUTER_API_KEY"
+    assert env_for_model_key("gsk_abc") == "GROQ_API_KEY"
+    assert env_for_model_key("AIzaabc") == "GEMINI_API_KEY"
+    assert env_for_model_key("sk-abc") == "OPENAI_API_KEY"
+    assert env_for_model_key("not-a-known-prefix") is None
+
+
 def test_a_sentence_uses_the_fake_model_to_choose_a_workflow() -> None:
     async def body() -> None:
         app = QuantOSApp(session=_DeskSession(), url="fake://", data=_returns(), keyed=True, think=_think)