Stream Unificado

// Mapa local de odds — indexado pelo ID da odd, armazena objetos Odds completos do snapshot.
// Eventos delta são mesclados neste mapa pelo ID.
const oddsMap = new Map();
let resuming = false; // definido por `connected` com `resumed: true`
 
// Oportunidades por tipo, cada uma indexada por `id`. Um item de `:detected` é uma
// oportunidade nova OU uma versão atualizada de uma que você já tem (mesmo `id`).
const oppsByType = { ev: new Map(), arbitrage: new Map(), middles: new Map(), low_hold: new Map() };
 
// Upsert por `id`. Retorna true apenas na primeira vez que um `id` aparece —
// alerte nisso, não em cada item de `:detected`.
function upsertOpp(type, opp) {
  const isNew = !oppsByType[type].has(opp.id);
  oppsByType[type].set(opp.id, opp); // substitui a versão que você tinha
  return isNew;
}
 
const eventSource = new EventSource(
  'https://api.sharpapi.io/api/v1/stream?channel=all&league=nba&api_key=YOUR_KEY'
);
 
eventSource.addEventListener('connected', (e) => {
  const { stream_id, channel, resumed } = JSON.parse(e.data);
  // Mantenha as odds locais só num resume (`resumed: true`): aí os deltas perdidos são
  // reenviados em vez de um snapshot. Qualquer outra conexão é seguida de um snapshot
  // completo — limpe agora. Não use `reconnected`: ele também é `true` num resume.
  resuming = resumed === true;
  if (!resuming) oddsMap.clear();
  // Oportunidades nunca são retomadas: cada conexão as reenvia no `snapshot`.
  for (const map of Object.values(oppsByType)) map.clear();
  console.log(`Stream ${stream_id} connected (${channel})`);
});
 
eventSource.addEventListener('snapshot', (e) => {
  const data = JSON.parse(e.data);
  // Um snapshot depois de `resumed: true` significa que o servidor desistiu do resume:
  // este snapshot substitui seu estado.
  if (resuming) {
    oddsMap.clear();
    resuming = false;
  }
  // Fragmentos de oportunidades trazem `ev` / `arbitrage` / `middles` / `low_hold` em vez de `odds`
  for (const type of Object.keys(oppsByType)) {
    for (const opp of data[type] ?? []) oppsByType[type].set(opp.id, opp);
  }
  if (!data.odds) return;
  // Armazena objetos Odds completos indexados por ID
  for (const odd of data.odds) {
    oddsMap.set(odd.id, odd);
  }
  console.log(`Snapshot chunk: ${data.count} odds (${oddsMap.size}/${data.total} total)`);
});
 
eventSource.addEventListener('snapshot:complete', (e) => {
  const { mode } = JSON.parse(e.data); // "resume", "full_resync" ou ausente numa primeira conexão
  // Um snapshot completo pode chegar sem nenhum chunk de `snapshot` — nada mais
  // corresponde aos seus filtros —, então a limpeza no handler de `snapshot` nunca rodou.
  // A checagem de `resuming` evita apagar um snapshot que você acabou de guardar.
  if (mode === 'full_resync' && resuming) oddsMap.clear();
  resuming = false;
  console.log(`Snapshot complete: ${oddsMap.size} odds loaded`);
});
 
eventSource.addEventListener('odds:update', (e) => {
  const { odds, book } = JSON.parse(e.data);
  // Mescla deltas compactos no estado local — apenas campos dinâmicos são enviados
  for (const delta of odds) {
    const existing = oddsMap.get(delta.id);
    if (existing) {
      Object.assign(existing, delta); // Mescla campos alterados
    } else {
      // Um `id` que você ainda não tem chega como linha completa — guarde como está
      oddsMap.set(delta.id, delta);
    }
  }
  console.log(`${book}: ${odds.length} odds updated`);
});
 
eventSource.addEventListener('odds:removed', (e) => {
  const { ids, book } = JSON.parse(e.data);
  for (const id of ids) {
    oddsMap.delete(id);
  }
  console.log(`${book}: ${ids.length} odds removed`);
});
 
// Cada item de `:detected` é salvo com upsert; só um `id` visto pela primeira vez é registrado como novo.
eventSource.addEventListener('ev:detected', (e) => {
  const { opportunities: opps } = JSON.parse(e.data);
  opps.forEach(opp => {
    if (upsertOpp('ev', opp)) console.log(`+EV: ${opp.selection} at ${opp.ev_percentage}%`);
  });
});
 
eventSource.addEventListener('arb:detected', (e) => {
  const { opportunities: arbs } = JSON.parse(e.data);
  arbs.forEach(arb => {
    if (upsertOpp('arbitrage', arb)) console.log(`Arb: ${arb.profit_percent}% profit`);
  });
});
 
eventSource.addEventListener('middles:detected', (e) => {
  const { opportunities: middles } = JSON.parse(e.data);
  middles.forEach(m => {
    if (upsertOpp('middles', m)) console.log(`Middle: ${m.event_name} — EV ${m.expected_value}%`);
  });
});
 
