extras/trading/trades_gemini.py

# tickers is a list of stock tickers
import tickers

# prices is a dict; the key is a ticker and the value is a list of historic prices, today first
import prices

# Trade represents a decision to buy or sell a quantity of a ticker
import Trade

import random
import numpy as np

def trade2():
    # Buy the stock with the highest price today
    ticker = max(prices, key=lambda t: prices[t][0])  # Find ticker with highest price
    return [Trade(ticker, random.randrange(1, 10))]   # Buy a small quantity

def trade3():
    # Sell the stock with the lowest price today
    ticker = min(prices, key=lambda t: prices[t][0])
    return [Trade(ticker, random.randrange(-10, -1))] 

def trade4():
    # Buy the stock with the largest percent increase today
    changes = {t: (prices[t][0] - prices[t][1]) / prices[t][1] for t in prices}
    ticker = max(changes, key=changes.get)
    return [Trade(ticker, random.randrange(1, 10))]

def trade5():
    # Sell the stock with the largest percent decrease today
    changes = {t: (prices[t][0] - prices[t][1]) / prices[t][1] for t in prices}
    ticker = min(changes, key=changes.get)
    return [Trade(ticker, random.randrange(-10, -1))]

def trade6():
    # Buy the 3 stocks with the highest moving average over the last 5 days
    mvgs = {t: np.mean(prices[t][:5]) for t in prices}
    top_tickers = sorted(mvgs, key=mvgs.get, reverse=True)[:3]
    return [Trade(t, random.randrange(1, 5)) for t in top_tickers]

def trade7():
    # Sell the 3 stocks with the lowest moving average over the last 5 days
    mvgs = {t: np.mean(prices[t][:5]) for t in prices}
    bottom_tickers = sorted(mvgs, key=mvgs.get)[:3]
    return [Trade(t, random.randrange(-5, -1)) for t in bottom_tickers]

def trade8():
    # Randomly buy or sell a single stock based on a coin flip
    ticker = random.choice(tickers)
    action = random.choice([-1, 1])  # -1 for sell, 1 for buy
    return [Trade(ticker, action * random.randrange(1, 10))]

def trade9():
    # Diversify: Buy a small amount of 5 random stocks
    chosen_tickers = random.sample(tickers, 5)
    return [Trade(t, random.randrange(1, 3)) for t in chosen_tickers]

def trade10():
    # Follow the trend: If the market is up today, buy, else sell
    market_change = (prices[tickers[0]][0] - prices[tickers[0]][1]) / prices[tickers[0]][1]
    action = 1 if market_change > 0 else -1
    ticker = random.choice(tickers)
    return [Trade(ticker, action * random.randrange(1, 10))]

def trade11():
    # Mean Reversion: Buy the 2 stocks that fell the most yesterday, hoping they rebound
    yesterday_changes = {t: (prices[t][1] - prices[t][2]) / prices[t][2] for t in prices}
    bottom_tickers = sorted(yesterday_changes, key=yesterday_changes.get)[:2]
    return [Trade(t, random.randrange(1, 5)) for t in bottom_tickers]

def trade12():
    # Momentum: Short the 2 stocks that rose the most yesterday, expecting a pullback
    yesterday_changes = {t: (prices[t][1] - prices[t][2]) / prices[t][2] for t in prices}
    top_tickers = sorted(yesterday_changes, key=yesterday_changes.get, reverse=True)[:2]
    return [Trade(t, random.randrange(-5, -1)) for t in top_tickers]

def trade13():
    # Pairs Trading: Long one stock, short another with a similar price history
    correlations = np.corrcoef([prices[t] for t in tickers])
    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
    return [Trade(tickers[i], 1), Trade(tickers[j], -1)] 

def trade14():
    # Relative Strength: Go long on the strongest stock, short the weakest
    performances = {t: (prices[t][0] - prices[t][-1]) / prices[t][-1] for t in prices}
    strongest = max(performances, key=performances.get)
    weakest = min(performances, key=performances.get)
    return [Trade(strongest, 1), Trade(weakest, -1)]

