brain-login-and-sim 0.1.0__tar.gz

brain_login_and_sim-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tanakrit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

brain_login_and_sim-0.1.0/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: brain-login-and-sim
+Version: 0.1.0
+Summary: WorldQuant BRAIN client — login (biometric Scan + auto re-login), simulation, batch run, and auto-keeping promising alphas
+Author-email: Tanakrit <9tanakrit.work@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Tanakrit/brain-login-and-sim
+Project-URL: Issues, https://github.com/Tanakrit/brain-login-and-sim/issues
+Keywords: worldquant,brain,alpha,quant,simulation,trading
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: python-dotenv>=0.19
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# brain-login-and-sim
+
+ไคลเอนต์ Python สำหรับ **WorldQuant BRAIN** — login (จัดการ biometric "Scan" + auto re-login),
+ส่ง simulation, รัน batch (สูงสุด 3 พร้อมกันตามลิมิต), และคัดเก็บ alpha ที่ผ่านเกณฑ์อัตโนมัติ
+
+## ติดตั้ง
+
+```bash
+pip install brain-login-and-sim
+```
+
+## ตั้งค่า credentials
+
+สร้างไฟล์ `.env` (ดู `.env.example`):
+
+```
+WQ_EMAIL=your-email@example.com
+WQ_PASSWORD=your-password
+# ส่งลิงก์ Scan เข้า Telegram (ทางเลือก แต่แนะนำ)
+TELEGRAM_BOT_TOKEN=123456789:AAH...
+TELEGRAM_CHAT_ID=123456789
+```
+
+## ใช้งาน
+
+```python
+from brain_login_and_sim import BrainClient, Simulator
+
+# login — ถ้าระบบขอ biometric Scan จะส่งลิงก์เข้า Telegram แล้วรอจนสแกนเสร็จ
+client = BrainClient(notify_telegram=True).authenticate()
+print(client.whoami()["id"])
+
+sim = Simulator(client)
+
+# ยิง 1 ตัว
+r = sim.simulate("ts_rank(close, 5)")
+print(r["simulation"]["status"], r["alpha"]["is"]["sharpe"])
+
+# รันหลายตัวจากไฟล์ JSONL คัดเก็บตัวที่ผ่านเกณฑ์อัตโนมัติ
+sim.simulate_batch("alphas.jsonl", save_promising=True)
+```
+
+## ฟีเจอร์หลัก
+
+- **Login + biometric Scan** — ส่งลิงก์สแกนเข้า Telegram/อีเมล แล้ว poll รอจนเสร็จ (ไม่ต้องเฝ้าจอ)
+- **Auto re-login** — เมื่อ session หมดอายุ (WorldQuant ให้ ~4 ชม.) เจอ 401 จะ login ใหม่แล้วลองซ้ำให้เอง
+- **คัดเก็บ alpha ดี** — เกณฑ์ `|Sharpe| ≥ 1` และ `|Fitness| ≥ 0.9` (ค่าสัมบูรณ์ จับ flip candidate ที่ negate แล้วดี)
+- **Batch** — รันสูงสุด 3 ตัวพร้อมกัน (ลิมิต WorldQuant), error รายตัวไม่ล้มทั้ง batch
+- **Resume** — จด checkpoint ด้วย hash รันไฟล์เดิมซ้ำจะข้ามตัวที่รันแล้ว รันต่อจากที่ค้าง
+- **Input ยืดหยุ่น** — list ของสูตร, ไฟล์ `.txt` (1 สูตร/บรรทัด), หรือ `.jsonl` ที่มี field `expression` (+`hash`)
+
+## รูปแบบ JSONL
+
+```jsonl
+{"hash": "f7b3...", "expression": "rank(reverse(ts_delta(anl4_cfo_median, 10)))", "status": "generated"}
+```
+
+ระบบดึง `expression` ไปรัน และถ้าผ่านเกณฑ์จะเก็บ `source_hash` ไว้อ้างกลับไฟล์ต้นฉบับใน `promising_alphas.jsonl`
+
+## API ย่อ
+
+`BrainClient`: `authenticate(on_biometric=None)`, `whoami()`, `get(path)`, `post(path)`, `auto_relogin`
+
+`Simulator(client)`: `simulate(...)`, `simulate_batch(...)`, `is_promising(...)`, `save_if_promising(...)`,
+`load_promising(path)`, `get_operators()`, `get_data_fields(...)`, `get_alpha(id)`
+
+## ทดสอบ
+
+```bash
+python tests/test_full_loop.py   # mock API ไม่ต้องต่อเน็ต/รหัสผ่าน
+```
+
+## License
+
+MIT

brain_login_and_sim-0.1.0/README.md

