Add Alpaca broker integration

ALPACA_TRADING_SETUP.md

@@ -0,0 +1,83 @@
+# Alpaca Trading API Kurulumu
+
+Bu uygulamada ABD hisseleri icin ilk gercek broker entegrasyonu Alpaca uzerinden yapilir.
+
+## Modlar
+
+- `--mode paper`: Mevcut lokal kagit broker. Gercek API kullanmaz.
+- `--mode sandbox --market us`: Alpaca paper trading API kullanir. Gercek para kullanmaz.
+- `--mode live --market us`: Alpaca live endpoint kullanir. Gercek para riski vardir ve ekstra env kilidi ister.
+
+BIST icin Alpaca kullanilmaz. BIST tarafinda ayri broker/Matriks bridge gerekir.
+
+## Gerekli Env Degiskenleri
+
+Paper trading icin:
+
+```env
+TRADING_BROKER=alpaca
+ALPACA_API_KEY=...
+ALPACA_API_SECRET=...
+ALPACA_ORDER_WAIT_SEC=20
+```
+
+Live trading icin bunlara ek olarak:
+
+```env
+ALPACA_ENABLE_LIVE=true
+MAX_ORDER_NOTIONAL=25000
+```
+
+`ALPACA_ENABLE_LIVE` set edilmeden live endpoint acilmaz.
+
+Opsiyonel endpoint override:
+
+```env
+ALPACA_PAPER_BASE_URL=https://paper-api.alpaca.markets
+ALPACA_LIVE_BASE_URL=https://api.alpaca.markets
+```
+
+## Guvenli Test Sirası
+
+1. Credential ve hesap kontrolu:
+
+```bash
+curl https://veteroner-borsa.hf.space/api/diag/alpaca
+```
+
+2. Yerelde Alpaca paper ile tek cycle:
+
+```bash
+cd huggingface-space
+TRADING_BROKER=alpaca python3 -m trading.worker --cycle --market us --mode sandbox --force
+```
+
+3. Daemon olarak Alpaca paper:
+
+```bash
+cd huggingface-space
+TRADING_BROKER=alpaca python3 -m trading.worker --daemon --market us --mode sandbox --interval 3600
+```
+
+4. Live icin son kilit:
+
+```bash
+cd huggingface-space
+TRADING_BROKER=alpaca ALPACA_ENABLE_LIVE=true python3 -m trading.worker --daemon --market us --mode live --interval 3600
+```
+
+Daemon live modda terminalde `YES` onayi ister.
+
+## Risk Kilitleri
+
+Worker emir gondermeden once mevcut guvenlik katmanlarini kullanir:
+
+- Kill switch
+- Circuit breaker
+- Market saatleri kontrolu
+- Gunluk emir limiti
+- Tek emir notional limiti
+- Minimum nakit rezervi
+- Model risk ve scorecard kapilari
+
+Ilk live kullanimda `MAX_ORDER_NOTIONAL` dusuk tutulmali ve Telegram onayli emir akisi eklenene kadar otomatik live daemon calistirilmamalidir.

README.md

@@ -34,6 +34,12 @@ ML sinyallerini gerçek para ile kullanmadan önce, yerel walk-forward backtest
 
 - [WALK_FORWARD_BACKTEST.md](WALK_FORWARD_BACKTEST.md)
 
+## ABD Hisseleri Gerçek Broker Entegrasyonu
+
+US piyasası için Alpaca Trading API adaptörü eklendi. Önce Alpaca paper endpoint ile doğrulama, sonra açık env kilidiyle live endpoint kullanımı önerilir:
+
+- [ALPACA_TRADING_SETUP.md](ALPACA_TRADING_SETUP.md)
+
 ## 📦 Kurulum
 
 ### 1. Bağımlılıkları Yükle

app.py

@@ -1535,6 +1535,46 @@ def diag_telegram():
     return report
 
 
