Live Trading

!pip install alpaca-trade-api !pip install alpaca-py

import alpaca from alpaca.trading.client import TradingClient from alpaca.data.historical import StockHistoricalDataClient from alpaca.data.requests import StockBarsRequest from alpaca.data.timeframe import TimeFrame from datetime import datetime, timedelta from google.colab import userdata # 🔐 CONFIG API_KEY = userdata.get("ALPACA_API_KEY") SECRET_KEY = userdata.get("ALPACA_SECRET_KEY") # Client per il trading (paper=True = simulazione) trading = TradingClient(API_KEY, SECRET_KEY, paper=True) account = trading.get_account() print(f"Portafoglio: ${float(account.portfolio_value):,.2f}") print(f"Cash: ${float(account.cash):,.2f}") print(f"Buying power: ${float(account.buying_power):,.2f}")

def diagnostica(): print("🔍 DIAGNOSTICA ALPACA") # 1. Test connessione tc = TradingClient(API_KEY, SECRET_KEY, paper=True) try: acc = tc.get_account() print(f"✅ API funzionante - Account: {acc.account_number}") print(f"💰 Cash: ${float(acc.cash):.2f}") except Exception as e: print(f"❌ Errore API: {e}") return # 2. Test dati storici dc = StockHistoricalDataClient(API_KEY, SECRET_KEY) # Prova diversi intervalli for ore in [8, 24, 48, 72]: req = StockBarsRequest( symbol_or_symbols="AAPL", timeframe=TimeFrame.Minute, start=datetime.now() - timedelta(hours=ore) ) resp = dc.get_stock_bars(req) print(f"Ultime {ore} ore: {len(resp.df)} barre") # 3. Orario corrente clock = tc.get_clock() print(f"\n🕐 Ora server: {clock.timestamp}") print(f"📈 Mercato aperto: {clock.is_open}") print(f"🔜 Prossima apertura: {clock.next_open}") print(f"🔚 Prossima chiusura: {clock.next_close}") diagnostica()

from alpaca.trading.requests import ( MarketOrderRequest, LimitOrderRequest, TrailingStopOrderRequest ) from alpaca.trading.enums import OrderSide, TimeInForce # ── 1. Market order (esecuzione immediata al prezzo corrente) ─ o = trading.submit_order(MarketOrderRequest( symbol="AAPL", qty=10, side=OrderSide.BUY, time_in_force=TimeInForce.DAY )) print(f"Market order: {o.id} — status: {o.status}") # ── 2. Limit order (compra solo se prezzo scende a 148) ─────── trading.submit_order(LimitOrderRequest( symbol="AAPL", qty=5, side=OrderSide.BUY, limit_price=148.00, time_in_force=TimeInForce.GTC # Good Till Cancelled )) # ── 3. Trailing stop (vende se prezzo scende del 2% dal max) ─ trading.submit_order(TrailingStopOrderRequest( symbol="AAPL", qty=10, side=OrderSide.SELL, trail_percent=2.0, time_in_force=TimeInForce.GTC # Added missing time_in_force )) # ── 4. Visualizza tutti gli ordini aperti ───────────────────── aperti = trading.get_orders() for x in aperti: print(f"{x.symbol} {x.side} qty={x.qty} [{x.status}]") # ── 5. Cancella un ordine ───────────────────────────────────── trading.cancel_order_by_id(o.id)

# Leggi tutte le posizioni aperte positions = trading.get_all_positions() for p in positions: pnl = float(p.unrealized_plpc) * 100 seg = "+" if pnl > 0 else "" print( f"{p.symbol:<6} qty={p.qty:>6}" f" valore=${float(p.market_value):8.2f}" f" P&L={seg}{pnl:.2f}%" ) # Helper: controlla se hai una posizione su un simbolo def ha_posizione(symbol) -> bool: try: trading.get_open_position(symbol) return True except: return False # Fix: Cancel any pending sell orders for AAPL before attempting to close the position open_orders = trading.get_orders() # Get all open orders (defaults to open) for order in open_orders: if order.symbol == "AAPL" and order.side == OrderSide.SELL: print(f"Cancelling pending sell order for {order.symbol} with ID: {order.id}") trading.cancel_order_by_id(order.id) # Chiudi una posizione specifica trading.close_position("AAPL") # Panic button: chiudi tutto e cancella ordini pendenti trading.close_all_positions(cancel_orders=True)