eventSource.addEventListener('low_hold:detected', (e) => {
  const { opportunities: holds } = JSON.parse(e.data);
  holds.forEach(h => {
    if (upsertOpp('low_hold', h)) console.log(`Low hold: ${h.hold_percentage}%`);
  });
});
 
// `:expired` lista os ids que sumiram. Esqueça-os, para que um `id` que
// volte depois conte como novo de novo.
for (const prefix of ['ev', 'arb', 'middles', 'low_hold']) {
  eventSource.addEventListener(`${prefix}:expired`, (e) => {
    const { expired, type } = JSON.parse(e.data); // type: 'ev' | 'arbitrage' | 'middles' | 'low_hold'
    for (const id of expired) oppsByType[type].delete(id);
  });
}
 
eventSource.addEventListener('heartbeat', () => {
  console.log('Connection alive');
});
 
eventSource.onerror = () => {
  console.log('Connection lost, auto-reconnecting...');
};

import EventSource from 'eventsource';
 
// Mapa local de odds — indexado pelo ID da odd
const oddsMap = new Map();
let resuming = false; // definido por `connected` com `resumed: true`
// Oportunidades indexadas por `id` — `:detected` traz itens novos E atualizados
const evMap = new Map();
const arbMap = new Map();
 
const es = new EventSource(
  'https://api.sharpapi.io/api/v1/stream?channel=all&sport=basketball&league=nba',
  { headers: { 'X-API-Key': 'YOUR_KEY' } }
);
 
es.addEventListener('connected', (e) => {
  const { stream_id, resumed } = JSON.parse(e.data);
  // Só um resume (`resumed: true`) mantém o estado; senão, um snapshot chega.
  resuming = resumed === true;
  if (!resuming) oddsMap.clear();
  evMap.clear(); // oportunidades nunca são retomadas — o snapshot as reenvia
  arbMap.clear();
  console.log(`Stream ${stream_id} connected (resumed: ${resumed ?? 'fresh'})`);
});
 
es.addEventListener('snapshot', (e) => {
  // Snapshot depois de `resumed: true`: o resume foi abandonado e o snapshot substitui o estado
  if (resuming) {
    oddsMap.clear();
    resuming = false;
  }
  // Fragmentos de oportunidades trazem `ev` / `arbitrage` / ... em vez de `odds`
  const { odds, ev, arbitrage } = JSON.parse(e.data);
  for (const odd of odds ?? []) {
    oddsMap.set(odd.id, odd);
  }
  for (const opp of ev ?? []) evMap.set(opp.id, opp);
  for (const arb of arbitrage ?? []) arbMap.set(arb.id, arb);
});
 
es.addEventListener('snapshot:complete', (e) => {
  const { mode } = JSON.parse(e.data); // "resume", "full_resync" ou ausente numa primeira conexão
  // Um snapshot completo sem linhas correspondentes não envia chunk de `snapshot`: limpe aqui também
  if (mode === 'full_resync' && resuming) oddsMap.clear();
  resuming = false;
  console.log(`Ready: ${oddsMap.size} odds loaded`);
});
 
es.addEventListener('odds:update', (e) => {
  const { odds, book } = JSON.parse(e.data);
  // Mescla deltas compactos nos objetos locais completos
  for (const delta of odds) {
    const existing = oddsMap.get(delta.id);
    // Um `id` que você ainda não tem chega como linha completa — guarde como está
    if (existing) Object.assign(existing, delta);
    else oddsMap.set(delta.id, delta);
  }
  console.log(`${book}: ${odds.length} odds updated`);
});
 
es.addEventListener('odds:removed', (e) => {
  const { ids, book } = JSON.parse(e.data);
  for (const id of ids) oddsMap.delete(id);
  console.log(`${book}: ${ids.length} odds removed`);
});
 
es.addEventListener('ev:detected', (e) => {
  const { opportunities } = JSON.parse(e.data);
  for (const opp of opportunities) {
    const isNew = !evMap.has(opp.id);
    evMap.set(opp.id, opp); // upsert — um id conhecido é uma atualização (novo preço / EV%)
    if (isNew) console.log(`+EV: ${opp.selection} — ${opp.ev_percentage}% EV`);
  }
});
 
es.addEventListener('ev:expired', (e) => {
  const { expired } = JSON.parse(e.data);
  for (const id of expired) evMap.delete(id);
  console.log(`EV expired: ${expired.length} opportunities`);
});
 
es.addEventListener('arb:detected', (e) => {
  const { opportunities } = JSON.parse(e.data);
  for (const arb of opportunities) {
    const isNew = !arbMap.has(arb.id);
    arbMap.set(arb.id, arb); // upsert — um id conhecido é uma atualização (novas odds das pernas)
    if (isNew) console.log(`Arb: ${arb.profit_percent}% across ${arb.legs.length} legs`);
  }
});
 
es.addEventListener('arb:expired', (e) => {
  const { expired } = JSON.parse(e.data);
  for (const id of expired) arbMap.delete(id);
  console.log(`Arb expired: ${expired.length} opportunities`);
});
 
