Yahoo Finance

#!/usr/bin/env python3
"""
Batch fetch de Yahoo Finance con token bucket + ThreadPoolExecutor.

Respeta el rate limit de Yahoo (~2 req/s sostenidos) usando un token bucket
thread-safe. Quote batching: todos los tickers en 1 sola request.

Uso:
    # Test seguro (3 tickers, solo chart, 2 req/s)
    py scripts/batch_fetch.py --tickers AAPL,MSFT,NVDA --chart --rate 2.0

    # Batch completo (quote en 1 request + charts en paralelo)
    py scripts/batch_fetch.py --tickers AAPL,MSFT,NVDA,GOOGL,META,AMZN,TSLA --all --rate 2.0 --workers 4

    # Solo quotes (siempre 1 request, imposible rate-limit)
    py scripts/batch_fetch.py --tickers AAPL,MSFT,NVDA,GOOGL --quote

    # Todo con output a archivo
    py scripts/batch_fetch.py --tickers AAPL,MSFT --all --rate 2.0 --output data/batch.json
"""

import argparse
import functools
import json
import os
import sys
import threading
import time as _time
from concurrent.futures import ThreadPoolExecutor, as_completed

from curl_cffi import requests

BASE = "https://query1.finance.yahoo.com"
FALLBACK = "https://query2.finance.yahoo.com"

# ---------------------------------------------------------------------------
# Token Bucket - thread-safe, con burst
# ---------------------------------------------------------------------------

class TokenBucket:
    """Token bucket rate limiter. Thread-safe.

    Por defecto: 2 tokens/s, max 5 tokens (burst). Esto significa que
    pueden dispararse hasta 5 requests instantaneas, luego se estabiliza
    a 2 req/s. Yahoo tolera esto sin problemas (yfinance no tiene
    rate limiter y manda N requests simultaneas sin throttling).
    """
    def __init__(self, rate: float = 2.0, burst: int = 5):
        self.rate = rate
        self.burst = burst
        self.tokens = float(burst)
        self.last = _time.monotonic()
        self._lock = threading.Lock()

    def acquire(self, block: bool = True):
        """Adquiere 1 token. Bloquea hasta que haya disponible."""
        if block:
            while True:
                needed = self._try_consume()
                if needed <= 0:
                    return
                _time.sleep(min(needed, 0.1))

    def _try_consume(self) -> float:
        """Intenta consumir 1 token. Retorna segundos hasta que haya disponible."""
        with self._lock:
            now = _time.monotonic()
            elapsed = now - self.last
            self.tokens = min(self.burst, self.tokens + elapsed * self.rate)
            self.last = now
            if self.tokens >= 1.0:
                self.tokens -= 1.0
                return 0.0
            return (1.0 - self.tokens) / self.rate

# ---------------------------------------------------------------------------
# Sesion + crumb
# ---------------------------------------------------------------------------

class SessionPool:
    """Pool de sesiones curl_cffi con crumb. Thread-safe."""
    def __init__(self, size: int = 2):
        self._sessions = [self._new_session() for _ in range(size)]
        self._counter = 0
        self._lock = threading.Lock()

    @staticmethod
    def _new_session():
        s = requests.Session(impersonate="chrome")
        try:
            s.get("https://fc.yahoo.com", timeout=10)
            crumb = s.get(f"{BASE}/v1/test/getcrumb", timeout=10).text.strip()
            s.params = {"crumb": crumb}
        except Exception:
            s.params = {}
        return s

    def get(self):
        with self._lock:
            s = self._sessions[self._counter % len(self._sessions)]
            self._counter += 1
            return s

# ---------------------------------------------------------------------------
# Endpoints
# ---------------------------------------------------------------------------

def fetch_quote(session, tickers):
    """v7/finance/quote - batch de todos los tickers en 1 request."""
    symbols = ",".join(tickers)
    url = f"{BASE}/v7/finance/quote"
    for attempt in range(3):
        resp = session.get(url, params={"symbols": symbols}, timeout=15)
        if resp.status_code == 429:
            _time.sleep(2 ** attempt)
            continue
        resp.raise_for_status()
        return resp.json()
    raise Exception(f"Rate limited after 3 retries: quote batch")


def fetch_chart(session, ticker, range_="1y", interval="1d", events="div,splits"):
    """v8/finance/chart - OHLCV historico. No requiere crumb."""
    params = {"range": range_, "interval": interval, "events": events}
    for attempt in range(3):
        resp = session.get(f"{BASE}/v8/finance/chart/{ticker}",
                           params=params, timeout=15)
        if resp.status_code == 429:
            _time.sleep(2 ** attempt)
            continue
        resp.raise_for_status()
        return resp.json()
    raise Exception(f"Rate limited after 3 retries: chart {ticker}")