import time import logging from datetime import datetime, timedelta # 🔐 CONFIG API_KEY = userdata.get("ALPACA_API_KEY") SECRET_KEY = userdata.get("ALPACA_SECRET_KEY") logging.basicConfig(level=logging.INFO) class RealBot: def __init__(self, symbol="AAPL"): self.symbol = symbol self.tc = TradingClient(API_KEY, SECRET_KEY, paper=True) self.dc = StockHistoricalDataClient(API_KEY, SECRET_KEY) self.fast = 20 self.slow = 50 self.position = False self.entry_price = None self.risk_per_trade = 0.01 # 1% # 📊 DATI (CORRETTO) def get_data(self): try: # Richiedi 5 giorni di dati per avere abbastanza storia req = StockBarsRequest( symbol_or_symbols=self.symbol, timeframe=TimeFrame.Minute, start=datetime.now() - timedelta(days=5), limit=500 # Limita a 500 barre ) response = self.dc.get_stock_bars(req) # METODO CORRETTO per estrarre i dati if response.df.empty: logging.warning("Nessun dato ricevuto") return None # Converti MultiIndex in DataFrame semplice df = response.df.droplevel(0) # Rimuove il livello del simbolo df = df.reset_index() # Resetta l'indice df = df.set_index('timestamp') # Usa timestamp come indice if len(df) < self.slow: logging.warning(f"Dati insufficienti: {len(df)} righe, serve almeno {self.slow}") return None # Calcola SMA df["SMA_fast"] = df["close"].rolling(self.fast).mean() df["SMA_slow"] = df["close"].rolling(self.slow).mean() # RSI delta = df["close"].diff() gain = delta.clip(lower=0) loss = -delta.clip(upper=0) avg_gain = gain.rolling(14).mean() avg_loss = loss.rolling(14).mean() rs = avg_gain / avg_loss df["RSI"] = 100 - (100 / (1 + rs)) return df except Exception as e: logging.error(f"Errore get_data: {e}") return None # 🎯 SEGNALE def signal(self, df): if df is None or len(df) < 2: return "HOLD" f = df["SMA_fast"] s = df["SMA_slow"] rsi = df["RSI"] # Verifica che non ci siano NaN if f.isna().iloc[-1] or s.isna().iloc[-1] or rsi.isna().iloc[-1]: return "HOLD" f_now, f_prev = f.iloc[-1], f.iloc[-2] s_now, s_prev = s.iloc[-1], s.iloc[-2] rsi_now = rsi.iloc[-1] if f_prev < s_prev and f_now > s_now and rsi_now < 70: return "BUY" if f_prev > s_prev and f_now < s_now: return "SELL" return "HOLD" # 💰 SIZE DINAMICA def position_size(self, price): acc = self.tc.get_account() capital = float(acc.equity) risk_amount = capital * self.risk_per_trade stop_loss_pct = 0.02 qty = int(risk_amount / (price * stop_loss_pct)) return max(qty, 1) # 🚀 LOOP def run(self): logging.info(f"Bot reale avviato per {self.symbol}") logging.info(f"Parametri: SMA{self.fast} / SMA{self.slow}") ciclo = 0 while True: ciclo += 1 try: logging.info(f"---- CICLO {ciclo} ----") # Verifica se il mercato è aperto clock = self.tc.get_clock() logging.info(f"Mercato aperto: {clock.is_open}") if not clock.is_open: logging.info("Mercato chiuso - attesa 5 minuti") time.sleep(300) # 5 minuti quando chiuso continue # Ottieni dati df = self.get_data() if df is None: logging.warning("Nessun dato disponibile") time.sleep(60) continue logging.info(f"Dati ricevuti: {len(df)} righe") sig = self.signal(df) price = df["close"].iloc[-1] logging.info(f"SEGNALE: {sig} | PREZZO: {price:.2f}") # Mostra anche gli indicatori per debug logging.info(f"SMA_fast: {df['SMA_fast'].iloc[-1]:.2f}, SMA_slow: {df['SMA_slow'].iloc[-1]:.2f}") logging.info(f"RSI: {df['RSI'].iloc[-1]:.2f}") logging.info(f"Posizione aperta: {self.position}") # 🟢 BUY if sig == "BUY" and not self.position: qty = self.position_size(price) if qty > 0: order = MarketOrderRequest( symbol=self.symbol, qty=qty, side=OrderSide.BUY, time_in_force=TimeInForce.DAY ) self.tc.submit_order(order) self.position = True self.entry_price = price logging.info(f"🟢 BUY {qty} @ {price}") else: logging.warning("Quantità zero, ordine non eseguito") # 🔴 SELL (crossover) elif sig == "SELL" and self.position: self.tc.close_position(self.symbol) self.position = False logging.info("🔴 SELL (crossover)") # 🛑 STOP LOSS / TAKE PROFIT if self.position and self.entry_price: if price <= self.entry_price * 0.98: self.tc.close_position(self.symbol) self.position = False logging.info(f"🛑 STOP LOSS a {price:.2f} (entry: {self.entry_price:.2f})") elif price >= self.entry_price * 1.03: self.tc.close_position(self.symbol) self.position = False logging.info(f"💰 TAKE PROFIT a {price:.2f} (entry: {self.entry_price:.2f})") time.sleep(60) # Controlla ogni minuto except Exception as e: logging.error(f"Errore nel ciclo: {e}") import traceback traceback.print_exc() time.sleep(60) # === ESECUZIONE CON TEST PRELIMINARE === if __name__ == "__main__": print("Avvio bot...") # Test rapido di connessione bot_test = RealBot("AAPL") try: acc = bot_test.tc.get_account() print(f"✅ Connessione riuscita! Account: {acc.account_number}") print(f"💰 Equity: ${float(acc.equity):.2f}") # Test dati print("\n📊 Test recupero dati...") df_test = bot_test.get_data() if df_test is not None: print(f"✅ Dati recuperati: {len(df_test)} righe") print(df_test[['close', 'SMA_fast', 'SMA_slow', 'RSI']].tail()) else: print("❌ Problema nel recupero dati") # Avvia bot print("\n🚀 Avvio bot in modalità paper trading...") bot_test.run() except Exception as e: print(f"❌ Errore di connessione: {e}")