Upload 3 files

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["python", "app.py"]

app.py

@@ -0,0 +1,342 @@
+import os
+import yfinance as yf
+import math
+import time
+import random
+import threading
+import requests
+from requests.adapters import HTTPAdapter
+from datetime import datetime, timezone
+from flask import Flask, jsonify, render_template_string, request
+from flask_cors import CORS
+from dotenv import load_dotenv
+
+load_dotenv()
+
+app = Flask(__name__)
+
+# ── Session com headers de browser para evitar rate limit ──
+def make_yf_session():
+    session = requests.Session()
+    session.headers.update({
+        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.5",
+        "Accept-Encoding": "gzip, deflate, br",
+        "Connection": "keep-alive",
+    })
+    adapter = HTTPAdapter(max_retries=2)
+    session.mount("https://", adapter)
+    return session
+CORS(app)
+
+assets_raw = os.getenv("ASSETS") or os.getenv("ASSET") or "MSFT,AAPL,TSLA"
+TICKERS = [t.strip().upper() for t in assets_raw.split(",") if t.strip()]
+RISK_FREE = 0.045
+SLEEP = 60
+TARGET_DAYS = [10, 15, 30, 60, 90, 120]
+DELTA_SELL_RANGE = (0.01, 0.65)
+DELTA_BUY_RANGE  = (0.01, 0.65)
+MAX_WIDTH = 14
+
+scan_state = {
+    "status": "idle",
+    "last_update": None,
+    "results": {},
+    "errors": [],
+    "tickers": TICKERS,
+}
+scan_lock = threading.Lock()
+
+def to_float_safe(x):
+    try:
+        if isinstance(x, (float, int)):
+            return float(x)
+        if hasattr(x, "values"):
+            return float(x.values[0])
+        return float(x)
+    except:
+        return 0.0
+
+def mid_or_last_safe(row):
+    try:
+        bid  = to_float_safe(row["bid"])
+        ask  = to_float_safe(row["ask"])
+        last = to_float_safe(row["lastPrice"])
+    except:
+        return 0.0
+    if bid > 0 and ask > 0:
+        return (bid + ask) / 2.0
+    if last > 0:
+        return last
+    if bid > 0:
+        return bid
+    return 0.0
+
+def N(x):
+    return 0.5 * (1 + math.erf(x / math.sqrt(2)))
+
+def d1(S, K, r, sigma, T):
+    return (math.log(S/K) + (r + 0.5*sigma**2)*T) / (sigma * math.sqrt(T))
+
+def d2(S, K, r, sigma, T):
+    return d1(S, K, r, sigma, T) - sigma * math.sqrt(T)
+
+def bs_call_price(S, K, r, sigma, T):
+    return S * N(d1(S, K, r, sigma, T)) - K * math.exp(-r*T) * N(d2(S, K, r, sigma, T))
+
+def bs_put_price(S, K, r, sigma, T):
+    return K * math.exp(-r*T) * N(-d2(S, K, r, sigma, T)) - S * N(-d1(S, K, r, sigma, T))
+
+def delta_call(S, K, r, sigma, T):
+    return N(d1(S, K, r, sigma, T))
+
+def delta_put(S, K, r, sigma, T):
+    return N(d1(S, K, r, sigma, T)) - 1
+
+def implied_volatility(option_price, S, K, r, T, option_type="call"):
+    sigma = 0.30
+    for _ in range(70):
+        if sigma <= 0:
+            sigma = 0.01
+        try:
+            model = bs_call_price(S, K, r, sigma, T) if option_type == "call" else bs_put_price(S, K, r, sigma, T)
+        except:
+            return sigma
+        d_1 = d1(S, K, r, sigma, T)
+        vega = S * math.sqrt(T) * (1/math.sqrt(2*math.pi)) * math.exp(-(d_1*d_1)/2)
+        diff = model - option_price
+        if abs(diff) < 1e-6 or vega < 1e-8:
+            return sigma
+        sigma -= diff / vega
+    return sigma
+
+def year_fraction_to_expiry(expiry_str):
+    dt = datetime.strptime(expiry_str, "%Y-%m-%d").replace(tzinfo=timezone.utc)
+    now = datetime.now(timezone.utc)
+    delta = dt - now
+    days = delta.days + delta.seconds / 86400
+    return max(days / 365, 1e-6), max(days, 0)
+
+def scan_ticker(TICKER):
+    result = {"ticker": TICKER, "price": None, "variations": {}, "structures": [], "error": None}
+    try:
+        session = make_yf_session()
+        tk = yf.Ticker(TICKER, session=session)
+        hist = tk.history(interval="1m", period="1d")
+        if hist.empty:
+            result["error"] = "Sem dados de preco (mercado fechado?)"
+            return result
+
+        S = float(hist["Close"].iloc[-1])
+        result["price"] = round(S, 4)
+
+        hist_daily = tk.history(interval="1d", period="90d")
+        today_date = hist_daily.index[-1].strftime("%Y-%m-%d") if len(hist_daily) else ""
+
+        for label, idx in [("1D", -2), ("5D", -6), ("15D", -15), ("30D", -31), ("60D", -60), ("90D", -90)]:
+            if len(hist_daily) >= abs(idx):
+                close = float(hist_daily["Close"].iloc[idx])
+                date  = hist_daily.index[idx].strftime("%Y-%m-%d")
+                pct   = ((S - close) / close) * 100
+                result["variations"][label] = {"pct": round(pct, 2), "from": date, "to": today_date}
+
+        expiries = tk.options
+        if not expiries:
+            result["error"] = "Sem opcoes disponiveis"
+            return result
+
+        exp_info = []
+        for e in expiries:
+            T_frac, days = year_fraction_to_expiry(e)
+            if days > 0:
+                exp_info.append((e, T_frac, days))
+
+        chosen = []
+        seen = set()
+        for target_days in TARGET_DAYS:
+            nearest = min(exp_info, key=lambda x: abs(x[2] - target_days))
+            if nearest[0] not in seen:
+                seen.add(nearest[0])
+                chosen.append(nearest)
+
+        for (exp_str, T_years, days_left) in chosen:
+            chain = tk.option_chain(exp_str)
+            for tipo in ["call", "put"]:
+                options = chain.calls if tipo == "call" else chain.puts
+                if options.empty:
+                    continue
+
+                best_structure = None
+                best_score = -999999
+
+                for _, sell in options.iterrows():
+                    K_s = float(sell["strike"])
+                    if tipo == "call" and K_s <= S:
+                        continue
+                    if tipo == "put" and K_s >= S:
+                        continue
+
+                    mid_s = mid_or_last_safe(sell)
+                    if mid_s <= 0:
+                        continue
+
+                    bid_s = to_float_safe(sell.get("bid", 0))
+                    ask_s = to_float_safe(sell.get("ask", 0))
+                    if bid_s <= 0 or ask_s <= 0:
+                        continue
+
+                    spread_s = ask_s - bid_s
+
+                    iv_s = implied_volatility(mid_s, S, K_s, RISK_FREE, T_years, tipo)
+                    d_s = abs(delta_call(S, K_s, RISK_FREE, iv_s, T_years) if tipo == "call"
+                              else delta_put(S, K_s, RISK_FREE, iv_s, T_years))
+
+                    if not (DELTA_SELL_RANGE[0] <= d_s <= DELTA_SELL_RANGE[1]):
+                        continue
+
+                    for _, buy in options.iterrows():
+                        K_b = float(buy["strike"])
+                        if tipo == "call" and K_b <= K_s:
+                            continue
+                        if tipo == "put" and K_b >= K_s:
+                            continue
+
+                        mid_b = mid_or_last_safe(buy)
+                        if mid_b <= 0:
+                            continue
+
+                        bid_b = to_float_safe(buy.get("bid", 0))
+                        ask_b = to_float_safe(buy.get("ask", 0))
+                        if bid_b <= 0 or ask_b <= 0:
+                            continue
+
+                        spread_b = ask_b - bid_b
+
+                        iv_b = implied_volatility(mid_b, S, K_b, RISK_FREE, T_years, tipo)
+                        d_b = abs(delta_call(S, K_b, RISK_FREE, iv_b, T_years) if tipo == "call"
+                                  else delta_put(S, K_b, RISK_FREE, iv_b, T_years))
+
+                        if not (DELTA_BUY_RANGE[0] <= d_b <= DELTA_BUY_RANGE[1]):
+                            continue
+
+                        credito = mid_s - (2 * mid_b)
+                        if credito <= 0.3:
+                            continue
+
+                        width = abs(K_b - K_s)
+                        if width > MAX_WIDTH:
+                            continue
+
+                        max_loss = width - credito
+                        score = -max_loss if max_loss > 0 else -999
+                        spread_total = spread_s + 2 * spread_b
+
+                        if score > best_score:
+                            best_score = score
+                            be = (K_b + max_loss) if tipo == "call" else (K_b - max_loss)
+                            best_structure = {
+                                "type": tipo,
+                                "expiry": exp_str,
+                                "days_left": round(days_left, 1),
+                                "strike_sell": K_s,
+                                "mid_sell": round(mid_s, 3),
+                                "delta_sell": round(d_s, 3),
+                                "strike_buy": K_b,
+                                "mid_buy": round(mid_b, 3),
+                                "delta_buy": round(d_b, 3),
+                                "credit": round(credito, 3),
+                                "max_loss": round(max_loss, 3),
+                                "spread_total": round(spread_total, 3),
+                                "be_point": round(be, 2),
+                                "pct_move": round((be - S) / S * 100, 2),
+                                "iv_sell": round(iv_s * 100, 1),
+                                "iv_buy": round(iv_b * 100, 1),
+                            }
+
+                if best_structure:
+                    result["structures"].append(best_structure)
+
+    except Exception as e:
+        result["error"] = str(e)
+
+    return result
+
+def run_scan(tickers):
+    with scan_lock:
+        scan_state["status"] = "scanning"
+        scan_state["errors"] = []
+        scan_state["results"] = {}
+
+    results = {}
+    errors = []
+    for i, ticker in enumerate(tickers):
+        # Delay entre tickers para evitar rate limit (2-4s aleatório)
+        if i > 0:
+            time.sleep(random.uniform(2.5, 4.5))
+
+        # Retry automático em caso de rate limit
+        for attempt in range(3):
+            res = scan_ticker(ticker)
+            if res.get("error") and "Too Many Requests" in str(res.get("error", "")):
+                wait = 10 + attempt * 10  # 10s, 20s, 30s
+                time.sleep(wait)
+                continue
+            break
+
+        results[ticker] = res
+        # Atualiza resultados parciais para o frontend ir mostrando
+        with scan_lock:
+            scan_state["results"] = dict(results)
+        if res.get("error"):
+            errors.append(f"{ticker}: {res['error']}")
+
+    with scan_lock:
+        scan_state["status"] = "done"
+        scan_state["results"] = results
+        scan_state["errors"] = errors
+        scan_state["last_update"] = datetime.now(timezone.utc).isoformat()
+
+@app.route("/")
+def index():
+    with open("templates/index.html", encoding="utf-8") as f:
+        return render_template_string(f.read())
+
+@app.route("/api/status")
+def api_status():
+    with scan_lock:
+        return jsonify({
+            "status": scan_state["status"],
+            "last_update": scan_state["last_update"],
+            "tickers": scan_state["tickers"],
+            "errors": scan_state["errors"],
+        })
+
+@app.route("/api/results")
+def api_results():
+    with scan_lock:
+        return jsonify(scan_state["results"])
+
+@app.route("/api/scan", methods=["POST"])
+def api_scan():
+    data = request.get_json(silent=True) or {}
+    tickers_raw = data.get("tickers", "")
+    tickers = [t.strip().upper() for t in tickers_raw.split(",") if t.strip()] if tickers_raw else TICKERS
+    with scan_lock:
+        if scan_state["status"] == "scanning":
+            return jsonify({"error": "Scan ja em curso"}), 409
+        scan_state["tickers"] = tickers
+    threading.Thread(target=run_scan, args=(tickers,), daemon=True).start()
+    return jsonify({"ok": True, "tickers": tickers})
+
+@app.route("/api/config")
+def api_config():
+    return jsonify({
+        "tickers": TICKERS,
+        "risk_free": RISK_FREE,
+        "target_days": TARGET_DAYS,
+        "max_width": MAX_WIDTH,
+    })
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=False)

requirements.txt

@@ -0,0 +1,6 @@
+flask==3.0.3
+flask-cors==4.0.1
+yfinance==0.2.54
+pandas==2.2.3
+python-dotenv==1.0.1
+requests==2.32.3