@@ -0,0 +1,75 @@
+# brain-login-and-sim
+
+ไคลเอนต์ Python สำหรับ **WorldQuant BRAIN** — login (จัดการ biometric "Scan" + auto re-login),
+ส่ง simulation, รัน batch (สูงสุด 3 พร้อมกันตามลิมิต), และคัดเก็บ alpha ที่ผ่านเกณฑ์อัตโนมัติ
+
+## ติดตั้ง
+
+```bash
+pip install brain-login-and-sim
+```
+
+## ตั้งค่า credentials
+
+สร้างไฟล์ `.env` (ดู `.env.example`):
+
+```
+WQ_EMAIL=your-email@example.com
+WQ_PASSWORD=your-password
+# ส่งลิงก์ Scan เข้า Telegram (ทางเลือก แต่แนะนำ)
+TELEGRAM_BOT_TOKEN=123456789:AAH...
+TELEGRAM_CHAT_ID=123456789
+```
+
+## ใช้งาน
+
+```python
+from brain_login_and_sim import BrainClient, Simulator
+
+# login — ถ้าระบบขอ biometric Scan จะส่งลิงก์เข้า Telegram แล้วรอจนสแกนเสร็จ
+client = BrainClient(notify_telegram=True).authenticate()
+print(client.whoami()["id"])
+
+sim = Simulator(client)
+
+# ยิง 1 ตัว
+r = sim.simulate("ts_rank(close, 5)")
+print(r["simulation"]["status"], r["alpha"]["is"]["sharpe"])
+
+# รันหลายตัวจากไฟล์ JSONL คัดเก็บตัวที่ผ่านเกณฑ์อัตโนมัติ
+sim.simulate_batch("alphas.jsonl", save_promising=True)
+```
+
+## ฟีเจอร์หลัก
+
+- **Login + biometric Scan** — ส่งลิงก์สแกนเข้า Telegram/อีเมล แล้ว poll รอจนเสร็จ (ไม่ต้องเฝ้าจอ)
+- **Auto re-login** — เมื่อ session หมดอายุ (WorldQuant ให้ ~4 ชม.) เจอ 401 จะ login ใหม่แล้วลองซ้ำให้เอง
+- **คัดเก็บ alpha ดี** — เกณฑ์ `|Sharpe| ≥ 1` และ `|Fitness| ≥ 0.9` (ค่าสัมบูรณ์ จับ flip candidate ที่ negate แล้วดี)
+- **Batch** — รันสูงสุด 3 ตัวพร้อมกัน (ลิมิต WorldQuant), error รายตัวไม่ล้มทั้ง batch
+- **Resume** — จด checkpoint ด้วย hash รันไฟล์เดิมซ้ำจะข้ามตัวที่รันแล้ว รันต่อจากที่ค้าง
+- **Input ยืดหยุ่น** — list ของสูตร, ไฟล์ `.txt` (1 สูตร/บรรทัด), หรือ `.jsonl` ที่มี field `expression` (+`hash`)
+
+## รูปแบบ JSONL
+
+```jsonl
+{"hash": "f7b3...", "expression": "rank(reverse(ts_delta(anl4_cfo_median, 10)))", "status": "generated"}
+```
+
+ระบบดึง `expression` ไปรัน และถ้าผ่านเกณฑ์จะเก็บ `source_hash` ไว้อ้างกลับไฟล์ต้นฉบับใน `promising_alphas.jsonl`
+
+## API ย่อ
+
+`BrainClient`: `authenticate(on_biometric=None)`, `whoami()`, `get(path)`, `post(path)`, `auto_relogin`
+
+`Simulator(client)`: `simulate(...)`, `simulate_batch(...)`, `is_promising(...)`, `save_if_promising(...)`,
+`load_promising(path)`, `get_operators()`, `get_data_fields(...)`, `get_alpha(id)`
+
+## ทดสอบ
+
+```bash
+python tests/test_full_loop.py   # mock API ไม่ต้องต่อเน็ต/รหัสผ่าน
+```
+
+## License
+
+MIT

brain_login_and_sim-0.1.0/pyproject.toml

@@ -0,0 +1,35 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "brain-login-and-sim"
+version = "0.1.0"
+description = "WorldQuant BRAIN client — login (biometric Scan + auto re-login), simulation, batch run, and auto-keeping promising alphas"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Tanakrit", email = "9tanakrit.work@gmail.com" }]
+keywords = ["worldquant", "brain", "alpha", "quant", "simulation", "trading"]
+dependencies = [
+    "requests>=2.28",
+    "python-dotenv>=0.19",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Topic :: Office/Business :: Financial :: Investment",
+]
+
+[project.optional-dependencies]
+dev = ["build", "twine", "pytest"]
+
+[project.urls]
+Homepage = "https://github.com/Tanakrit/brain-login-and-sim"
+Issues = "https://github.com/Tanakrit/brain-login-and-sim/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

brain_login_and_sim-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

brain_login_and_sim-0.1.0/src/brain_login_and_sim/__init__.py

@@ -0,0 +1,33 @@
+"""
+brain_login_and_sim
+====================
+ไคลเอนต์ WorldQuant BRAIN — login (จัดการ biometric Scan + auto re-login),
+ส่ง simulation, รัน batch (สูงสุด 3 พร้อมกัน), คัดเก็บ alpha ที่ผ่านเกณฑ์อัตโนมัติ
+และ resume ได้
+
+ใช้งานสั้น ๆ:
+    from brain_login_and_sim import BrainClient, Simulator
+
+    client = BrainClient(notify_telegram=True).authenticate()
+    sim = Simulator(client)
+    sim.simulate_batch("alphas.jsonl", save_promising=True)
+"""
+
+from .auth import (
+    BrainClient,
+    BrainAuthError,
+    send_biometric_email,
+    send_biometric_telegram,
+)
+from .simulation import Simulator
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "BrainClient",
+    "BrainAuthError",
+    "Simulator",
+    "send_biometric_email",
+    "send_biometric_telegram",
+    "__version__",
+]

brain_login_and_sim-0.1.0/src/brain_login_and_sim/auth.py