def fetch_quote_summary(session, ticker, modules):
    """v10/finance/quoteSummary - fundamentos."""
    url = f"{BASE}/v10/finance/quoteSummary/{ticker}"
    params = {"modules": ",".join(modules)}
    for attempt in range(3):
        resp = session.get(url, params=params, timeout=15)
        if resp.status_code == 429:
            _time.sleep(2 ** attempt)
            continue
        resp.raise_for_status()
        return resp.json()
    raise Exception(f"Rate limited after 3 retries: summary {ticker}")


def fetch_options(session, ticker):
    """v7/finance/options - cadena de opciones."""
    for attempt in range(3):
        resp = session.get(f"{BASE}/v7/finance/options/{ticker}", timeout=15)
        if resp.status_code == 429:
            _time.sleep(2 ** attempt)
            continue
        resp.raise_for_status()
        return resp.json()
    raise Exception(f"Rate limited after 3 retries: options {ticker}")


def fetch_search(ticker):
    """v1/finance/search - busqueda + noticias. Sin crumb."""
    url = f"{BASE}/v1/finance/search"
    params = {"q": ticker, "quotesCount": 3, "newsCount": 5}
    resp = requests.get(url, params=params, impersonate="chrome", timeout=15)
    resp.raise_for_status()
    return resp.json()

# ---------------------------------------------------------------------------
# Worker - procesa un ticker individual (chart, summary, options)
# ---------------------------------------------------------------------------

CORE_MODULES = [
    "assetProfile", "financialData", "defaultKeyStatistics",
    "incomeStatementHistory", "balanceSheetHistory", "cashflowStatementHistory",
    "earnings", "earningsTrend", "recommendationTrend",
    "calendarEvents", "price", "summaryDetail"
]

def worker(ticker, args, bucket, session_pool):
    """Procesa todos los endpoints requeridos para UN ticker."""
    result = {"ticker": ticker, "ok": {}, "error": {}}
    session = session_pool.get()

    if args.chart:
        try:
            bucket.acquire()
            data = fetch_chart(session, ticker, args.range, args.interval)
            n_bars = len(data.get("chart", {}).get("result", [{}])[0].get("timestamp", []))
            result["ok"]["chart"] = {"bars": n_bars}
        except Exception as e:
            result["error"]["chart"] = str(e)

    if args.fundamentals:
        try:
            bucket.acquire()
            data = fetch_quote_summary(session, ticker, args.modules or CORE_MODULES)
            result["ok"]["fundamentals"] = True
        except Exception as e:
            result["error"]["fundamentals"] = str(e)

    if args.options:
        try:
            bucket.acquire()
            data = fetch_options(session, ticker)
            opt_res = data.get("optionChain", {}).get("result", [{}])[0]
            n_exp = len(opt_res.get("expirationDates", []))
            result["ok"]["options"] = {"expirations": n_exp}
        except Exception as e:
            result["error"]["options"] = str(e)

    if args.search:
        try:
            data = fetch_search(ticker)
            n_news = len(data.get("news", []))
            result["ok"]["search"] = {"news": n_news}
        except Exception as e:
            result["error"]["search"] = str(e)

    return result

# ---------------------------------------------------------------------------
# Main
# ---------------------------------------------------------------------------