def trade15():
    # Calendar Spread: Buy this month's option, sell next month's (same strike
    # This is a simplified representation, as actual option trading is more complex
    ticker = random.choice(tickers)
    return [Trade(f"{ticker}_OPT_THIS_MONTH", 1), Trade(f"{ticker}_OPT_NEXT_MONTH", -1)]

def trade16():
    # Straddle: Buy both a call and put option on the same stock (same strike
    ticker = random.choice(tickers)
    strike = prices[ticker][0]  # Use the current price as a simple strike price
    return [Trade(f"{ticker}_CALL_{strike}", 1), Trade(f"{ticker}_PUT_{strike}", 1)]

def trade17():
    # Breakout: Buy if a stock breaks above its 52-week high
    ticker = random.choice(tickers)
    if prices[ticker][0] > max(prices[ticker]):
        return [Trade(ticker, random.randrange(1, 10))]
    else:
        return [] 

def trade18():
    # Volatility: If market volatility is high, sell (expecting it to decrease
    market_volatility = np.std([prices[t][0] / prices[t][1] for t in tickers])
    if market_volatility > 0.05:  # You'd adjust this threshold based on your risk tolerance
        ticker = random.choice(tickers)
        return [Trade(ticker, random.randrange(-10, -1))]
    else:
        return []

def trade19():
    # Golden Cross: Buy if the short-term moving average crosses above the long-term
    ticker = random.choice(tickers)
    short_ma = np.mean(prices[ticker][:5])
    long_ma = np.mean(prices[ticker][:20])
    if short_ma > long_ma and short_ma - long_ma < 0.01:  # Small margin to avoid false signals
        return [Trade(ticker, random.randrange(1, 10))]
    else:
        return []

def trade20():
    # Death Cross: Sell if the short-term moving average crosses below the long-term
    ticker = random.choice(tickers)
    short_ma = np.mean(prices[ticker][:5])
    long_ma = np.mean(prices[ticker][:20])
    if short_ma < long_ma and long_ma - short_ma < 0.01: 
        return [Trade(ticker, random.randrange(-10, -1))]
    else:
        return []

def trade21():
    # Correlated Pairs Buy: Buy a pair of stocks that have historically moved together
    correlations = np.corrcoef([prices[t] for t in tickers])
    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
    return [Trade(tickers[i], 1), Trade(tickers[j], 1)]

def trade22():
    # Correlated Pairs Sell: Sell a pair of stocks that have historically moved together
    correlations = np.corrcoef([prices[t] for t in tickers])
    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
    return [Trade(tickers[i], -1), Trade(tickers[j], -1)]

def trade23():
    # Contrarian Pairs Buy: Buy a stock that's down while its correlated pair is up
    correlations = np.corrcoef([prices[t] for t in tickers])
    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
    if prices[tickers[i]][0] < prices[tickers[i]][1] and prices[tickers[j]][0] > prices[tickers[j]][1]:
        return [Trade(tickers[i], 1)]
    else:
        return []

def trade24():
    # Contrarian Pairs Sell: Sell a stock that's up while its correlated pair is down
    correlations = np.corrcoef([prices[t] for t in tickers])
    i, j = np.unravel_index(np.argmax(correlations), correlations.shape)
    if prices[tickers[i]][0] > prices[tickers[i]][1] and prices[tickers[j]][0] < prices[tickers[j]][1]:
        return [Trade(tickers[i], -1)]
    else:
        return []

def trade25():
    # Correlation Reversal: Buy a stock that's recently become less correlated with the market
    # This is a simplified version, you'd likely use a rolling correlation window
    market_prices = [prices[t] for t in tickers]
    correlations_today = np.corrcoef(market_prices)
    correlations_yesterday = np.corrcoef([p[1:] for p in market_prices])
    diffs = correlations_today - correlations_yesterday
    i, j = np.unravel_index(np.argmin(diffs), diffs.shape)
    if i != j:  # Ensure we're not comparing a stock to itself
        return [Trade(tickers[i], 1)]
    else:
        return []