es.onerror = (err) => {
  console.error('Stream error:', err.message);
};

import sseclient
import requests
import json
 
url = 'https://api.sharpapi.io/api/v1/stream'
params = {
    'channel': 'all',
    'sport': 'basketball',
    'league': 'nba',
}
headers = {'X-API-Key': 'YOUR_KEY'}
 
# Dicionário local de odds — indexado pelo ID da odd, armazena objetos completos do snapshot
odds_map: dict[str, dict] = {}
resuming = False  # definido por 'connected' com resumed True
 
# Oportunidades por tipo, cada uma indexada por id. Um item de `:detected` é uma
# oportunidade nova OU uma versão atualizada de uma que você já tem (mesmo id).
opps_by_type: dict[str, dict[str, dict]] = {
    'ev': {}, 'arbitrage': {}, 'middles': {}, 'low_hold': {},
}
 
def upsert_opp(opp_type: str, opp: dict) -> bool:
    """Upsert por id. True apenas na primeira vez que um id aparece — alerte nisso."""
    is_new = opp['id'] not in opps_by_type[opp_type]
    opps_by_type[opp_type][opp['id']] = opp  # substitui a versão que você tinha
    return is_new
 
response = requests.get(url, params=params, headers=headers, stream=True)
client = sseclient.SSEClient(response)
 
for event in client.events():
    data = json.loads(event.data) if event.data else {}
 
    if event.event == 'connected':
        # Só um resume (resumed True) mantém o estado: aí o servidor reenvia os deltas
        # perdidos. Todo o resto é seguido de um snapshot completo.
        resuming = data.get('resumed') is True
        if not resuming:
            odds_map.clear()
        # Oportunidades nunca são retomadas: cada conexão as reenvia no `snapshot`.
        for held in opps_by_type.values():
            held.clear()
        print(f"Stream {data['stream_id']} connected ({data['channel']})")
 
    elif event.event == 'snapshot':
        # Snapshot depois de resumed True: o servidor desistiu do resume, este
        # snapshot substitui seu estado.
        if resuming:
            odds_map.clear()
            resuming = False
        # Fragmentos de oportunidades trazem 'ev' / 'arbitrage' / 'middles' / 'low_hold' em vez de 'odds'
        for opp_type, held in opps_by_type.items():
            for opp in data.get(opp_type, []):
                held[opp['id']] = opp
        # Armazena objetos completos de odds indexados por ID
        for odd in data.get('odds', []):
            odds_map[odd['id']] = odd
        print(f"Snapshot chunk: {data['count']} items ({data['offset'] + data['count']}/{data['total']})")
 
    elif event.event == 'snapshot:complete':
        # Um snapshot completo sem linhas correspondentes não envia chunk: limpe aqui também
        if data.get('mode') == 'full_resync' and resuming:
            odds_map.clear()
        resuming = False
        print(f"Ready: {len(odds_map)} odds loaded")
 
    elif event.event == 'odds:update':
        # Mescla deltas compactos no estado local
        for delta in data.get('odds', []):
            existing = odds_map.get(delta['id'])
            if existing:
                existing.update(delta)
            else:
                # Um id que você ainda não tem chega como linha completa — guarde como está
                odds_map[delta['id']] = delta
        print(f"{data['book']}: {data['count']} odds updated")
 
    elif event.event == 'odds:removed':
        for odd_id in data.get('ids', []):
            odds_map.pop(odd_id, None)
        print(f"{data['book']}: {data['count']} odds removed")
 
    # Cada item de `:detected` é salvo com upsert; só um id visto pela primeira vez é impresso como novo.
    elif event.event == 'ev:detected':
        for opp in data['opportunities']:
            if upsert_opp('ev', opp):
                print(f"+EV: {opp['selection']} at {opp['ev_percentage']}%")
 
    elif event.event == 'arb:detected':
        for arb in data['opportunities']:
            if upsert_opp('arbitrage', arb):
                print(f"Arb: {arb['profit_percent']}% profit")
 
    elif event.event == 'middles:detected':
        for m in data['opportunities']:
            if upsert_opp('middles', m):
                print(f"Middle: {m.get('event_name', '?')} — EV {m.get('expected_value', '?')}%")
 
    elif event.event == 'low_hold:detected':
        for h in data['opportunities']:
            if upsert_opp('low_hold', h):
                print(f"Low hold: {h['hold_percentage']}%")
 
    elif event.event in ('ev:expired', 'arb:expired', 'middles:expired', 'low_hold:expired'):
        # 'type' é 'ev', 'arbitrage', 'middles' ou 'low_hold'. Esqueça os ids,
        # para que um id que volte depois conte como novo de novo.
        for opp_id in data['expired']:
            opps_by_type[data['type']].pop(opp_id, None)
        print(f"{data['type']} expired: {len(data['expired'])} opportunities")
 
    elif event.event == 'heartbeat':
        pass  # keepalive silencioso