def main():
    parser = argparse.ArgumentParser(
        description="Batch fetch Yahoo Finance con rate limiting + paralelismo."
    )
    parser.add_argument("--tickers", "-t", required=True,
                        help="Tickers separados por coma, ej: AAPL,MSFT,NVDA")
    parser.add_argument("--output", "-o", default=None,
                        help="Archivo JSON de salida")
    parser.add_argument("--rate", type=float, default=2.0,
                        help="Tokens/segundo del rate limiter (default: 2.0)")
    parser.add_argument("--burst", type=int, default=5,
                        help="Max tokens acumulables (default: 5)")
    parser.add_argument("--workers", "-w", type=int, default=4,
                        help="Max workers en ThreadPoolExecutor (default: 4)")
    parser.add_argument("--range", default="1y",
                        help="Rango del chart: 1d..max (default: 1y)")
    parser.add_argument("--interval", default="1d",
                        help="Intervalo del chart (default: 1d)")
    parser.add_argument("--modules", default=None,
                        help="Modulos de quoteSummary separados por coma")

    # Que endpoints ejecutar
    parser.add_argument("--all", action="store_true",
                        help="Todos los endpoints")
    parser.add_argument("--chart", action="store_true",
                        help="Incluir historico OHLCV")
    parser.add_argument("--quote", action="store_true",
                        help="Incluir quote batch (todos los tickers en 1 request)")
    parser.add_argument("--fundamentals", action="store_true",
                        help="Incluir fundamentals (1 req por ticker)")
    parser.add_argument("--options", action="store_true",
                        help="Incluir opciones (1 req por ticker)")
    parser.add_argument("--search", action="store_true",
                        help="Incluir busqueda + noticias (1 req por ticker)")

    args = parser.parse_args()

    if args.all:
        args.chart = True
        args.quote = True
        args.fundamentals = True
        args.options = True
        args.search = True

    tickers = [t.strip().upper() for t in args.tickers.split(",")]

    if args.modules:
        args.modules = [m.strip() for m in args.modules.split(",")]
    else:
        args.modules = CORE_MODULES

    bucket = TokenBucket(rate=args.rate, burst=args.burst)
    session_pool = SessionPool(size=min(args.workers, 4))

    output = {
        "meta": {
            "tickers": tickers,
            "rate": args.rate,
            "burst": args.burst,
            "workers": args.workers,
            "timestamp": _time.strftime("%Y-%m-%dT%H:%M:%SZ", _time.gmtime()),
            "note": "Datos obtenidos de la API no oficial de Yahoo Finance."
        },
        "quote": None,
        "tickers": {},
        "summary": {
            "total": len(tickers),
            "ok": 0,
            "errors": 0
        }
    }

    # --- Fase 1: Quote batch (1 request para TODOS los tickers) ---
    if args.quote:
        print(f">> Quote batch ({len(tickers)} tickers)...")
        try:
            session = session_pool.get()
            data = fetch_quote(session, tickers)
            output["quote"] = data
            results = data.get("quoteResponse", {}).get("result", [])
            for q in results:
                sym = q.get("symbol", "?")
                p = q.get("regularMarketPrice", "N/A")
                chg = q.get("regularMarketChangePercent", 0)
                print(f"   {sym}: ${p} ({chg:+.2f}%)")
            output["summary"]["quotes_ok"] = len(results)
        except Exception as e:
            print(f"   ERR quote batch: {e}")
            output["summary"]["quote_error"] = str(e)

    # --- Fase 2: Paralelo por ticker (chart, fundamentals, options) ---
    endpoints_after_quote = sum([args.chart, args.fundamentals, args.options, args.search])
    if endpoints_after_quote == 0:
        pass  # solo quote
    else:
        print(f">> Procesando {len(tickers)} tickers con {args.workers} workers, rate={args.rate} req/s...")
        with ThreadPoolExecutor(max_workers=args.workers) as pool:
            futures = {
                pool.submit(worker, t, args, bucket, session_pool): t
                for t in tickers
            }
            for future in as_completed(futures):
                t = futures[future]
                try:
                    result = future.result()
                    output["tickers"][t] = result
                    n_ok = len(result["ok"])
                    n_err = len(result["error"])
                    if n_err > 0:
                        output["summary"]["errors"] += 1
                        print(f"   {t}: {n_ok} ok, {n_err} errors")
                    else:
                        output["summary"]["ok"] += 1
                        print(f"   {t}: {n_ok} ok")
                except Exception as e:
                    output["tickers"][t] = {"ticker": t, "error": str(e)}
                    output["summary"]["errors"] += 1
                    print(f"   {t}: EXCEPTION {e}")

    # --- Output ---
    outpath = args.output or f"batch_{len(tickers)}t.json"
    with open(outpath, "w", encoding="utf-8") as f:
        json.dump(output, f, indent=2, default=str)
    size_kb = os.path.getsize(outpath) / 1024
    print(f"\nGuardado: {outpath} ({size_kb:.0f} KB)")
    print(f"Tickers: {output['summary']['ok']} ok / {output['summary']['errors']} errors")


if __name__ == "__main__":
    main()

"""
Descargar datos históricos OHLCV de Yahoo Finance usando la API v8/chart directa.
Sin dependencia de yfinance — solo requests.

Uso:
    python download_historical.py --tickers AAPL,MSFT --range 1y --interval 1d --output data/
    python download_historical.py --tickers AAPL --period1 1672531200 --period2 1704067200 --interval 1d
"""

import argparse
import csv
import os
import sys
import time
from datetime import datetime, timezone

import requests


BASE_URL = "https://query1.finance.yahoo.com/v8/finance/chart"
HEADERS = {
    "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"
}