+@app.get("/api/diag/alpaca")
+def diag_alpaca(paper: bool = Query(True, description="Use Alpaca paper endpoint")):
+    """Diagnostic: report Alpaca trading API readiness without exposing secrets."""
+    key = os.environ.get("ALPACA_API_KEY") or os.environ.get("ALPACA_KEY_ID") or ""
+    secret = os.environ.get("ALPACA_API_SECRET") or os.environ.get("ALPACA_SECRET_KEY") or ""
+    live_enabled = str(os.environ.get("ALPACA_ENABLE_LIVE", "")).strip().lower() in {"1", "true", "yes", "on"}
+    report = {
+        "broker": "alpaca",
+        "paper": bool(paper),
+        "apiKeySet": bool(key),
+        "apiKeyLength": len(key),
+        "apiSecretSet": bool(secret),
+        "apiSecretLength": len(secret),
+        "liveEnabled": live_enabled,
+        "accountOk": False,
+    }
+    if not key or not secret:
+        report["error"] = "alpaca_credentials_missing"
+        return report
+    if not paper and not live_enabled:
+        report["error"] = "live_endpoint_blocked_set_ALPACA_ENABLE_LIVE"
+        return report
+    try:
+        from trading.alpaca_broker import AlpacaBroker
+
+        broker = AlpacaBroker.from_env(paper=bool(paper))
+        account = broker.get_account_info()
+        report.update({
+            "accountOk": True,
+            "cash": account.get("cash"),
+            "equity": account.get("equity"),
+            "positionCount": len(account.get("positions", {})),
+            "accountStatus": (account.get("raw_account") or {}).get("status"),
+            "tradingBlocked": (account.get("raw_account") or {}).get("trading_blocked"),
+        })
+    except Exception as e:
+        report["error"] = f"{type(e).__name__}: {e}"
+    return report
+
+
 # ─── Telegram Bot Webhook / Menu ────────────────────────────────────────────
 
 def _telegram_webhook_secret() -> str:

trading/alpaca_broker.py

