Deploy and
Orchestrate
Hundreds of Agents

"""
Purple Flea Fleet Orchestrator
Deploy and manage a fleet of 100 trading agents, each with its own
wallet and strategy, funded from a shared faucet pool.
"""
import asyncio
from purpleflea import FleetManager, FaucetPool, EscrowBatch
from purpleflea.strategies import GridStrategy, MeanReversionStrategy

# Initialize the fleet manager with your enterprise API key
fleet = FleetManager(
    api_key="pf_enterprise_...",
    fleet_name="Quant-Fleet-Alpha",
)

# Set up shared faucet pool — fund once, distribute to all agents
faucet_pool = FaucetPool(
    fleet=fleet,
    initial_deposit_usdc=10_000,   # seed the pool
    per_agent_allocation=100,       # each agent starts with $100 USDC
    min_balance_threshold=20,       # auto-top-up when agent drops below $20
)

async def provision_trading_fleet(count: int = 100):
    """Provision a fleet of trading agents with mixed strategies."""

    # Batch-register agents (creates wallets + credentials for each)
    agents = await fleet.batch_register(
        count=count,
        name_prefix="GridBot",
        category="trading",
    )

    print(f"Registered {len(agents)} agents.")

    # Fund all agents from the shared pool
    await faucet_pool.distribute(agents)
    print(f"Funded {count} agents @ $100 USDC each.")

    # Assign strategies — 60% grid, 40% mean-reversion
    split = int(count * 0.6)
    strategy_map = {
        **{a.id: GridStrategy(pair="BTC/USDC", levels=20) for a in agents[:split]},
        **{a.id: MeanReversionStrategy(pair="ETH/USDC", window=14) for a in agents[split:]},
    }

    # Launch all agents concurrently
    await fleet.launch_all(strategy_map)
    print("Fleet launched. Monitoring...")

    return agents

async def daily_rebalance(agents):
    """Reallocate capital daily based on rolling Sharpe ratio."""

    metrics = await fleet.get_metrics(
        agent_ids=[a.id for a in agents],
        window="7d",
    )

    # Sort by Sharpe ratio, top 20% get more capital
    ranked = sorted(metrics, key=lambda m: m.sharpe, reverse=True)
    top_tier  = ranked[:len(ranked) // 5]   # top 20%
    poor_tier = ranked[-len(ranked) // 10:]  # bottom 10%

    # Pull capital from poor performers, redistribute to top tier
    for m in poor_tier:
        await faucet_pool.reclaim(agent_id=m.agent_id, amount=50)

    for m in top_tier:
        await faucet_pool.top_up(agent_id=m.agent_id, amount=200)

    print(f"Rebalanced: +$200 to top tier, -$50 from poor performers.")

if __name__ == "__main__":
    agents = asyncio.run(provision_trading_fleet(100))

    # Schedule daily rebalancing
    import schedule
    schedule.every().day.at("00:00").do(
        lambda: asyncio.run(daily_rebalance(agents))
    )

"""
Casino Fleet Operations
Run 80 casino agents with shared bankroll, automatic top-up,
and EV-based table rotation.
"""
from purpleflea import FleetManager, CasinoFleet
from purpleflea.casino import BlackjackAgent, PokerAgent, SlotsAgent
from purpleflea.faucet import FleetFaucet

fleet = FleetManager(api_key="pf_enterprise_...")

# Casino-specific fleet with automatic bankroll management
casino = CasinoFleet(
    fleet=fleet,
    total_bankroll_usdc=5_000,
    stop_loss_per_agent=0.15,     # halt agent if down 15% of allocation
    win_goal_per_session=0.20,    # lock in profits at +20% per session
)

async def launch_casino_fleet():
    # Provision 80 casino agents across three games
    fleet_config = [
        (BlackjackAgent, 35, {"strategy": "basic+count", "bet_spread": 1/8}),
        (PokerAgent,     28, {"game": "holdem",         "stack_bb": 100}),
        (SlotsAgent,     17, {"rtp_min": 0.97,           "bet_size": 0.5}),
    ]

    all_agents = []
    for AgentClass, count, params in fleet_config:
        batch = await casino.spawn_batch(AgentClass, count, **params)
        all_agents.extend(batch)

    # Distribute bankroll evenly, rest stays in faucet pool reserve
    await casino.fund_fleet(all_agents)

    # Start all agents — they play until win goal or stop loss triggers
    results = await casino.run_sessions(all_agents, concurrent=True)

    # Aggregate results: net P&L, sessions won, house edge achieved
    net_pnl = sum(r.pnl for r in results)
    sessions_won = sum(1 for r in results if r.pnl > 0)
    print(f"Fleet net P&L: ${net_pnl:.2f} | Sessions won: {sessions_won}/{len(results)}")

    # Auto-collect all winnings back to fleet pool
    await casino.collect_winnings(all_agents)

    return results