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();
 
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, reconnected } = JSON.parse(e.data);
  if (reconnected) oddsMap.clear(); // Snapshot novo a caminho
  console.log(`Stream ${stream_id} connected (${channel})`);
});
 
eventSource.addEventListener('snapshot', (e) => {
  const { odds, count, total, has_more } = JSON.parse(e.data);
  // Armazena objetos Odds completos indexados por ID
  for (const odd of odds) {
    oddsMap.set(odd.id, odd);
  }
  console.log(`Snapshot chunk: ${count} odds (${oddsMap.size}/${total} total)`);
});
 
eventSource.addEventListener('snapshot:complete', (e) => {
  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
    }
    // Se não houver entrada existente, a odd apareceu após nosso snapshot — aguarde o próximo snapshot
  }
  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`);
});
 
eventSource.addEventListener('ev:detected', (e) => {
  const opps = JSON.parse(e.data);
  opps.forEach(opp => console.log(`+EV: ${opp.selection} at ${opp.ev_percentage}%`));
});
 
eventSource.addEventListener('arb:detected', (e) => {
  const arbs = JSON.parse(e.data);
  arbs.forEach(arb => console.log(`Arb: ${arb.profit_percent}% profit`));
});
 
eventSource.addEventListener('middles:detected', (e) => {
  const middles = JSON.parse(e.data);
  middles.forEach(m => console.log(`Middle: ${m.event_name} — EV ${m.expected_value}%`));
});
 
eventSource.addEventListener('low_hold:detected', (e) => {
  const holds = JSON.parse(e.data);
  holds.forEach(h => console.log(`Low hold: ${h.hold_percentage}%`));
});
 
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();
 
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, reconnected } = JSON.parse(e.data);
  if (reconnected) oddsMap.clear();
  console.log(`Stream ${stream_id} connected (reconnected: ${reconnected})`);
});
 
es.addEventListener('snapshot', (e) => {
  const { odds } = JSON.parse(e.data);
  for (const odd of odds) {
    oddsMap.set(odd.id, odd);
  }
});
 
es.addEventListener('snapshot:complete', () => {
  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);
    if (existing) Object.assign(existing, 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 opps = JSON.parse(e.data);
  opps.forEach(opp =>
    console.log(`+EV: ${opp.selection} — ${opp.ev_percentage}% EV`)
  );
});
 
es.addEventListener('ev:expired', (e) => {
  const { expired } = JSON.parse(e.data);
  console.log(`EV expired: ${expired.length} opportunities`);
});
 
es.addEventListener('arb:detected', (e) => {
  const arbs = JSON.parse(e.data);
  arbs.forEach(arb =>
    console.log(`Arb: ${arb.profit_percent}% across ${arb.legs.length} legs`)
  );
});
 
es.addEventListener('arb:expired', (e) => {
  const { expired } = JSON.parse(e.data);
  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] = {}
 
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':
        if data.get('reconnected'):
            odds_map.clear()  # Snapshot novo a caminho
        print(f"Stream {data['stream_id']} connected ({data['channel']})")
 
    elif event.event == 'snapshot':
        # 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']} odds ({len(odds_map)}/{data['total']} total)")
 
    elif event.event == 'snapshot:complete':
        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)
        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")
 
    elif event.event == 'ev:detected':
        for opp in data:
            print(f"+EV: {opp['selection']} at {opp['ev_percentage']}%")
 
    elif event.event == 'ev:expired':
        print(f"EV expired: {len(data['expired'])} opportunities")
 
    elif event.event == 'arb:detected':
        for arb in data:
            print(f"Arb: {arb['profit_percent']}% profit")
 
    elif event.event == 'arb:expired':
        print(f"Arb expired: {len(data['expired'])} opportunities")
 
    elif event.event == 'middles:detected':
        for m in data:
            print(f"Middle: {m.get('event_name', '?')} — EV {m.get('expected_value', '?')}%")
 
    elif event.event == 'low_hold:detected':
        for h in data:
            print(f"Low hold: {h['hold_percentage']}%")
 
    elif event.event == 'heartbeat':
        pass  # keepalive silencioso