def trade26():
    # Sector Rotation: Buy the top 2 stocks from the sector that's most correlated with the market
    # Assuming you have sector data (e.g., 'sector_map' dict: ticker -> sector)
    sector_returns = {s: np.mean([(prices[t][0] - prices[t][1]) / prices[t][1] for t in tickers if sector_map[t] == s]) for s in set(sector_map.values())}
    top_sector = max(sector_returns, key=sector_returns.get)
    top_tickers_in_sector = sorted([(t, prices[t][0]) for t in tickers if sector_map[t] == top_sector], key=lambda x: x[1], reverse=True)[:2]
    return [Trade(t, 1) for t, _ in top_tickers_in_sector]

def trade27():
    # Beta-Weighted Portfolio: Allocate more to stocks with higher betas (more volatile
    # You'd need historical market data to calculate betas
    betas = {t: random.uniform(0.5, 2) for t in tickers}  # Placeholder for actual betas
    total_beta = sum(betas.values())
    allocations = {t: betas[t] / total_beta * 100 for t in tickers}
    return [Trade(t, int(allocations[t])) for t in tickers]

def trade28():
    # Diversified Portfolio: Buy a mix of stocks with low correlations to each other
    correlations = np.corrcoef([prices[t] for t in tickers])
    chosen_tickers = []
    while len(chosen_tickers) < 5 and len(tickers) > 0:
        t = random.choice(tickers)
        if all(correlations[tickers.index(t)][tickers.index(c)] < 0.5 for c in chosen_tickers):
            chosen_tickers.append(t)
            tickers.remove(t) 
    return [Trade(t, random.randrange(1, 3)) for t in chosen_tickers]

def trade29():
    # Cointegration: Find a pair of stocks that are cointegrated and trade their spread
    # This requires more complex analysis (e.g., using the Johansen test)
    # For simplicity, we'll just pick a random pair and assume cointegration
    i, j = random.sample(range(len(tickers)), 2)
    spread = prices[tickers[i]][0] - prices[tickers[j]][0]
    if spread > 0:
        return [Trade(tickers[i], -1), Trade(tickers[j], 1)] 
    else:
        return [Trade(tickers[i], 1), Trade(tickers[j], -1)]

def trade30():
    # Basket Trading: Buy or sell a basket of stocks based on their correlation to a benchmark
    # You'd need a benchmark ticker and its historical prices
    benchmark = "SPY"
    correlations = np.corrcoef([prices[t] for t in tickers + [benchmark]])[:-1, -1]  # Correlate each stock with the benchmark
    if np.mean(correlations) > 0.5:
        return [Trade(t, 1) for t in tickers]
    else:
        return [Trade(t, -1) for t in tickers]

def trade31():
    # Double Bottom: Buy when a stock forms a double bottom pattern
    ticker = random.choice(tickers)
    if prices[ticker][0] < prices[ticker][2] < prices[ticker][4] and prices[ticker][1] > prices[ticker][3]:
        return [Trade(ticker, 1)]
    else:
        return []

def trade32():
    # Double Top: Sell when a stock forms a double top pattern
    ticker = random.choice(tickers)
    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] < prices[ticker][3]:
        return [Trade(ticker, -1)]
    else:
        return []

def trade33():
    # Head and Shoulders: Sell when a stock forms a head and shoulders pattern
    ticker = random.choice(tickers)
    if prices[ticker][0] < prices[ticker][2] < prices[ticker][4] and prices[ticker][1] > prices[ticker][3] > prices[ticker][5]:
        return [Trade(ticker, -1)]
    else:
        return []

def trade34
    # Inverse Head and Shoulders: Buy when a stock forms an inverse head and shoulders pattern
    ticker = random.choice(tickers)
    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] < prices[ticker][3] < prices[ticker][5]:
        return [Trade(ticker, 1)]
    else:
        return []