@@ -0,0 +1,257 @@
+"""
+auth.py — ระบบ login เข้า WorldQuant BRAIN
+
+- login ด้วย HTTP Basic Auth ที่ POST /authentication
+- จัดการขั้นตอน biometric "Scan" (Persona): ส่งลิงก์เข้า Telegram/อีเมล แล้ว poll รอ
+- auto re-login เมื่อ session หมดอายุ (WorldQuant ให้ ~4 ชม.): เจอ 401 -> login ใหม่ -> retry
+- อ่าน credential จาก .env (WQ_EMAIL/WQ_PASSWORD), จาก argument, หรือไฟล์ JSON
+"""
+from __future__ import annotations
+
+import json
+import os
+import smtplib
+import ssl
+import threading
+import time
+from email.message import EmailMessage
+from pathlib import Path
+from urllib.parse import urljoin
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+try:
+    from dotenv import load_dotenv
+    # อ่าน .env ที่อยู่ข้างไฟล์นี้ก่อน แล้วค่อยลอง cwd (ไม่ทับค่าที่โหลดแล้ว)
+    load_dotenv(Path(__file__).with_name(".env"))
+    load_dotenv()
+except ImportError:
+    pass
+
+API_BASE = "https://api.worldquantbrain.com"
+
+
+class BrainAuthError(Exception):
+    """ยกขึ้นเมื่อ authenticate ไม่สำเร็จ"""
+
+
+def send_biometric_email(scan_url, to_addr=None, smtp_host=None, smtp_port=None,
+                         smtp_user=None, smtp_password=None):
+    """ส่งลิงก์ Scan ไปอีเมล (อ่านค่า SMTP_* / WQ_NOTIFY_EMAIL จาก env ได้)"""
+    host = smtp_host or os.environ.get("SMTP_HOST", "smtp.gmail.com")
+    port = int(smtp_port or os.environ.get("SMTP_PORT", 587))
+    user = smtp_user or os.environ.get("SMTP_USER")
+    pw = smtp_password or os.environ.get("SMTP_PASSWORD")
+    to_addr = to_addr or os.environ.get("WQ_NOTIFY_EMAIL") or user
+    if not (user and pw and to_addr):
+        raise BrainAuthError(
+            "ส่งอีเมลไม่ได้ — ต้องตั้ง SMTP_USER, SMTP_PASSWORD (App Password), WQ_NOTIFY_EMAIL")
+    msg = EmailMessage()
+    msg["Subject"] = "WorldQuant BRAIN — ลิงก์ยืนยันตัวตน (Scan)"
+    msg["From"] = user
+    msg["To"] = to_addr
+    msg.set_content(
+        "เปิดลิงก์นี้บนมือถือแล้วสแกนให้เสร็จ:\n\n"
+        f"{scan_url}\n\nเมื่อสแกนเสร็จ โปรแกรมจะตรวจพบและทำงานต่อให้อัตโนมัติ")
+    ctx = ssl.create_default_context()
+    if port == 465:
+        with smtplib.SMTP_SSL(host, port, context=ctx) as s:
+            s.login(user, pw)
+            s.send_message(msg)
+    else:
+        with smtplib.SMTP(host, port) as s:
+            s.starttls(context=ctx)
+            s.login(user, pw)
+            s.send_message(msg)
+
+
+def send_biometric_telegram(scan_url, bot_token=None, chat_id=None):
+    """ส่งลิงก์ Scan ผ่าน Telegram bot (อ่าน TELEGRAM_BOT_TOKEN/TELEGRAM_CHAT_ID จาก env)"""
+    token = bot_token or os.environ.get("TELEGRAM_BOT_TOKEN")
+    chat = chat_id or os.environ.get("TELEGRAM_CHAT_ID")
+    if not (token and chat):
+        raise BrainAuthError(
+            "ส่ง Telegram ไม่ได้ — ต้องตั้ง TELEGRAM_BOT_TOKEN และ TELEGRAM_CHAT_ID")
+    text = ("WorldQuant BRAIN ขอยืนยันตัวตน (ขั้นตอน Scan)\n\n"
+            "เปิดลิงก์นี้บนมือถือแล้วสแกนให้เสร็จ:\n"
+            f"{scan_url}\n\nเมื่อสแกนเสร็จ โปรแกรมจะตรวจพบและทำงานต่อให้อัตโนมัติ")
+    r = requests.post(
+        f"https://api.telegram.org/bot{token}/sendMessage",
+        json={"chat_id": chat, "text": text, "disable_web_page_preview": False},
+        timeout=15)
+    if not r.ok:
+        raise BrainAuthError(f"ส่ง Telegram ไม่สำเร็จ: HTTP {r.status_code} — {r.text[:200]}")
+
+
+class BrainClient:
+    def __init__(self, email=None, password=None, credentials_file=None,
+                 api_base=API_BASE, notify_email=False, notify_telegram=False,
+                 poll_interval=5.0, biometric_timeout=600.0):
+        """
+        หา credential ตามลำดับ:
+          1. argument email/password
+          2. env WQ_EMAIL / WQ_PASSWORD (มาจาก .env ผ่าน python-dotenv)
+          3. ไฟล์ JSON ที่ระบุใน credentials_file หรือ env WQ_CREDENTIALS_FILE
+        """
+        self.api_base = api_base.rstrip("/")
+        self.session = requests.Session()
+        self.session.headers.update({"User-Agent": "brain-login-and-sim/0.1"})
+        self._email, self._password = self._resolve_credentials(
+            email, password, credentials_file)
+        self.user_id = None
+        self.notify_email = notify_email
+        self.notify_telegram = notify_telegram
+        self.poll_interval = poll_interval
+        self.biometric_timeout = biometric_timeout
+        # auto re-login เมื่อ session หมดอายุ (~4 ชม.)
+        self.auto_relogin = True
+        self._auth_lock = threading.Lock()
+        self._last_auth = 0.0
+        self._on_biometric = None
+
+    # -- credentials --------------------------------------------------- #
+    @staticmethod
+    def _resolve_credentials(email, password, credentials_file):
+        if email and password:
+            return email, password
+        env_email = os.environ.get("WQ_EMAIL")
+        env_pw = os.environ.get("WQ_PASSWORD")
+        if env_email and env_pw:
+            return env_email, env_pw
+        path = credentials_file or os.environ.get("WQ_CREDENTIALS_FILE")
+        if path and Path(path).exists():
+            data = json.loads(Path(path).read_text(encoding="utf-8"))
+            if data.get("email") and data.get("password"):
+                return data["email"], data["password"]
+        raise BrainAuthError(
+            "ไม่พบ credentials — แนะนำตั้ง WQ_EMAIL/WQ_PASSWORD ในไฟล์ .env (ดู .env.example) "
+            "| หรือส่ง email/password เข้า BrainClient ตรง ๆ | หรือใช้ไฟล์ JSON ผ่าน "
+            "WQ_CREDENTIALS_FILE. ถ้าตั้งใน .env แล้วยังไม่เจอ เช็กว่าติดตั้ง python-dotenv แล้ว")
+
+    # -- authentication ------------------------------------------------ #
+    def authenticate(self, on_biometric=None):
+        """login เข้า BRAIN; on_biometric=callback(url) เพื่อจัดการ Scan เอง"""
+        self._on_biometric = on_biometric
+        url = f"{self.api_base}/authentication"
+        r = self.session.post(url, auth=HTTPBasicAuth(self._email, self._password))
+        if r.status_code in (200, 201):
+            self._capture_user(r)
+            return self
+        if r.status_code == requests.codes.unauthorized:
+            www = r.headers.get("WWW-Authenticate", "").lower()
+            location = r.headers.get("Location")
+            if "persona" in www or "biometric" in www or location:
+                return self._handle_biometric(r, on_biometric)
+            raise BrainAuthError(
+                f"login ไม่สำเร็จ (401) — ตรวจ email/password. response: {r.text[:200]}")
+        raise BrainAuthError(f"login ไม่สำเร็จ: HTTP {r.status_code} — {r.text[:200]}")
+
+    def _handle_biometric(self, resp, on_biometric):
+        location = resp.headers.get("Location")
+        if not location:
+            try:
+                inquiry = resp.json().get("inquiry")
+            except Exception:
+                inquiry = None
+            location = (f"/authentication/persona?inquiry-id={inquiry}"
+                        if inquiry else "/authentication/persona")
+        bio_url = urljoin(resp.url, location)
+
+        if on_biometric is not None:
+            on_biometric(bio_url)
+            return self._wait_for_biometric(bio_url)
+
+        notified = False
+        if self.notify_telegram:
+            try:
+                send_biometric_telegram(bio_url)
+                dest = os.environ.get("TELEGRAM_CHAT_ID")
+                print(f"\nส่งลิงก์ Scan ทาง Telegram แล้ว (chat {dest}) — สแกนผ่านมือถือได้เลย")
+                notified = True
+            except Exception as e:
+                print(f"ส่ง Telegram ไม่สำเร็จ ({e}) — ใช้ลิงก์ด้านล่างแทน")
+        if self.notify_email:
+            try:
+                send_biometric_email(bio_url)
+                print("ส่งลิงก์ Scan ไปอีเมลแล้ว — สแกนผ่านมือถือได้เลย")
+                notified = True
+            except Exception as e:
+                print(f"ส่งอีเมลไม่สำเร็จ ({e}) — ใช้ลิงก์ด้านล่างแทน")
+
+        print("\nต้องยืนยันตัวตนด้วย biometric (ขั้นตอน Scan) เปิดลิงก์นี้แล้วสแกน:")
+        print(f"  {bio_url}\n")
+        if notified:
+            print(f"กำลังรอการสแกน... (เช็กทุก {self.poll_interval:.0f} วิ)")
+            return self._wait_for_biometric(bio_url, poll=True)
+        input("ทำ Scan เสร็จแล้วกด Enter เพื่อทำต่อ...")
+        return self._wait_for_biometric(bio_url)
+
+    def _wait_for_biometric(self, bio_url, poll=False):
+        deadline = time.time() + self.biometric_timeout
+        while True:
+            done = self.session.post(bio_url)
+            if done.status_code in (200, 201):
+                self._capture_user(done)
+                return self
+            recheck = self.session.post(
+                f"{self.api_base}/authentication",
+                auth=HTTPBasicAuth(self._email, self._password))
+            if recheck.status_code in (200, 201):
+                self._capture_user(recheck)
+                return self
+            if not poll or time.time() >= deadline:
+                raise BrainAuthError(
+                    f"ยืนยัน biometric ไม่สำเร็จ (persona HTTP {done.status_code})")
+            time.sleep(self.poll_interval)
+
+    def _capture_user(self, resp):
+        self._last_auth = time.time()
+        try:
+            data = resp.json()
+            self.user_id = (data.get("user") or {}).get("id") or data.get("id")
+        except Exception:
+            self.user_id = None
+
+    @property
+    def is_authenticated(self):
+        return len(self.session.cookies) > 0
+
+    # -- request helpers (auto re-login) ------------------------------- #
+    def get(self, path, **kwargs):
+        u = self._url(path)
+        return self._with_relogin(lambda: self.session.get(u, **kwargs), u)
+
+    def post(self, path, **kwargs):
+        u = self._url(path)
+        return self._with_relogin(lambda: self.session.post(u, **kwargs), u)
+
+    def _url(self, path):
+        if path.startswith("http"):
+            return path
+        return f"{self.api_base}/{path.lstrip('/')}"
+
+    @staticmethod
+    def _is_auth_url(url):
+        u = url.split("?")[0].rstrip("/")
+        return u.endswith("/authentication") or "/persona" in url
+
+    def _relogin_if_stale(self):
+        with self._auth_lock:
+            if time.time() - self._last_auth < 15:
+                return   # thread อื่นเพิ่ง re-login ไปแล้ว
+            print("session หมดอายุ — กำลัง login ใหม่อัตโนมัติ ...")
+            self.authenticate(on_biometric=self._on_biometric)
+
+    def _with_relogin(self, call, url):
+        """เรียก call(); ถ้าได้ 401 และไม่ใช่ endpoint login -> re-login แล้วลองซ้ำ 1 ครั้ง"""
+        resp = call()
+        if (getattr(resp, "status_code", None) == 401
+                and self.auto_relogin and not self._is_auth_url(url)):
+            self._relogin_if_stale()
+            resp = call()
+        return resp
+
+    def whoami(self):
+        """ข้อมูลผู้ใช้ปัจจุบัน (ยืนยันว่า session ใช้งานได้)"""
+        return self.get("/users/self").json()