def fetch_chart(ticker, period1=None, period2=None, range_=None, interval="1d", events="div,splits"):
    """Fetch raw JSON from v8/chart endpoint."""
    params = {"interval": interval}
    if range_:
        params["range"] = range_
    else:
        if period1:
            params["period1"] = period1
        if period2:
            params["period2"] = period2 or int(time.time())
    if events:
        params["events"] = events

    url = f"{BASE_URL}/{ticker}"
    resp = requests.get(url, params=params, headers=HEADERS)
    resp.raise_for_status()
    return resp.json()


def parse_chart(data, ticker):
    """Parse JSON de v8/chart a lista de dicts planos."""
    try:
        result = data["chart"]["result"][0]
    except (KeyError, IndexError, TypeError):
        print(f"  ⚠ Sin datos para {ticker}")
        return []

    timestamps = result.get("timestamp", [])
    quotes = result.get("indicators", {}).get("quote", [{}])[0]
    adjclose = result.get("indicators", {}).get("adjclose", [{}])[0]
    events = result.get("events", {})

    rows = []
    for i, ts in enumerate(timestamps):
        row = {
            "ticker": ticker,
            "date": datetime.fromtimestamp(ts, tz=timezone.utc).strftime("%Y-%m-%d"),
            "open": _get(quotes, "open", i),
            "high": _get(quotes, "high", i),
            "low": _get(quotes, "low", i),
            "close": _get(quotes, "close", i),
            "volume": _get(quotes, "volume", i),
            "adjclose": _get(adjclose, "adjclose", i),
        }
        rows.append(row)

    # Agregar dividendos como filas separadas
    if events and "dividends" in events:
        for ts_str, div in events["dividends"].items():
            rows.append({
                "ticker": ticker,
                "date": datetime.fromtimestamp(int(ts_str), tz=timezone.utc).strftime("%Y-%m-%d"),
                "dividend": div.get("amount"),
            })

    return rows


def _get(obj, key, idx):
    """Get value safely from a list at index."""
    try:
        val = obj[key][idx]
        return val if val is not None else ""
    except (IndexError, KeyError, TypeError):
        return ""