def trade35():
    # Ascending Triangle: Buy when a stock forms an ascending triangle pattern
    ticker = random.choice(tickers)
    # Simplified logic: check for higher lows and flat highs
    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] == prices[ticker][3] == prices[ticker][5]:
        return [Trade(ticker, 1)]
    else:
        return []

def trade36():
    # Descending Triangle: Sell when a stock forms a descending triangle pattern
    ticker = random.choice(tickers)
    # Simplified logic: check for lower highs and flat lows
    if prices[ticker][0] < prices[ticker][2] < prices[ticker][4] and prices[ticker][1] == prices[ticker][3] == prices[ticker][5]:
        return [Trade(ticker, -1)]
    else:
        return []

def trade37():
    # Flag/Pennant: Buy or sell based on the direction of the flag/pennant pattern
    ticker = random.choice(tickers)
    # Simplified logic: check for a consolidation period after a strong move
    if abs(prices[ticker][0] - np.mean(prices[ticker][1:5])) < 0.05 and abs(prices[ticker][5] - prices[ticker][6]) > 0.1:
        # Buy if the prior move was up, sell if down
        return [Trade(ticker, 1 if prices[ticker][5] > prices[ticker][6] else -1)]
    else:
        return []

def trade38():
    # Gap Up: Buy when a stock opens significantly higher than its previous close
    ticker = random.choice(tickers)
    if prices[ticker][0] > prices[ticker][1] * 1.05:  # 5% gap up
        return [Trade(ticker, 1)]
    else:
        return []

def trade39():
    # Gap Down: Sell when a stock opens significantly lower than its previous close
    ticker = random.choice(tickers)
    if prices[ticker][0] < prices[ticker][1] * 0.95:  # 5% gap down
        return [Trade(ticker, -1)]
    else:
        return []

def trade40():
    # Rounding Bottom: Buy when a stock forms a rounding bottom pattern
    ticker = random.choice(tickers)
    # Simplified logic: check for a gradual price increase after a period of decline
    if prices[ticker][0] > prices[ticker][2] > prices[ticker][4] and prices[ticker][1] < prices[ticker][3] < prices[ticker][5]:
        return [Trade(ticker, 1)]
    else:
        return []

def trade41():
    # Overbought/Oversold (RSI): Sell if RSI is above 70, buy if below 30
    ticker = random.choice(tickers)
    rsi = calculate_rsi(prices[ticker], 14)  # Assuming you have an RSI calculation function
    if rsi > 70:
        return [Trade(ticker, -1)]
    elif rsi < 30:
        return [Trade(ticker, 1)]
    else:
        return []

def trade42():
    # Bollinger Bands Breakout: Buy if price breaks above the upper band, sell if below lower
    ticker = random.choice(tickers)
    upper, middle, lower = calculate_bollinger_bands(prices[ticker], 20, 2)  # Assuming you have a Bollinger Band calculation function
    if prices[ticker][0] > upper:
        return [Trade(ticker, 1)]
    elif prices[ticker][0] < lower:
        return [Trade(ticker, -1)]
    else:
        return []

def trade43():
    # Channel Breakout: Buy or sell when price breaks out of a recent price channel
    ticker = random.choice(tickers)
    highs = [max(prices[ticker][i:i+5]) for i in range(len(prices[ticker]) - 5)]
    lows = [min(prices[ticker][i:i+5]) for i in range(len(prices[ticker]) - 5)]
    if prices[ticker][0] > highs[-1]:
        return [Trade(ticker, 1)]
    elif prices[ticker][0] < lows[-1]:
        return [Trade(ticker, -1)]
    else:
        return []

def trade44():
    # Trend Following: Buy if the 20-day moving average is rising, sell if falling
    ticker = random.choice(tickers)
    ma20_today = np.mean(prices[ticker][:20])
    ma20_yesterday = np.mean(prices[ticker][1:21])
    if ma20_today > ma20_yesterday:
        return [Trade(ticker, 1)]
    elif ma20_today < ma20_yesterday:
        return [Trade(ticker, -1)]
    else:
        return []