brain_login_and_sim-0.1.0/src/brain_login_and_sim/simulation.py

@@ -0,0 +1,350 @@
+"""
+simulation.py — ส่ง simulation + คัดเก็บ alpha ที่ผ่านเกณฑ์
+
+Simulator รับ BrainClient ที่ login แล้ว (จาก auth.py) มาใช้ session ร่วมกัน
+  - simulate()        : ยิง 1 ตัว, poll จนเสร็จ, ดึง metric จาก /alphas
+  - simulate_batch()  : รันหลายตัว (สูงสุด 3 พร้อมกันตามลิมิต WorldQuant),
+                        คัดเก็บอัตโนมัติ, resume (ข้ามตัวที่รันแล้ว), error รายตัวไม่ล้ม batch
+  - is_promising()    : เกณฑ์ |Sharpe|>=1 และ |Fitness|>=0.9 (จับ flip candidate ด้วย)
+"""
+from __future__ import annotations
+
+import json
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+
+# WorldQuant จำกัด simulation ที่รันพร้อมกันได้สูงสุด 3 ตัว/บัญชี
+MAX_CONCURRENT = 3
+
+
+class Simulator:
+    """ห่อ BrainClient ที่ login แล้ว เพื่อเรียก endpoint ฝั่ง simulation/data"""
+
+    MIN_SHARPE = 1.0
+    MIN_FITNESS = 0.9
+
+    DEFAULT_SETTINGS = {
+        "instrumentType": "EQUITY", "region": "USA", "universe": "TOP3000",
+        "delay": 1, "decay": 0, "neutralization": "INDUSTRY", "truncation": 0.08,
+        "pasteurization": "ON", "testPeriod": "P0Y0M", "unitHandling": "VERIFY",
+        "nanHandling": "OFF", "language": "FASTEXPR", "visualization": False,
+    }
+
+    def __init__(self, client):
+        self.client = client
+        self._save_lock = threading.Lock()
+        self._print_lock = threading.Lock()
+
+    # -- ข้อมูลประกอบ -------------------------------------------------- #
+    def get_operators(self):
+        return self.client.get("/operators").json()
+
+    def get_data_fields(self, region="USA", delay=1, universe="TOP3000",
+                        instrument_type="EQUITY"):
+        return self.client.get("/data-fields", params={
+            "instrumentType": instrument_type, "region": region,
+            "delay": delay, "universe": universe}).json()
+
+    def get_alpha(self, alpha_id):
+        """รายละเอียด alpha รวม metric in-sample (`is`) / out-of-sample (`os`)"""
+        return self.client.get(f"/alphas/{alpha_id}").json()
+
+    # -- คัดกรอง + เก็บ ------------------------------------------------ #
+    @staticmethod
+    def is_promising(alpha_detail, min_sharpe=MIN_SHARPE, min_fitness=MIN_FITNESS,
+                     include_inverse=True):
+        """
+        ผ่านเกณฑ์เมื่อ (in-sample):
+          include_inverse=True (ดีฟอลต์): |sharpe|>=min_sharpe และ |fitness|>=min_fitness
+            -> จับทั้งตัวบวกแรง และตัวลบแรง (พลิกเครื่องหมายสูตรแล้วดี)
+          include_inverse=False: เฉพาะตัวบวก
+        """
+        stats = (alpha_detail or {}).get("is") or {}
+        sharpe = stats.get("sharpe")
+        fitness = stats.get("fitness")
+        if sharpe is None or fitness is None:
+            return False
+        if include_inverse:
+            return abs(sharpe) >= min_sharpe and abs(fitness) >= min_fitness
+        return sharpe >= min_sharpe and fitness >= min_fitness
+
+    @staticmethod
+    def _flatten(alpha_detail, source=None):
+        a = alpha_detail or {}
+        is_ = a.get("is") or {}
+        settings = a.get("settings") or {}
+        code = ((a.get("regular") or {}).get("code")
+                if isinstance(a.get("regular"), dict) else a.get("regular"))
+        sharpe = is_.get("sharpe")
+        inverse = sharpe is not None and sharpe < 0   # flip candidate
+        return {
+            "savedAt": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+            "source_hash": (source or {}).get("hash"),
+            "alpha_id": a.get("id"), "regular": code, "inverse": inverse,
+            "regular_inverse": f"-({code})" if (inverse and code) else None,
+            "sharpe": sharpe, "fitness": is_.get("fitness"),
+            "turnover": is_.get("turnover"), "returns": is_.get("returns"),
+            "drawdown": is_.get("drawdown"), "margin": is_.get("margin"),
+            "region": settings.get("region"), "universe": settings.get("universe"),
+            "delay": settings.get("delay"),
+            "neutralization": settings.get("neutralization"),
+            "dateCreated": a.get("dateCreated"),
+        }
+
+    def save_if_promising(self, alpha_detail, path="promising_alphas.jsonl",
+                          min_sharpe=MIN_SHARPE, min_fitness=MIN_FITNESS,
+                          include_inverse=True, source=None):
+        """เก็บ alpha ลงไฟล์ JSONL ถ้าผ่านเกณฑ์ (กันบันทึกซ้ำ alpha id เดิม)"""
+        if not self.is_promising(alpha_detail, min_sharpe, min_fitness, include_inverse):
+            return False
+        record = self._flatten(alpha_detail, source)
+        p = Path(path)
+        with self._save_lock:
+            if p.exists() and record.get("alpha_id"):
+                for line in p.read_text(encoding="utf-8").splitlines():
+                    try:
+                        if json.loads(line).get("alpha_id") == record["alpha_id"]:
+                            return False
+                    except Exception:
+                        continue
+            with p.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(record, ensure_ascii=False) + "\n")
+        return True
+
+    @staticmethod
+    def load_promising(path="promising_alphas.jsonl"):
+        p = Path(path)
+        if not p.exists():
+            return []
+        out = []
+        for line in p.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if line:
+                try:
+                    out.append(json.loads(line))
+                except Exception:
+                    pass
+        return out
+
+    # -- simulate ------------------------------------------------------ #
+    def simulate(self, regular, settings=None, timeout=600.0, with_metrics=True,
+                 save_promising=False, save_path="promising_alphas.jsonl",
+                 min_sharpe=MIN_SHARPE, min_fitness=MIN_FITNESS,
+                 include_inverse=True, source=None):
+        """
+        ยิง simulation 1 ตัวแล้วรอจนเสร็จ
+        flow: POST /simulations -> poll GET /simulations/{id} (Retry-After ระหว่างรัน)
+              -> GET /alphas/{id} เอา metric
+        คืน: {simulation, alpha_id, alpha, promising, saved}
+        """
+        payload = {"type": "REGULAR",
+                   "settings": settings or dict(self.DEFAULT_SETTINGS),
+                   "regular": regular}
+        r = self.client.post("/simulations", json=payload)
+        r.raise_for_status()
+        progress_url = r.headers.get("Location")
+        if not progress_url:
+            return {"simulation": r.json(), "alpha_id": None, "alpha": None,
+                    "promising": False, "saved": False}
+
+        deadline = time.time() + timeout
+        sim = {}
+        while time.time() < deadline:
+            pr = self.client.get(progress_url)   # ผ่าน auto-relogin ถ้า session หมด
+            pr.raise_for_status()
+            retry_after = pr.headers.get("Retry-After")
+            if retry_after:                       # ยังรันอยู่
+                time.sleep(float(retry_after))
+                continue
+            sim = pr.json()
+            break
+        else:
+            raise TimeoutError("simulation ใช้เวลานานเกินกำหนด")
+
+        result = {"simulation": sim, "alpha_id": sim.get("alpha"),
+                  "alpha": None, "promising": False, "saved": False}
+        if sim.get("status") and sim["status"] != "COMPLETE":
+            return result
+        if (with_metrics or save_promising) and result["alpha_id"]:
+            result["alpha"] = self.get_alpha(result["alpha_id"])
+            result["promising"] = self.is_promising(
+                result["alpha"], min_sharpe, min_fitness, include_inverse)
+            if save_promising and result["promising"]:
+                result["saved"] = self.save_if_promising(
+                    result["alpha"], save_path, min_sharpe, min_fitness,
+                    include_inverse, source=source)
+        return result
+
+    # -- batch + resume ------------------------------------------------ #
+    def simulate_batch(self, expressions, settings=None, save_promising=True,
+                       save_path="promising_alphas.jsonl", min_sharpe=MIN_SHARPE,
+                       min_fitness=MIN_FITNESS, include_inverse=True, timeout=600.0,
+                       max_concurrent=MAX_CONCURRENT, stop_on_error=False,
+                       skip_processed=True, processed_path="processed.jsonl",
+                       on_progress=None):
+        """
+        รันหลาย alpha (สูงสุด max_concurrent พร้อมกัน, บีบไม่เกิน MAX_CONCURRENT=3)
+        expressions: path ไฟล์ (.txt/.jsonl) | list ของ string | list ของ dict {expression, hash}
+        skip_processed: resume — ข้ามตัวที่เคยรันแล้ว (key=hash) จด checkpoint ลง processed_path
+        คืน: list ของ record ต่อ alpha (เรียงตามลำดับ input)
+        """
+        if isinstance(expressions, str):
+            items = self.load_alpha_items(expressions)
+        else:
+            items = []
+            for x in expressions:
+                if isinstance(x, dict):
+                    expr = x.get("expression") or x.get("regular")
+                    if expr:
+                        items.append({"expression": expr, "source": x})
+                else:
+                    items.append({"expression": x, "source": None})
+        total = len(items)
+        workers = max(1, min(max_concurrent, MAX_CONCURRENT, total or 1))
+
+        def item_key(item):
+            return (item.get("source") or {}).get("hash") or item["expression"]
+
+        processed = self._load_processed_keys(processed_path) if skip_processed else set()
+
+        def run_one(item):
+            expr = item["expression"]
+            source = item.get("source")
+            rec = {"regular": expr, "source_hash": (source or {}).get("hash"),
+                   "ok": False, "status": None, "alpha_id": None, "sharpe": None,
+                   "fitness": None, "promising": False, "saved": False,
+                   "skipped": False, "error": None}
+            try:
+                r = self.simulate(expr, settings=settings, timeout=timeout,
+                                  with_metrics=True, save_promising=save_promising,
+                                  save_path=save_path, min_sharpe=min_sharpe,
+                                  min_fitness=min_fitness,
+                                  include_inverse=include_inverse, source=source)
+                is_ = (r["alpha"] or {}).get("is", {})
+                rec.update(ok=True, status=r["simulation"].get("status"),
+                           alpha_id=r["alpha_id"], sharpe=is_.get("sharpe"),
+                           fitness=is_.get("fitness"), promising=r["promising"],
+                           saved=r["saved"])
+            except Exception as e:
+                rec["error"] = str(e)
+            if skip_processed:
+                self._append_processed(processed_path, item_key(item), rec)
+            return rec
+
+        def report(done, rec):
+            if on_progress:
+                on_progress(rec)
+                return
+            with self._print_lock:
+                if rec["skipped"]:
+                    print(f"[{done}/{total}] {rec['regular'][:45]:45} skip (เคยรันแล้ว)")
+                elif rec["ok"]:
+                    flip = " (flip ต้อง negate)" if (
+                        rec["sharpe"] is not None and rec["sharpe"] < 0) else ""
+                    tag = ("เก็บแล้ว" + flip if rec["saved"]
+                           else "ผ่านเกณฑ์" + flip if rec["promising"] else "ไม่ผ่าน")
+                    print(f"[{done}/{total}] {rec['regular'][:45]:45} "
+                          f"sharpe={rec['sharpe']} fitness={rec['fitness']}  {tag}")
+                else:
+                    print(f"[{done}/{total}] {rec['regular'][:45]:45} ERROR: {rec['error']}")
+
+        def skipped_rec(item):
+            src = item.get("source") or {}
+            return {"regular": item["expression"], "source_hash": src.get("hash"),
+                    "ok": False, "status": None, "alpha_id": None, "sharpe": None,
+                    "fitness": None, "promising": False, "saved": False,
+                    "skipped": True, "error": None}
+
+        results = [None] * total
+        to_run = []
+        for i, item in enumerate(items):
+            if skip_processed and item_key(item) in processed:
+                results[i] = skipped_rec(item)
+            else:
+                to_run.append((i, item))
+        n_skip = total - len(to_run)
+
+        if workers == 1:
+            done = n_skip
+            for i, item in to_run:
+                rec = run_one(item)
+                results[i] = rec
+                done += 1
+                report(done, rec)
+                if rec["error"] and stop_on_error:
+                    break
+        else:
+            with ThreadPoolExecutor(max_workers=workers) as ex:
+                fut_to_idx = {ex.submit(run_one, item): i for i, item in to_run}
+                done = n_skip
+                for fut in as_completed(fut_to_idx):
+                    idx = fut_to_idx[fut]
+                    rec = fut.result()
+                    results[idx] = rec
+                    done += 1
+                    report(done, rec)
+
+        results = [r for r in results if r is not None]
+        ok = sum(r["ok"] for r in results)
+        promising = sum(r["promising"] for r in results)
+        saved = sum(r["saved"] for r in results)
+        print(f"\nสรุป: รันใหม่สำเร็จ {ok} | ข้าม {n_skip} | ผ่านเกณฑ์ {promising} | "
+              f"เก็บใหม่ {saved} -> {save_path}")
+        return results
+
+    # -- checkpoint (resume) ------------------------------------------- #
+    @staticmethod
+    def _load_processed_keys(path):
+        p = Path(path)
+        if not p.exists():
+            return set()
+        keys = set()
+        for line in p.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                k = json.loads(line).get("key")
+                if k is not None:
+                    keys.add(k)
+            except Exception:
+                continue
+        return keys
+
+    def _append_processed(self, path, key, rec):
+        entry = {"key": key, "source_hash": rec.get("source_hash"),
+                 "alpha_id": rec.get("alpha_id"), "regular": rec.get("regular"),
+                 "ok": rec.get("ok"), "status": rec.get("status"),
+                 "promising": rec.get("promising"), "error": rec.get("error"),
+                 "at": datetime.now(timezone.utc).isoformat(timespec="seconds")}
+        with self._save_lock:
+            with Path(path).open("a", encoding="utf-8") as f:
+                f.write(json.dumps(entry, ensure_ascii=False) + "\n")
+
+    # -- โหลดรายการ alpha จากไฟล์ -------------------------------------- #
+    @staticmethod
+    def load_alpha_items(path):
+        """อ่าน list ของ {expression, source} จากไฟล์ — รองรับ JSONL และข้อความล้วน"""
+        items = []
+        for raw in Path(path).read_text(encoding="utf-8").splitlines():
+            line = raw.strip()
+            if not line or line.startswith("#"):
+                continue
+            if line.startswith("{"):
+                try:
+                    obj = json.loads(line)
+                except Exception:
+                    continue
+                expr = obj.get("expression") or obj.get("regular")
+                if expr:
+                    items.append({"expression": expr, "source": obj})
+            else:
+                items.append({"expression": line, "source": None})
+        return items
+
+    @classmethod
+    def load_expressions(cls, path):
+        return [it["expression"] for it in cls.load_alpha_items(path)]

