Meet the Fleet

import ccxt, pandas as pd, asyncio
from ta.trend import EMAIndicator
from ta.volatility import AverageTrueRange

MIN_VOLUME_24H = 20_000_000
LEVERAGE       = 20
SCAN_INTERVAL  = 600

def get_market_regime(exchange):
    anchors = ['BTC/USDT:USDT', 'ETH/USDT:USDT']
    votes   = []
    for symbol in anchors:
        ohlcv = exchange.fetch_ohlcv(symbol, '1h', limit=50)
        df    = pd.DataFrame(ohlcv, columns=['t','o','h','l','c','v'])
        df['ema9']  = EMAIndicator(df['c'], window=9).ema_indicator()
        df['ema21'] = EMAIndicator(df['c'], window=21).ema_indicator()
        votes.append(df['ema9'].iloc[-1] > df['ema21'].iloc[-1])
    return 'bull' if votes.count(True) >= 3 else 'bear'

def is_valid_pullback(df):
    last  = df.iloc[-1]
    prev  = df.iloc[-2]
    ema21 = df['ema21'].iloc[-1]
    near_ema    = abs(last['l'] - ema21) / ema21 < 0.003
    wick_reject = (last['c'] - last['l']) / (last['h'] - last['l'] + 1e-9) > 0.65
    confirmed   = last['c'] > prev['c']
    return near_ema and wick_reject and confirmed

def calc_sl_tp(df, entry):
    atr = AverageTrueRange(df['h'], df['l'], df['c'], window=14).average_true_range().iloc[-1]
    return {'sl': round(entry - 1.5 * atr, 4), 'tp': round(entry + 3.0 * atr, 4)}

async def scan_cycle(exchange, bot):
    while True:
        regime = get_market_regime(exchange)
        if regime == 'bear':
            await bot.send("[Loutias] Regime: BEAR — standing down.")
            await asyncio.sleep(SCAN_INTERVAL)
            continue
        markets = [m for m in exchange.fetch_tickers().values()
                   if m.get('quoteVolume', 0) >= MIN_VOLUME_24H]
        for market in markets:
            ohlcv = exchange.fetch_ohlcv(market['symbol'], '15m', limit=60)
            df    = pd.DataFrame(ohlcv, columns=['t','o','h','l','c','v'])
            df['ema21'] = EMAIndicator(df['c'], window=21).ema_indicator()
            if is_valid_pullback(df):
                entry  = df['c'].iloc[-1]
                levels = calc_sl_tp(df, entry)
                await bot.send(f"LONG {market['symbol']} @ {entry}")
        await asyncio.sleep(SCAN_INTERVAL)

import openai, asyncio, base64, ccxt

async def validate_with_vision(chart_path, signal):
    client = openai.AsyncOpenAI()
    with open(chart_path, 'rb') as f:
        b64 = base64.b64encode(f.read()).decode()
    response = await client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": [
            {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{b64}"}},
            {"type": "text", "text": f"Validate {signal['side']} setup. EMA pullback visible? YES/NO + reason."}
        ]}]
    )
    return response.choices[0].message.content.startswith('YES')

async def execute_order(exchange, signal, validated):
    if not validated:
        return {'status': 'rejected', 'reason': 'vision check failed'}
    order = await exchange.create_order(
        symbol=signal['symbol'], type='market',
        side=signal['side'].lower(), amount=signal['amount'],
    )
    return order

async def handle_signal(signal, bot, exchange):
    chart  = await capture_chart(signal['symbol'])
    ok     = await validate_with_vision(chart, signal)
    result = await execute_order(exchange, signal, ok)
    await bot.send_message(f"[Loudevoir] {result.get('status','filled')} — {signal['symbol']}")

import feedparser, asyncio, openai, aiohttp

FEEDS = ['https://cointelegraph.com/rss', 'https://cryptonews.com/news/feed/']
FNG_API = 'https://api.alternative.me/fng/?limit=1'

async def fetch_fear_greed():
    async with aiohttp.ClientSession() as s:
        async with s.get(FNG_API) as r:
            data = await r.json()
    return int(data['data'][0]['value']), data['data'][0]['value_classification']

async def analyze_headlines(headlines):
    prompt = "\n".join(f"- {h}" for h in headlines[:15])
    client = openai.AsyncOpenAI()
    resp = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content":
            f"Crypto news sentiment:\n{prompt}\nReturn: BULLISH/BEARISH/NEUTRAL + 1 sentence."}]
    )
    return resp.choices[0].message.content

async def hourly_report(bot):
    while True:
        articles = []
        for url in FEEDS:
            feed = feedparser.parse(url)
            articles += [e.title for e in feed.entries[:10]]
        fng_val, fng_lbl = await fetch_fear_greed()
        analysis = await analyze_headlines(articles)
        await bot.send_message(f"Market Pulse | F&G: {fng_val} ({fng_lbl})\n{analysis}")
        await asyncio.sleep(3600)

@app.post("/webhook")
def receive_webhook():
    update = request.get_json(silent=True)
    message = update.get("message") or update.get("edited_message")
    _handle_message(message)
    return "ok", 200

def _handle_message(message):
    text = message.get("text", "").strip()
    result = call_loumielle(text, sender_id=sender_id)
    action = result["data_extraction"]["action"]

    if action in ("ADD_EXPENSE", "ADD_INCOME"):
        insert_transaction(data, sender_id=sender_id)

    elif action == "VIEW_STATUS":
        # binance_pnl, binance_balance, monthly_summary…
        report = build_report(query_type, sender_id=sender_id)
        reply = f"{ai_response}\n\n{report}"

    send_message(chat_id, reply)

# Auto-sync Binance every hour
scheduler.add_job(sync_all, "interval", hours=1)

# Auto-report: every Sunday 20:00 + last day of month
scheduler.add_job(auto_weekly_report,  "cron", day_of_week="sun", hour=20)
scheduler.add_job(auto_monthly_report, "cron", day="last",        hour=20)