def trade45():
    # MACD Crossover: Buy when MACD line crosses above signal line, sell when below
    ticker = random.choice(tickers)
    macd_line, signal_line = calculate_macd(prices[ticker])  # Assuming you have a MACD calculation function
    if macd_line[-1] > signal_line[-1] and macd_line[-2] <= signal_line[-2]:
        return [Trade(ticker, 1)]
    elif macd_line[-1] < signal_line[-1] and macd_line[-2] >= signal_line[-2]:
        return [Trade(ticker, -1)]
    else:
        return []

def trade46():
    # Stochastic Oscillator: Buy if %K crosses above %D in oversold zone, sell if opposite
    ticker = random.choice(tickers)
    k_line, d_line = calculate_stochastic(prices[ticker])  # Assuming you have a Stochastic calculation function
    if k_line[-1] > d_line[-1] and k_line[-1] < 20:
        return [Trade(ticker, 1)]
    elif k_line[-1] < d_line[-1] and k_line[-1] > 80:
        return [Trade(ticker, -1)]
    else:
        return []

def trade47():
    # Volume Spike: Buy if today's volume is much higher than the average
    # You'd need volume data for this strategy
    ticker = random.choice(tickers)
    avg_volume = np.mean(volumes[ticker][1:])  # Assuming you have 'volumes' data
    if volumes[ticker][0] > avg_volume * 2:
        return [Trade(ticker, 1)]
    else:
        return []

def trade48():
    # Price Spike: Buy if today's price increase is much higher than average daily change
    ticker = random.choice(tickers)
    daily_changes = [(prices[ticker][i] - prices[ticker][i + 1]) / prices[ticker][i + 1] for i in range(len(prices[ticker]) - 1)]
    avg_change = np.mean(daily_changes)
    today_change = (prices[ticker][0] - prices[ticker][1]) / prices[ticker][1]
    if today_change > avg_change * 2:
        return [Trade(ticker, 1)]
    else:
        return []

def trade49():
    # Mean Reversion (Long-term): Buy if the price is below its 200-day moving average
    ticker = random.choice(tickers)
    ma200 = np.mean(prices[ticker])
    if prices[ticker][0] < ma200:
        return [Trade(ticker, 1)]
    else:
        return []

def trade50():
    # Trend Reversal (Parabolic SAR): Buy or sell based on the Parabolic SAR indicator
    # Assuming you have a Parabolic SAR calculation function
    ticker = random.choice(tickers)
    sar = calculate_parabolic_sar(prices[ticker])
    if prices[ticker][0] > sar[-1]: 
        return [Trade(ticker, 1)]
    elif prices[ticker][0] < sar[-1]:
        return [Trade(ticker, -1)]
    else:
        return []

def trade51():
    # Market Outperformance: Buy stocks whose daily returns beat the market
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    outperformers = [t for t in tickers if (prices[t][0] - prices[t][1]) / prices[t][1] > market_return]
    if outperformers:
        ticker = random.choice(outperformers)
        return [Trade(ticker, 1)]
    else:
        return []

def trade52():
    # Market Underperformance: Short stocks whose daily returns lag the market
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    underperformers = [t for t in tickers if (prices[t][0] - prices[t][1]) / prices[t][1] < market_return]
    if underperformers:
        ticker = random.choice(underperformers)
        return [Trade(ticker, -1)]
    else:
        return []

def trade53():
    # Relative Strength to Market: Buy the stock with the highest relative strength to the market
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    relative_strengths = {t: ((prices[t][0] - prices[t][1]) / prices[t][1]) - market_return for t in tickers}
    ticker = max(relative_strengths, key=relative_strengths.get)
    return [Trade(ticker, 1)]

def trade54():
    # Relative Weakness to Market: Short the stock with the lowest relative strength to the market
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    relative_strengths = {t: ((prices[t][0] - prices[t][1]) / prices[t][1]) - market_return for t in tickers}
    ticker = min(relative_strengths, key=relative_strengths.get)
    return [Trade(ticker, -1)]