brain_login_and_sim-0.1.0/src/brain_login_and_sim.egg-info/PKG-INFO

@@ -0,0 +1,101 @@
+Metadata-Version: 2.4
+Name: brain-login-and-sim
+Version: 0.1.0
+Summary: WorldQuant BRAIN client — login (biometric Scan + auto re-login), simulation, batch run, and auto-keeping promising alphas
+Author-email: Tanakrit <9tanakrit.work@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Tanakrit/brain-login-and-sim
+Project-URL: Issues, https://github.com/Tanakrit/brain-login-and-sim/issues
+Keywords: worldquant,brain,alpha,quant,simulation,trading
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: python-dotenv>=0.19
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# brain-login-and-sim
+
+ไคลเอนต์ Python สำหรับ **WorldQuant BRAIN** — login (จัดการ biometric "Scan" + auto re-login),
+ส่ง simulation, รัน batch (สูงสุด 3 พร้อมกันตามลิมิต), และคัดเก็บ alpha ที่ผ่านเกณฑ์อัตโนมัติ
+
+## ติดตั้ง
+
+```bash
+pip install brain-login-and-sim
+```
+
+## ตั้งค่า credentials
+
+สร้างไฟล์ `.env` (ดู `.env.example`):
+
+```
+WQ_EMAIL=your-email@example.com
+WQ_PASSWORD=your-password
+# ส่งลิงก์ Scan เข้า Telegram (ทางเลือก แต่แนะนำ)
+TELEGRAM_BOT_TOKEN=123456789:AAH...
+TELEGRAM_CHAT_ID=123456789
+```
+
+## ใช้งาน
+
+```python
+from brain_login_and_sim import BrainClient, Simulator
+
+# login — ถ้าระบบขอ biometric Scan จะส่งลิงก์เข้า Telegram แล้วรอจนสแกนเสร็จ
+client = BrainClient(notify_telegram=True).authenticate()
+print(client.whoami()["id"])
+
+sim = Simulator(client)
+
+# ยิง 1 ตัว
+r = sim.simulate("ts_rank(close, 5)")
+print(r["simulation"]["status"], r["alpha"]["is"]["sharpe"])
+
+# รันหลายตัวจากไฟล์ JSONL คัดเก็บตัวที่ผ่านเกณฑ์อัตโนมัติ
+sim.simulate_batch("alphas.jsonl", save_promising=True)
+```
+
+## ฟีเจอร์หลัก
+
+- **Login + biometric Scan** — ส่งลิงก์สแกนเข้า Telegram/อีเมล แล้ว poll รอจนเสร็จ (ไม่ต้องเฝ้าจอ)
+- **Auto re-login** — เมื่อ session หมดอายุ (WorldQuant ให้ ~4 ชม.) เจอ 401 จะ login ใหม่แล้วลองซ้ำให้เอง
+- **คัดเก็บ alpha ดี** — เกณฑ์ `|Sharpe| ≥ 1` และ `|Fitness| ≥ 0.9` (ค่าสัมบูรณ์ จับ flip candidate ที่ negate แล้วดี)
+- **Batch** — รันสูงสุด 3 ตัวพร้อมกัน (ลิมิต WorldQuant), error รายตัวไม่ล้มทั้ง batch
+- **Resume** — จด checkpoint ด้วย hash รันไฟล์เดิมซ้ำจะข้ามตัวที่รันแล้ว รันต่อจากที่ค้าง
+- **Input ยืดหยุ่น** — list ของสูตร, ไฟล์ `.txt` (1 สูตร/บรรทัด), หรือ `.jsonl` ที่มี field `expression` (+`hash`)
+
+## รูปแบบ JSONL
+
+```jsonl
+{"hash": "f7b3...", "expression": "rank(reverse(ts_delta(anl4_cfo_median, 10)))", "status": "generated"}
+```
+
+ระบบดึง `expression` ไปรัน และถ้าผ่านเกณฑ์จะเก็บ `source_hash` ไว้อ้างกลับไฟล์ต้นฉบับใน `promising_alphas.jsonl`
+
+## API ย่อ
+
+`BrainClient`: `authenticate(on_biometric=None)`, `whoami()`, `get(path)`, `post(path)`, `auto_relogin`
+
+`Simulator(client)`: `simulate(...)`, `simulate_batch(...)`, `is_promising(...)`, `save_if_promising(...)`,
+`load_promising(path)`, `get_operators()`, `get_data_fields(...)`, `get_alpha(id)`
+
+## ทดสอบ
+
+```bash
+python tests/test_full_loop.py   # mock API ไม่ต้องต่อเน็ต/รหัสผ่าน
+```
+
+## License
+
+MIT