def save_csv(rows, output_path, ticker):
    """Save rows to CSV file."""
    if not rows:
        print(f"  ⚠ No hay datos para guardar para {ticker}")
        return

    filename = os.path.join(output_path, f"{ticker}_historical.csv")
    fieldnames = rows[0].keys()
    with open(filename, "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=fieldnames)
        writer.writeheader()
        writer.writerows(rows)
    print(f"  ✓ {filename} — {len(rows)} filas")


def main():
    parser = argparse.ArgumentParser(description="Descargar históricos OHLCV de Yahoo Finance")
    parser.add_argument("--tickers", required=True, help="Tickers separados por coma, ej: AAPL,MSFT")
    parser.add_argument("--range", default="1mo", help="Rango: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, max")
    parser.add_argument("--interval", default="1d", help="Intervalo: 1m, 5m, 15m, 1h, 1d, 1wk, 1mo")
    parser.add_argument("--period1", type=int, help="Timestamp Unix inicio (alternativo a --range)")
    parser.add_argument("--period2", type=int, help="Timestamp Unix fin (alternativo a --range)")
    parser.add_argument("--output", default="data", help="Directorio de salida")
    parser.add_argument("--delay", type=float, default=0.5, help="Delay entre requests (segundos)")

    args = parser.parse_args()
    os.makedirs(args.output, exist_ok=True)

    tickers = [t.strip().upper() for t in args.tickers.split(",")]

    for ticker in tickers:
        print(f"→ Descargando {ticker} ...")
        try:
            data = fetch_chart(
                ticker,
                period1=args.period1,
                period2=args.period2,
                range_=args.range,
                interval=args.interval,
            )
            rows = parse_chart(data, ticker)
            save_csv(rows, args.output, ticker)
        except requests.exceptions.RequestException as e:
            print(f"  ✗ Error en {ticker}: {e}")
        except Exception as e:
            print(f"  ✗ Error inesperado en {ticker}: {e}")

        time.sleep(args.delay)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Fetch integral de Yahoo Finance: histórico, quote, fundamentals, opciones, búsqueda y noticias.
Usa requests HTTP directos — sin yfinance ni wrappers.

Uso:
    # Todo lo disponible para un ticker
    python fetch_all.py --ticker AAPL --all

    # Solo histórico con rango personalizado
    python fetch_all.py --ticker MSFT --chart --range 5y --interval 1wk

    # Histórico por timestamps Unix
    python fetch_all.py --ticker TSLA --chart --period1 1609459200 --period2 1704067200

    # Solo quote + fundamentals con módulos específicos
    python fetch_all.py --ticker NVDA --quote --fundamentals --modules financialData,assetProfile

    # Todo + opciones para varios tickers (uno por vez)
    python fetch_all.py --ticker AAPL --all --output data/aapl.json
"""

import argparse
import json
import os
import sys
import time
from datetime import datetime, timezone

import requests

BASE = "https://query1.finance.yahoo.com"
HEADERS = {
    "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"
}

# =========================================================================
# Sesión con autenticación
# =========================================================================

def yahoo_session():
    """Crea una requests.Session con cookie A3 y crumb para endpoints auth."""
    s = requests.Session()
    s.headers.update(HEADERS)
    s.get("https://fc.yahoo.com", timeout=10)
    crumb = s.get(f"{BASE}/v1/test/getcrumb", timeout=10).text.strip()
    s.params = {"crumb": crumb}
    return s


# =========================================================================
# Endpoints
# =========================================================================

def fetch_chart(ticker, range_="1mo", interval="1d", events="div,splits",
                period1=None, period2=None, include_prepost=False):
    """
    v8/finance/chart — Históricos OHLCV.
    No requiere autenticación, sólo User-Agent.
    """
    params = {"interval": interval}
    if range_:
        params["range"] = range_
    if period1:
        params["period1"] = period1
        if period2:
            params["period2"] = period2
        else:
            params["period2"] = int(time.time())
    if events:
        params["events"] = events
    if include_prepost:
        params["includePrePost"] = "true"

    r = requests.get(f"{BASE}/v8/finance/chart/{ticker}",
                     params=params, headers=HEADERS, timeout=15)
    r.raise_for_status()
    return r.json()


def fetch_quote(session, ticker):
    """
    v7/finance/quote — Precio en tiempo real y métricas básicas.
    Requiere crumb.
    """
    r = session.get(f"{BASE}/v7/finance/quote",
                    params={"symbols": ticker}, timeout=15)
    r.raise_for_status()
    return r.json()


def fetch_quote_summary(session, ticker, modules):
    """
    v10/finance/quoteSummary/{ticker} — Fundamentos y datos profundos.
    Requiere crumb.
    """
    r = session.get(
        f"{BASE}/v10/finance/quoteSummary/{ticker}",
        params={"modules": ",".join(modules)},
        timeout=15
    )
    r.raise_for_status()
    return r.json()


def fetch_options(session, ticker, expiration_date=None):
    """
    v7/finance/options/{ticker} — Cadena de opciones.
    Requiere crumb.
    expiration_date: timestamp Unix opcional para una fecha específica.
    """
    url = f"{BASE}/v7/finance/options/{ticker}"
    params = {}
    if expiration_date:
        params["date"] = expiration_date
    r = session.get(url, params=params, timeout=15)
    r.raise_for_status()
    return r.json()


def fetch_search(ticker, quotes_count=3, news_count=5):
    """
    v1/finance/search — Búsqueda + noticias.
    No requiere autenticación.
    """
    r = requests.get(
        f"{BASE}/v1/finance/search",
        params={"q": ticker, "quotesCount": quotes_count, "newsCount": news_count},
        headers=HEADERS, timeout=15
    )
    r.raise_for_status()
    return r.json()


def fetch_recommendations(session, ticker):
    """
    v6/finance/recommendationsbysymbol/{ticker} — Recomendaciones de analistas.
    Requiere crumb.
    """
    r = session.get(f"{BASE}/v6/finance/recommendationsbysymbol/{ticker}", timeout=15)
    r.raise_for_status()
    return r.json()


def fetch_trending(session=None, country="US"):
    """
    v1/finance/trending/{country} — Trending symbols.
    No requiere autenticación.
    """
    r = requests.get(f"{BASE}/v1/finance/trending/{country}",
                     headers=HEADERS, timeout=15)
    r.raise_for_status()
    return r.json()


# =========================================================================
# Módulos disponibles para quoteSummary
# =========================================================================

ALL_MODULES = [
    "assetProfile",              # Perfil de la empresa completo
    "summaryProfile",            # Resumen del perfil
    "financialData",             # Métricas financieras clave
    "defaultKeyStatistics",      # Estadísticas clave (beta, shares, etc.)
    "incomeStatementHistory",    # Estado de resultados histórico
    "incomeStatementHistoryQuarterly",  # Estado de resultados trimestral
    "balanceSheetHistory",       # Balance general histórico
    "balanceSheetHistoryQuarterly",     # Balance general trimestral
    "cashflowStatementHistory",  # Flujo de caja histórico
    "cashflowStatementHistoryQuarterly", # Flujo de caja trimestral
    "earnings",                  # Ganancias históricas
    "earningsHistory",           # Historia de earnings vs estimados
    "earningsTrend",             # Tendencia de earnings
    "recommendationTrend",       # Recomendaciones de analistas
    "upgradeDowngradeHistory",   # Historia de upgrades/downgrades
    "insiderTransactions",       # Transacciones de insider
    "insiderHolders",            # Tenedores insider
    "institutionOwnership",      # Tenencia institucional
    "fundOwnership",             # Tenencia de fondos mutuos
    "majorDirectHolders",        # Mayores tenedores directos
    "majorHoldersBreakdown",     # Desglose de tenedores (%, institutional, insider)
    "secFilings",                # SEC filings
    "calendarEvents",            # Próximos eventos
    "price",                     # Información detallada de precio
    "quoteType",                 # Tipo de instrumento
    "summaryDetail",             # Detalle resumido
    "symbol",                    # Símbolo
    "topHoldings",               # Top holdings (ETFs)
    "fundProfile",               # Perfil del fondo (ETFs)
    "indexTrend",                # Tendencia del índice
    "sectorTrend",               # Tendencia del sector
    "industryTrend",             # Tendencia de la industria
    "netSharePurchaseActivity",  # Actividad neta de recompra
    "esgScore",                  # Score ESG (si disponible)
]

# Módulos esenciales para un fetch rápido
CORE_MODULES = [
    "assetProfile", "financialData", "defaultKeyStatistics",
    "incomeStatementHistory", "balanceSheetHistory", "cashflowStatementHistory",
    "earnings", "earningsTrend", "recommendationTrend",
    "calendarEvents", "price", "summaryDetail"
]


# =========================================================================
# Main
# =========================================================================

def main():
    parser = argparse.ArgumentParser(
        description="Fetch integral de Yahoo Finance. Usa requests HTTP directos (sin yfinance)."
    )
    parser.add_argument("--ticker", "-t", required=True,
                        help="Ticker a consultar (ej: AAPL, MSFT, GGAL)")
    parser.add_argument("--output", "-o", default=None,
                        help="Archivo JSON de salida (default: <ticker>_fetch.json)")
    parser.add_argument("--delay", type=float, default=0.5,
                        help="Delay entre requests en segundos (default: 0.5)")

    # Qué endpoints ejecutar
    parser.add_argument("--all", action="store_true",
                        help="Fetch de todo lo disponible (chart + quote + all fundamentals + options + search)")
    parser.add_argument("--chart", action="store_true",
                        help="Incluir histórico OHLCV")
    parser.add_argument("--quote", action="store_true",
                        help="Incluir quote en tiempo real")
    parser.add_argument("--fundamentals", action="store_true",
                        help="Incluir fundamentals (quoteSummary)")
    parser.add_argument("--options", action="store_true",
                        help="Incluir cadena de opciones")
    parser.add_argument("--search", action="store_true",
                        help="Incluir búsqueda y noticias")
    parser.add_argument("--recommendations", action="store_true",
                        help="Incluir recomendaciones de analistas")
    parser.add_argument("--trending", action="store_true",
                        help="Incluir trending symbols")

    # Parámetros para chart
    parser.add_argument("--range", default="1y",
                        help="Rango del histórico: 1d, 5d, 1mo, 3mo, 6mo, 1y, 2y, 5y, 10y, ytd, max")
    parser.add_argument("--interval", default="1d",
                        help="Intervalo: 1m, 2m, 5m, 15m, 30m, 60m, 1h, 1d, 1wk, 1mo")
    parser.add_argument("--period1", type=int, default=None,
                        help="Timestamp Unix inicio (alternativo a --range)")
    parser.add_argument("--period2", type=int, default=None,
                        help="Timestamp Unix fin (alternativo a --range)")

    # Parámetros para fundamentals
    parser.add_argument("--modules", default=None,
                        help="Módulos de quoteSummary separados por coma (default: core)")
    parser.add_argument("--all-modules", action="store_true",
                        help="Fetch de TODOS los módulos de quoteSummary (~33 módulos)")

    # Consola
    parser.add_argument("--quiet", "-q", action="store_true",
                        help="Sin salida en consola (sólo errores)")

    args = parser.parse_args()

    # Si --all, habilitar todo
    if args.all:
        args.chart = True
        args.quote = True
        args.fundamentals = True
        args.options = True
        args.search = True
        args.recommendations = True

    ticker = args.ticker.upper()
    results = {
        "ticker": ticker,
        "timestamp": datetime.now(timezone.utc).isoformat(),
        "endpoints": {},
        "meta": {
            "note": "Datos obtenidos de la API no oficial de Yahoo Finance. Sin garantías."
        }
    }
    errors = []
    log = [] if args.quiet else print

    def log_msg(msg):
        if not args.quiet:
            print(msg)

    session = None  # lazy init

    # ------ CHART ------
    if args.chart:
        log_msg(f">> Chart ({args.range}, {args.interval})...")
        try:
            data = fetch_chart(ticker, range_=args.range, interval=args.interval,
                               period1=args.period1, period2=args.period2)
            results["endpoints"]["chart"] = data
            n = len(data.get("chart", {}).get("result", [{}])[0].get("timestamp", []))
            log_msg(f"  OK {n} bars")
        except Exception as e:
            errors.append(f"chart: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ------ QUOTE ------
    if args.quote:
        log_msg(">> Quote...")
        try:
            if session is None:
                session = yahoo_session()
            data = fetch_quote(session, ticker)
            results["endpoints"]["quote"] = data
            q = data.get("quoteResponse", {}).get("result", [{}])[0]
            p = q.get("regularMarketPrice", "N/A")
            chg = q.get("regularMarketChangePercent", 0)
            log_msg(f"  OK Price: ${p} ({chg:.2f}%)")
        except Exception as e:
            errors.append(f"quote: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ------ FUNDAMENTALS ------
    if args.fundamentals:
        if args.all_modules:
            modules = ALL_MODULES
        elif args.modules:
            modules = [m.strip() for m in args.modules.split(",")]
        else:
            modules = CORE_MODULES
        log_msg(f">> Fundamentals ({len(modules)} módulos)...")
        try:
            if session is None:
                session = yahoo_session()
            data = fetch_quote_summary(session, ticker, modules)
            results["endpoints"]["quoteSummary"] = data
            fin = data.get("quoteSummary", {}).get("result", [{}])[0]
            profile = fin.get("assetProfile", {})
            summary = profile.get("longBusinessSummary", "N/A")[:100]
            log_msg(f"  OK Company: {summary}...")
            fd = fin.get("financialData", {})
            log_msg(f"    Revenue: {fd.get('totalRevenue',{}).get('fmt','N/A')}  "
                    f"EBITDA: {fd.get('ebitda',{}).get('fmt','N/A')}  "
                    f"PE: {fd.get('trailingPE',{}).get('fmt','N/A')}")
        except Exception as e:
            errors.append(f"fundamentals: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ------ OPTIONS ------
    if args.options:
        log_msg(">> Options...")
        try:
            if session is None:
                session = yahoo_session()
            data = fetch_options(session, ticker)
            results["endpoints"]["options"] = data
            opt_res = data.get("optionChain", {}).get("result", [{}])[0]
            exp = len(opt_res.get("expirationDates", []))
            opts = opt_res.get("options", [])
            nc = len(opts[0].get("calls", [])) if opts else 0
            np_ = len(opts[0].get("puts", [])) if opts else 0
            log_msg(f"  OK {exp} expiration dates, {nc} calls, {np_} puts")
        except Exception as e:
            errors.append(f"options: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ------ SEARCH ------
    if args.search:
        log_msg(">> Search + News...")
        try:
            data = fetch_search(ticker)
            results["endpoints"]["search"] = data
            nn = len(data.get("news", []))
            log_msg(f"  OK {nn} news items")
        except Exception as e:
            errors.append(f"search: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ------ RECOMMENDATIONS ------
    if args.recommendations:
        log_msg(">> Recommendations...")
        try:
            if session is None:
                session = yahoo_session()
            data = fetch_recommendations(session, ticker)
            results["endpoints"]["recommendations"] = data
            log_msg("  OK")
        except Exception as e:
            errors.append(f"recommendations: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ------ TRENDING ------
    if args.trending:
        log_msg(">> Trending...")
        try:
            data = fetch_trending()
            results["endpoints"]["trending"] = data
            nq = len(data.get("finance", {}).get("result", [{}])[0].get("quotes", []))
            log_msg(f"  OK {nq} trending symbols")
        except Exception as e:
            errors.append(f"trending: {e}")
            log_msg(f"  ERR {e}")
        time.sleep(args.delay)

    # ====== GUARDAR ======
    results["errors"] = errors
    results["endpoints_count"] = len(results["endpoints"])

    if args.output:
        outpath = args.output
    else:
        outpath = f"{ticker}_fetch.json"

    with open(outpath, "w", encoding="utf-8") as f:
        json.dump(results, f, indent=2, default=str)

    size_kb = os.path.getsize(outpath) / 1024
    log_msg(f"\n{'='*50}")
    log_msg(f"Guardado en: {outpath}")
    log_msg(f"Endpoints exitosos: {results['endpoints_count']}/{len(errors) + results['endpoints_count']}")
    if errors:
        log_msg(f"Errores ({len(errors)}):")
        for e in errors:
            log_msg(f"  - {e}")
    log_msg(f"Tamano: {size_kb:.0f} KB")


if __name__ == "__main__":
    main()

"""
Fetch quote + fundamentals de Yahoo Finance usando la API v7/v10 directa.
Sin dependencia de yfinance — solo requests + cookie/crumb.

Uso:
    python fetch_quote.py --tickers AAPL,MSFT --output data/
    python fetch_quote.py --tickers AAPL --modules assetProfile,financialData --json
"""

import argparse
import json
import os
import sys
import time

import requests


BASE = "https://query1.finance.yahoo.com"
HEADERS = {
    "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"
}


def yahoo_session():
    """Create requests.Session with cookie A3 and crumb."""
    s = requests.Session()
    s.headers.update(HEADERS)
    s.get("https://fc.yahoo.com", timeout=10)
    crumb_resp = s.get(f"{BASE}/v1/test/getcrumb", timeout=10)
    crumb = crumb_resp.text.strip()
    s.params = {"crumb": crumb}
    return s


def fetch_quote(session, tickers):
    """Fetch real-time quote via v7/quote."""
    symbols = ",".join(tickers)
    url = f"{BASE}/v7/finance/quote"
    resp = session.get(url, params={"symbols": symbols})
    resp.raise_for_status()
    return resp.json()


def fetch_quote_summary(session, ticker, modules):
    """Fetch fundamentals via v10/quoteSummary."""
    url = f"{BASE}/v10/finance/quoteSummary/{ticker}"
    resp = session.get(url, params={"modules": ",".join(modules)})
    resp.raise_for_status()
    return resp.json()


def main():
    parser = argparse.ArgumentParser(description="Fetch quote + fundamentals de Yahoo Finance")
    parser.add_argument("--tickers", required=True, help="Tickers separados por coma, ej: AAPL,MSFT")
    parser.add_argument("--modules", default="assetProfile,financialData,defaultKeyStatistics",
                        help="Módulos de quoteSummary separados por coma")
    parser.add_argument("--output", default="data", help="Directorio de salida")
    parser.add_argument("--json", action="store_true", help="Output a JSON en stdout")
    parser.add_argument("--delay", type=float, default=1.0, help="Delay entre requests (segundos)")

    args = parser.parse_args()
    os.makedirs(args.output, exist_ok=True)

    tickers = [t.strip().upper() for t in args.tickers.split(",")]
    modules = [m.strip() for m in args.modules.split(",")]

    print("→ Obteniendo sesión con crumb...")
    session = yahoo_session()

    # 1. Quote rápido
    print(f"→ Fetching quote para {', '.join(tickers)}...")
    try:
        quote_data = fetch_quote(session, tickers)
        if args.json:
            print(json.dumps(quote_data, indent=2))
        else:
            outfile = os.path.join(args.output, "quotes.json")
            with open(outfile, "w", encoding="utf-8") as f:
                json.dump(quote_data, f, indent=2)
            print(f"  ✓ quotes.json guardado en {outfile}")

            # Mostrar resumen
            for q in quote_data.get("quoteResponse", {}).get("result", []):
                print(f"  {q['symbol']}: ${q.get('regularMarketPrice', 'N/A')} "
                      f"({q.get('regularMarketChangePercent', 0):.2f}%) "
                      f"vol={q.get('regularMarketVolume', 'N/A')}")
    except Exception as e:
        print(f"  ✗ Error en quote: {e}")

    time.sleep(args.delay)

    # 2. QuoteSummary (fundamentals) por ticker
    for ticker in tickers:
        print(f"\n→ Fetching fundamentals para {ticker}...")
        try:
            summary = fetch_quote_summary(session, ticker, modules)
            if args.json:
                print(json.dumps(summary, indent=2))
            else:
                outfile = os.path.join(args.output, f"{ticker}_fundamentals.json")
                with open(outfile, "w", encoding="utf-8") as f:
                    json.dump(summary, f, indent=2)
                print(f"  ✓ {ticker}_fundamentals.json guardado")

                # Mostrar resumen si hay financialData
                result = summary.get("quoteSummary", {}).get("result", [{}])[0]
                fin = result.get("financialData", {})
                if fin:
                    print(f"  Revenue: {fin.get('totalRevenue', {}).get('raw', 'N/A')}")
                    print(f"  EBITDA: {fin.get('ebitda', {}).get('raw', 'N/A')}")
                    print(f"  Profit Margin: {fin.get('profitMargins', {}).get('fmt', 'N/A')}")
        except Exception as e:
            print(f"  ✗ Error en {ticker}: {e}")

        time.sleep(args.delay)


if __name__ == "__main__":
    main()