def trade55():
    # Sector vs. Market: Buy top stock from sector outperforming the market, short from underperforming
    # Assuming you have sector data (e.g., 'sector_map' dict: ticker -> sector)
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    sector_returns = {s: np.mean([(prices[t][0] - prices[t][1]) / prices[t][1] for t in tickers if sector_map[t] == s]) for s in set(sector_map.values())}
    outperforming_sectors = [s for s in sector_returns if sector_returns[s] > market_return]
    underperforming_sectors = [s for s in sector_returns if sector_returns[s] < market_return]
    trades = []
    if outperforming_sectors:
        top_ticker = max([(t, prices[t][0]) for t in tickers if sector_map[t] == random.choice(outperforming_sectors)], key=lambda x: x[1])[0]
        trades.append(Trade(top_ticker, 1))
    if underperforming_sectors:
        bottom_ticker = min([(t, prices[t][0]) for t in tickers if sector_map[t] == random.choice(underperforming_sectors)], key=lambda x: x[1])[0]
        trades.append(Trade(bottom_ticker, -1))
    return trades

def trade56():
    # Market-Neutral Pairs: Long/short pairs of stocks with similar market betas
    betas = {t: random.uniform(0.8, 1.2) for t in tickers}  # Placeholder, calculate actual betas
    pairs = [(t1, t2) for t1 in tickers for t2 in tickers if abs(betas[t1] - betas[t2]) < 0.1 and t1 != t2]
    if pairs:
        t1, t2 = random.choice(pairs)
        return [Trade(t1, 1), Trade(t2, -1)]
    else:
        return []

def trade57():
    # Beta Rotation: Buy high-beta stocks if the market is rising, low-beta if falling
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    betas = {t: random.uniform(0.5, 2) for t in tickers}  # Placeholder, calculate actual betas
    if market_return > 0:  # Market is rising
        target_beta = 1.5  # Example target for high-beta
    else:
        target_beta = 0.8   # Example target for low-beta
    closest_ticker = min(tickers, key=lambda t: abs(betas[t] - target_beta))
    return [Trade(closest_ticker, 1 if market_return > 0 else -1)]  # Buy if rising, short if falling

def trade58():
    # Market Timing with Relative Strength: Buy strong stocks in up markets, sell in down markets
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    market_return = (total_market_values[0] - total_market_values[1]) / total_market_values[1]
    relative_strengths = {t: ((prices[t][0] - prices[t][-1]) / prices[t][-1]) for t in tickers}  # Calculate over a longer period (e.g., 20 days)
    if market_return > 0:
        strongest = max(relative_strengths, key=relative_strengths.get)
        return [Trade(strongest, 1)]
    else:
        weakest = min(relative_strengths, key=relative_strengths.get)
        return [Trade(weakest, -1)]

def trade59():
    # Relative Value to Market: Buy stocks trading below their historical average relative to the market
    # Requires historical data to calculate averages
    total_market_values = [sum(prices[t][i] for t in tickers) for i in range(len(prices[tickers[0]]))]
    relative_values = {t: prices[t][0] / total_market_values[0] for t in tickers}  # Current relative value
    historical_averages = {t: 0.05 for t in tickers}  # Placeholder, calculate actual averages
    undervalued = [t for t in tickers if relative_values[t] < historical_averages[t] * 0.95]  # Allow some buffer
    if undervalued:
        ticker = random.choice(undervalued)
        return [Trade(ticker, 1)]
    else:
        return []

def trade60():
    # Market-Cap Weighted: Allocate trade amounts proportional to each stock's market cap relative to total market
    total_market_value = sum(prices[t][0] for t in tickers)
    market_caps = {t: prices[t][0] * 1000 for t in tickers}  # Assuming 1000 shares outstanding for each stock
    weights = {t: market_caps[t] / total_market_value for t in tickers}
    total_trade_amount = 100  # Example
    trades = [Trade(t, int(weights[t] * total_trade_amount)) for t in tickers]
    return trades