brain_login_and_sim-0.1.0/src/brain_login_and_sim.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/brain_login_and_sim/__init__.py
+src/brain_login_and_sim/auth.py
+src/brain_login_and_sim/simulation.py
+src/brain_login_and_sim.egg-info/PKG-INFO
+src/brain_login_and_sim.egg-info/SOURCES.txt
+src/brain_login_and_sim.egg-info/dependency_links.txt
+src/brain_login_and_sim.egg-info/requires.txt
+src/brain_login_and_sim.egg-info/top_level.txt
+tests/test_full_loop.py

brain_login_and_sim-0.1.0/src/brain_login_and_sim.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

brain_login_and_sim-0.1.0/src/brain_login_and_sim.egg-info/requires.txt

@@ -0,0 +1,7 @@
+requests>=2.28
+python-dotenv>=0.19
+
+[dev]
+build
+twine
+pytest

brain_login_and_sim-0.1.0/src/brain_login_and_sim.egg-info/top_level.txt

@@ -0,0 +1 @@
+brain_login_and_sim

brain_login_and_sim-0.1.0/tests/test_full_loop.py

@@ -0,0 +1,205 @@
+"""Full-loop test (mock API, no network/credentials).  Run: pytest -s  หรือ python tests/test_full_loop.py"""
+import json
+import sys
+import tempfile
+from pathlib import Path
+
+import requests
+
+from brain_login_and_sim import BrainClient, Simulator
+
+_p = 0
+_f = 0
+
+
+def check(name, cond):
+    global _p, _f
+    if cond:
+        _p += 1
+        print("  PASS", name)
+    else:
+        _f += 1
+        print("  FAIL", name, "<--")
+
+
+API = "https://api.worldquantbrain.com"
+METRICS = {
+    "rank(close - open)": (1.40, 0.95),
+    "-rank(returns)": (-1.80, -0.95),
+    "ts_rank(close, 5)": (0.50, 0.40),
+    "broken_expr(": None,
+}
+
+
+class FR:
+    def __init__(self, code=200, data=None, headers=None, url=API + "/authentication"):
+        self.status_code = code
+        self._d = data or {}
+        self.headers = headers or {}
+        self.text = json.dumps(self._d)
+        self.url = url
+
+    def json(self):
+        return self._d
+
+    @property
+    def ok(self):
+        return self.status_code < 400
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise requests.HTTPError(f"HTTP {self.status_code}")
+
+
+class FS:
+    def __init__(self, biometric=False):
+        self.headers = {}
+        self.cookies = []
+        self.biometric = biometric
+        self._bio = False
+        self._n = 0
+        self._se = {}
+        self._poll = {}
+        self.expired = False
+
+    def post(self, url, auth=None, json=None, **kw):
+        if url.endswith("/authentication"):
+            if self.biometric and not self._bio:
+                return FR(401, {}, {"WWW-Authenticate": "persona",
+                          "Location": "/authentication/persona?inquiry-id=X"},
+                          url=API + "/authentication")
+            self.expired = False
+            return FR(201, {"user": {"id": "U1"}})
+        if "/persona" in url:
+            self._bio = True
+            self.expired = False
+            return FR(201, {"user": {"id": "U1"}})
+        if url.endswith("/simulations"):
+            expr = (json or {}).get("regular")
+            if METRICS.get(expr, "x") is None:
+                return FR(400, {"error": "bad"})
+            self._n += 1
+            sid = f"SIM{self._n}"
+            self._se[sid] = expr
+            self._poll[sid] = 0
+            return FR(201, {}, {"Location": f"{API}/simulations/{sid}"})
+        return FR(404, {})
+
+    def get(self, url, params=None, **kw):
+        if self.expired:
+            return FR(401, {"error": "expired"})
+        if "/simulations/" in url:
+            sid = url.rsplit("/", 1)[-1]
+            self._poll[sid] += 1
+            if self._poll[sid] == 1:
+                return FR(200, {"progress": 0.5}, {"Retry-After": "0"})
+            expr = self._se[sid]
+            return FR(200, {"id": sid, "status": "COMPLETE", "alpha": f"ALPHA_{sid}",
+                      "regular": expr, "settings": {"region": "USA",
+                      "universe": "TOP3000", "delay": 1, "neutralization": "INDUSTRY"}})
+        if "/alphas/" in url:
+            aid = url.rsplit("/", 1)[-1]
+            sid = aid.replace("ALPHA_", "")
+            expr = self._se.get(sid)
+            sh, fi = METRICS[expr]
+            return FR(200, {"id": aid, "regular": expr,
+                      "settings": {"region": "USA", "universe": "TOP3000",
+                      "delay": 1, "neutralization": "INDUSTRY"},
+                      "is": {"sharpe": sh, "fitness": fi, "turnover": 0.3,
+                      "returns": 0.1, "drawdown": 0.2, "margin": 0.001}, "os": {}})
+        if url.endswith("/users/self"):
+            return FR(200, {"id": "U1"})
+        if url.endswith("/operators"):
+            return FR(200, [{"name": "rank"}, {"name": "ts_rank"}])
+        if "/data-fields" in url:
+            return FR(200, {"count": 2, "results": []})
+        return FR(404, {})
+
+
+def mk(biometric=False):
+    c = BrainClient(email="t@e.com", password="x")
+    c.session = FS(biometric=biometric)
+    return c
+
+
+def run():
+    print("=" * 50)
+    print("FULL-LOOP TEST")
+    print("=" * 50)
+
+    print("\n[1] login direct")
+    c = mk().authenticate()
+    check("returns client", isinstance(c, BrainClient))
+    check("uid U1", c.user_id == "U1")
+    check("whoami", c.whoami().get("id") == "U1")
+
+    print("\n[2] login biometric")
+    seen = {}
+    c = mk(biometric=True)
+    c.authenticate(on_biometric=lambda u: seen.update(u=u))
+    check("persona url", "/persona" in seen.get("u", ""))
+    check("login ok", c.user_id == "U1")
+
+    print("\n[3] single simulate")
+    sim = Simulator(mk().authenticate())
+    r = sim.simulate("rank(close - open)")
+    check("COMPLETE", r["simulation"]["status"] == "COMPLETE")
+    check("alpha_id", bool(r["alpha_id"]))
+    check("sharpe 1.4", r["alpha"]["is"]["sharpe"] == 1.40)
+    check("promising", r["promising"] is True)
+
+    print("\n[4] is_promising")
+    check("pos", Simulator.is_promising({"is": {"sharpe": 1.4, "fitness": 0.95}}))
+    check("neg abs", Simulator.is_promising({"is": {"sharpe": -1.8, "fitness": -0.95}}))
+    check("weak", Simulator.is_promising({"is": {"sharpe": 0.5, "fitness": 0.4}}) is False)
+    check("neg no-inv", Simulator.is_promising(
+        {"is": {"sharpe": -1.8, "fitness": -0.95}}, include_inverse=False) is False)
+
+    print("\n[5-7] batch + resume + inverse + error")
+    with tempfile.TemporaryDirectory() as d:
+        tmp = Path(d)
+        jl = tmp / "a.jsonl"
+        jl.write_text("\n".join(json.dumps(o) for o in [
+            {"hash": "H_pos", "expression": "rank(close - open)"},
+            {"hash": "H_neg", "expression": "-rank(returns)"},
+            {"hash": "H_weak", "expression": "ts_rank(close, 5)"},
+            {"hash": "H_err", "expression": "broken_expr("}]), encoding="utf-8")
+        sv = str(tmp / "p.jsonl")
+        pr = str(tmp / "proc.jsonl")
+        sim = Simulator(mk().authenticate())
+        r1 = sim.simulate_batch(str(jl), save_promising=True, save_path=sv,
+                                processed_path=pr, max_concurrent=3)
+        check("ran 4", len([x for x in r1 if not x["skipped"]]) == 4)
+        check("promising 2", sum(x["promising"] for x in r1) == 2)
+        check("saved 2", sum(x["saved"] for x in r1) == 2)
+        check("1 error", sum(1 for x in r1 if x["error"]) == 1)
+        saved = Simulator.load_promising(sv)
+        neg = next((s for s in saved if s["source_hash"] == "H_neg"), None)
+        check("inverse flag", neg and neg["inverse"] is True)
+        check("neg expr", "-(-rank(returns))" == (neg and neg["regular_inverse"]))
+        check("source_hash", any(s["source_hash"] == "H_pos" for s in saved))
+        r2 = sim.simulate_batch(str(jl), save_promising=True, save_path=sv,
+                                processed_path=pr, max_concurrent=3)
+        check("resume skip all", all(x["skipped"] for x in r2) and len(r2) == 4)
+        check("no dup save", len(Simulator.load_promising(sv)) == len(saved))
+
+    print("\n[8] auto re-login")
+    c = mk().authenticate()
+    c.session.expired = True
+    c._last_auth = 0
+    rr = c.get("/operators")
+    check("401 -> relogin -> 200", rr.status_code == 200)
+    check("usable again", c.session.expired is False)
+
+    print("\n" + "=" * 50)
+    print(f"RESULT: passed {_p} | failed {_f}")
+    print("=" * 50)
+    return _f
+
+
+def test_full_loop():
+    assert run() == 0
+
+
+if __name__ == "__main__":
+    sys.exit(1 if run() else 0)