@@ -0,0 +1,251 @@
+"""Alpaca broker adapter for US equities.
+
+This adapter implements BrokerBase using Alpaca's Trading API v2.
+Default safe path:
+- sandbox mode -> Alpaca paper endpoint
+- live mode -> Alpaca live endpoint only when explicitly enabled by env
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import time
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+
+from trading.broker_base import (
+    BrokerBase,
+    FillResult,
+    OrderRequest,
+    OrderSide,
+    OrderStatus,
+    OrderType,
+    SlippageModel,
+)
+
+logger = logging.getLogger("trading.alpaca_broker")
+
+
+class AlpacaConfigError(RuntimeError):
+    """Raised when Alpaca credentials or live guards are not configured."""
+
+
+class AlpacaBroker(BrokerBase):
+    """BrokerBase implementation backed by Alpaca Trading API.
+
+    Env vars:
+        ALPACA_API_KEY / ALPACA_KEY_ID
+        ALPACA_API_SECRET / ALPACA_SECRET_KEY
+        ALPACA_PAPER_BASE_URL       default https://paper-api.alpaca.markets
+        ALPACA_LIVE_BASE_URL        default https://api.alpaca.markets
+        ALPACA_ENABLE_LIVE          must be true/1/yes for live endpoint
+        ALPACA_ORDER_WAIT_SEC       seconds to wait for market order fill
+    """
+
+    PAPER_BASE_URL = "https://paper-api.alpaca.markets"
+    LIVE_BASE_URL = "https://api.alpaca.markets"
+
+    def __init__(
+        self,
+        api_key: str,
+        api_secret: str,
+        *,
+        paper: bool = True,
+        base_url: str = "",
+        timeout: int = 30,
+        wait_for_fill_sec: float = 20.0,
+        slippage_model: Optional[SlippageModel] = None,
+    ) -> None:
+        super().__init__(name="AlpacaPaper" if paper else "AlpacaLive", slippage_model=slippage_model)
+        if not api_key or not api_secret:
+            raise AlpacaConfigError("Alpaca API key/secret are required")
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.paper = paper
+        self.base_url = (base_url or (self.PAPER_BASE_URL if paper else self.LIVE_BASE_URL)).rstrip("/")
+        self.timeout = timeout
+        self.wait_for_fill_sec = max(0.0, float(wait_for_fill_sec))
+
+        self._session = requests.Session()
+        self._session.headers.update({
+            "APCA-API-KEY-ID": self.api_key,
+            "APCA-API-SECRET-KEY": self.api_secret,
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        })
+        retries = Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET", "POST", "DELETE"],
+        )
+        adapter = HTTPAdapter(max_retries=retries)
+        self._session.mount("https://", adapter)
+        self._session.mount("http://", adapter)
+
+    @classmethod
+    def from_env(cls, *, paper: bool = True) -> "AlpacaBroker":
+        api_key = os.environ.get("ALPACA_API_KEY") or os.environ.get("ALPACA_KEY_ID") or ""
+        api_secret = os.environ.get("ALPACA_API_SECRET") or os.environ.get("ALPACA_SECRET_KEY") or ""
+        if not paper:
+            live_enabled = str(os.environ.get("ALPACA_ENABLE_LIVE", "")).strip().lower()
+            if live_enabled not in {"1", "true", "yes", "on"}:
+                raise AlpacaConfigError(
+                    "ALPACA_ENABLE_LIVE must be true/1/yes before live Alpaca orders are allowed"
+                )
+        return cls(
+            api_key=api_key,
+            api_secret=api_secret,
+            paper=paper,
+            base_url=os.environ.get("ALPACA_PAPER_BASE_URL" if paper else "ALPACA_LIVE_BASE_URL", ""),
+            timeout=int(os.environ.get("ALPACA_TIMEOUT_SEC", "30")),
+            wait_for_fill_sec=float(os.environ.get("ALPACA_ORDER_WAIT_SEC", "20")),
+        )
+
+    def _request(self, method: str, path: str, **kwargs: Any) -> Any:
+        url = f"{self.base_url}{path}"
+        resp = self._session.request(method, url, timeout=self.timeout, **kwargs)
+        if resp.status_code >= 400:
+            body = resp.text[:500]
+            raise RuntimeError(f"Alpaca API {resp.status_code} {path}: {body}")
+        if not resp.content:
+            return None
+        return resp.json()
+
+    def _execute(self, req: OrderRequest) -> FillResult:
+        payload: Dict[str, Any] = {
+            "symbol": str(req.symbol).upper(),
+            "qty": str(int(req.quantity)),
+            "side": req.side.value.lower(),
+            "type": "market" if req.order_type == OrderType.MARKET else "limit",
+            "time_in_force": self._map_time_in_force(req.time_in_force),
+            "client_order_id": req.client_order_id,
+        }
+        if req.order_type == OrderType.LIMIT:
+            payload["limit_price"] = str(req.limit_price)
+
+        try:
+            submitted = self._request("POST", "/v2/orders", json=payload)
+            order = self._wait_for_terminal_or_fill(submitted.get("id")) if submitted.get("id") else submitted
+            return self._fill_from_order(req, order or submitted)
+        except Exception as exc:
+            logger.warning("Alpaca order failed: %s", exc)
+            return FillResult(
+                order_id="alpaca_rejected",
+                client_order_id=req.client_order_id,
+                symbol=req.symbol,
+                side=req.side,
+                requested_qty=req.quantity,
+                filled_qty=0,
+                avg_fill_price=0.0,
+                commission=0.0,
+                slippage_bps=0.0,
+                status=OrderStatus.REJECTED,
+                timestamp=datetime.now(timezone.utc).isoformat(),
+                broker_name=self.name,
+                reject_reason=str(exc),
+            )
+
+    def _wait_for_terminal_or_fill(self, order_id: str) -> Dict[str, Any]:
+        deadline = time.time() + self.wait_for_fill_sec
+        last = self._request("GET", f"/v2/orders/{order_id}")
+        terminal = {"filled", "partially_filled", "canceled", "expired", "rejected"}
+        while time.time() < deadline:
+            status = str(last.get("status") or "").lower()
+            if status in terminal:
+                return last
+            time.sleep(1.0)
+            last = self._request("GET", f"/v2/orders/{order_id}")
+        return last
+
+    def _fill_from_order(self, req: OrderRequest, order: Dict[str, Any]) -> FillResult:
+        status = self._map_status(str(order.get("status") or ""))
+        filled_qty = int(float(order.get("filled_qty") or 0))
+        avg_price = float(order.get("filled_avg_price") or order.get("limit_price") or 0.0)
+        order_id = str(order.get("id") or "")
+        if status == OrderStatus.PENDING and filled_qty > 0:
+            status = OrderStatus.PARTIALLY_FILLED
+        if status in {OrderStatus.REJECTED, OrderStatus.CANCELLED, OrderStatus.EXPIRED}:
+            filled_qty = 0
+            avg_price = 0.0
+        return FillResult(
+            order_id=order_id or "alpaca_order",
+            client_order_id=str(order.get("client_order_id") or req.client_order_id),
+            symbol=req.symbol,
+            side=req.side,
+            requested_qty=req.quantity,
+            filled_qty=filled_qty,
+            avg_fill_price=avg_price,
+            commission=0.0,
+            slippage_bps=0.0,
+            status=status,
+            timestamp=str(order.get("filled_at") or order.get("submitted_at") or datetime.now(timezone.utc).isoformat()),
+            broker_name=self.name,
+            raw_response=order,
+            reject_reason=str(order.get("failed_at") or order.get("expired_at") or "") or None,
+        )
+
+    def get_account_info(self) -> Dict[str, Any]:
+        account = self._request("GET", "/v2/account")
+        positions_raw = self._request("GET", "/v2/positions") or []
+        positions: Dict[str, Dict[str, Any]] = {}
+        for pos in positions_raw:
+            symbol = str(pos.get("symbol") or "").upper()
+            if not symbol:
+                continue
+            qty = int(float(pos.get("qty") or 0))
+            if qty <= 0:
+                continue
+            positions[symbol] = {
+                "qty": qty,
+                "avg_cost": float(pos.get("avg_entry_price") or 0.0),
+                "market_value": float(pos.get("market_value") or 0.0),
+                "unrealized_pl": float(pos.get("unrealized_pl") or 0.0),
+                "unrealized_plpc": float(pos.get("unrealized_plpc") or 0.0),
+            }
+        equity = float(account.get("equity") or 0.0)
+        last_equity = float(account.get("last_equity") or equity or 1.0)
+        pnl_pct = ((equity / last_equity) - 1.0) * 100 if last_equity else 0.0
+        return {
+            "cash": round(float(account.get("cash") or 0.0), 2),
+            "equity": round(equity, 2),
+            "initial_cash": round(last_equity, 2),
+            "pnl_pct": round(pnl_pct, 2),
+            "positions": positions,
+            "trade_count": 0,
+            "total_commission": 0.0,
+            "buying_power": float(account.get("buying_power") or 0.0),
+            "raw_account": {
+                "status": account.get("status"),
+                "trading_blocked": account.get("trading_blocked"),
+                "account_blocked": account.get("account_blocked"),
+                "pattern_day_trader": account.get("pattern_day_trader"),
+            },
+        }
+
+    @staticmethod
+    def _map_time_in_force(value: str) -> str:
+        normalized = str(value or "DAY").strip().lower()
+        if normalized in {"gtc", "day", "ioc", "opg", "cls"}:
+            return normalized
+        return "day"
+
+    @staticmethod
+    def _map_status(value: str) -> OrderStatus:
+        normalized = value.lower()
+        if normalized == "filled":
+            return OrderStatus.FILLED
+        if normalized == "partially_filled":
+            return OrderStatus.PARTIALLY_FILLED
+        if normalized in {"canceled", "cancelled"}:
+            return OrderStatus.CANCELLED
+        if normalized == "expired":
+            return OrderStatus.EXPIRED
+        if normalized in {"rejected", "stopped", "suspended"}:
+            return OrderStatus.REJECTED
+        return OrderStatus.PENDING

trading/worker.py

@@ -622,15 +622,37 @@ class TradingWorker:
 
         # Broker (based on mode)
         if self.mode == "live":
-            from trading.midas_broker import MidasBroker
-            self._broker = MidasBroker.from_env(sandbox=False, dry_run=False)
+            broker_provider = os.environ.get(
+                "TRADING_BROKER",
+                "alpaca" if self.market_id == "us" else "midas",
+            ).strip().lower()
+            if broker_provider == "alpaca":
+                if self.market_id != "us":
+                    raise RuntimeError("Alpaca live broker is only supported for market_id='us'")
+                from trading.alpaca_broker import AlpacaBroker
+                self._broker = AlpacaBroker.from_env(paper=False)
+            else:
+                from trading.midas_broker import MidasBroker
+                self._broker = MidasBroker.from_env(sandbox=False, dry_run=False)
             logger.warning("=" * 60)
             logger.warning("*** LIVE TRADING MODE — REAL MONEY ***")
+            logger.warning("Broker provider: %s", broker_provider)
             logger.warning("=" * 60)
         elif self.mode == "sandbox":
-            from trading.midas_broker import MidasBroker
-            self._broker = MidasBroker.from_env(sandbox=True, dry_run=False)
-            logger.info("Sandbox mode — using Midas demo environment")
+            broker_provider = os.environ.get(
+                "TRADING_BROKER",
+                "alpaca" if self.market_id == "us" else "midas",
+            ).strip().lower()
+            if broker_provider == "alpaca":
+                if self.market_id != "us":
+                    raise RuntimeError("Alpaca paper broker is only supported for market_id='us'")
+                from trading.alpaca_broker import AlpacaBroker
+                self._broker = AlpacaBroker.from_env(paper=True)
+                logger.info("Sandbox mode — using Alpaca paper trading API")
+            else:
+                from trading.midas_broker import MidasBroker
+                self._broker = MidasBroker.from_env(sandbox=True, dry_run=False)
+                logger.info("Sandbox mode — using Midas demo environment")
         else:
             # Restore broker from state.json if available
             state_data = {}
@@ -1408,11 +1430,13 @@ class TradingWorker:
             state_data["total_trades"] = total_trades
             state_data["broker_cash"] = account.get("cash", 0)
             state_data["is_running"] = False
-            # Save broker positions for paper mode
-            if self.mode == "paper" and hasattr(self._broker, "_positions"):
+            # Save broker positions for dashboard/sync in every mode.
+            if hasattr(self._broker, "_positions"):
                 state_data["broker_positions"] = {
                     s: dict(p) for s, p in self._broker._positions.items()  # type: ignore
                 }
+            else:
+                state_data["broker_positions"] = account.get("positions", {})
             state_data["updated_at"] = datetime.now(timezone.utc).isoformat()
             tmp = state_file.with_suffix(".tmp")
             tmp.write_text(json.dumps(state_data, indent=2, default=str))