Real-time APIs

import videodb

conn = videodb.connect()
coll = conn.get_collection()
rtstream = coll.get_rtstream("rts-xxx")

# Index visuals with a prompt
scene_index = rtstream.index_visuals(
    prompt="Describe activity and detect unusual behavior",
    batch_config={"type": "time", "value": 5, "frame_count": 2}
)

# Create a reusable event
event_id = conn.create_event(
    event_prompt="Detect when someone enters restricted area",
    label="intrusion_detected"
)

# Set up alert
alert_id = scene_index.create_alert(
    event_id=event_id,
    callback_url="https://your-backend.com/webhooks/alerts"
)

import { connect } from 'videodb';

const conn = await connect();
const coll = await conn.getCollection();
const rtstream = await coll.getRtstream("rts-xxx");

// Index visuals with a prompt
const sceneIndex = await rtstream.indexVisuals({
    prompt: "Describe activity and detect unusual behavior",
    batchConfig: { type: "time", value: 5, frameCount: 2 }
});

// Create a reusable event
const eventId = await conn.createEvent(
    "Detect when someone enters restricted area",
    "intrusion_detected"
);

// Set up alert
const alertId = await sceneIndex.createAlert(
    eventId,
    "https://your-backend.com/webhooks/alerts"
);

scene_index = rtstream.index_visuals(
    prompt="Describe the scene and highlight congestion",
    batch_config={"type": "time", "value": 5, "frame_count": 2},
    name="traffic_monitor",
    ws_connection_id=ws.connection_id  # optional, for real-time events
)

const sceneIndex = await rtstream.indexVisuals({
    prompt: "Describe the scene and highlight congestion",
    batchConfig: { type: "time", value: 5, frameCount: 2 },
    name: "traffic_monitor",
    wsConnectionId: ws.connectionId  // optional
});

# List all indexes
indexes = rtstream.list_scene_indexes()

# Get specific index
scene_index = rtstream.get_scene_index(index_id)

# Poll scenes
scenes = scene_index.get_scenes(
    start=0, end=None, page=1, page_size=100
)

// List all indexes
const indexes = await rtstream.listSceneIndexes();

// Get specific index
const sceneIndex = await rtstream.getSceneIndex(indexId);

// Poll scenes
const scenes = await sceneIndex.getScenes({
    start: 0, end: null, page: 1, pageSize: 100
});

audio_index = rtstream.index_audio(
    prompt="Identify key speakers and main topics",
    batch_config={"type": "word", "value": 50}
)

const audioIndex = await rtstream.indexAudio({
    prompt: "Identify key speakers and main topics",
    batchConfig: { type: "word", value: 50 }
});

# Start transcription
rtstream.start_transcript(ws_connection_id=ws.connection_id)

# Stop transcription
rtstream.stop_transcript(mode="graceful")

# Poll transcripts
transcript = rtstream.get_transcript(
    start=0, page=1, page_size=100
)

// Start transcription
await rtstream.startTranscript(ws.connectionId);

// Stop transcription
await rtstream.stopTranscript("graceful");

// Poll transcripts
const transcript = await rtstream.getTranscript({
    start: 0, page: 1, pageSize: 100
});

results = rtstream.search(
    query="white car moving fast",
    score_threshold=0.5
)

for shot in results.shots:
    print(f"Match at {shot.start}: {shot.text}")
    shot.play()  # Opens in browser

const results = await rtstream.search({
    query: "white car moving fast",
    scoreThreshold: 0.5
});

for (const shot of results.shots) {
    console.log(`Match at ${shot.start}: ${shot.text}`);
    await shot.play();
}

# Generate stream with player metadata
player_url = rtstream.generate_stream(
    start=1711000000,
    end=1711003600,
    player_config={
        "title": "Live Feed Recording",
        "description": "Camera 1 - Front entrance",
        "slug": "cam1-front"
    }
)

# generate_stream() returns the player_url
# Both URLs are also stored on the instance
print(rtstream.player_url)   # Shareable player URL (same as return value)
print(rtstream.stream_url)   # Raw HLS stream URL (.m3u8)

// Generate stream with player metadata
const playerUrl = await rtstream.generateStream({
    start: 1711000000,
    end: 1711003600,
    playerConfig: {
        title: "Live Feed Recording",
        description: "Camera 1 - Front entrance",
        slug: "cam1-front"
    }
});

// generateStream() returns the playerUrl
// Both URLs are also stored on the instance
console.log(rtstream.playerUrl);   // Shareable player URL (same as return value)
console.log(rtstream.streamUrl);   // Raw HLS stream URL (.m3u8)

# Generate embed code (requires generate_stream() first)
rtstream.generate_stream(start=start_ts, end=end_ts)
embed_html = rtstream.get_embed_code()

// Generate embed code (requires generateStream() first)
await rtstream.generateStream({ start: startTs, end: endTs });
const embedHtml = rtstream.getEmbedCode();

event_id = conn.create_event(
    event_prompt="Detect pedestrians crossing the zebra",
    label="pedestrian_detected"
)

const eventId = await conn.createEvent(
    "Detect pedestrians crossing the zebra",
    "pedestrian_detected"
);

alert_id = scene_index.create_alert(
    event_id=event_id,
    callback_url="https://your-backend.com/webhooks/alerts",
    ws_connection_id=ws.connection_id  # optional
)

const alertId = await sceneIndex.createAlert(
    eventId,
    "https://your-backend.com/webhooks/alerts",
    ws.connectionId  // optional
);

# List alerts
alerts = scene_index.list_alerts()

# Enable/disable
scene_index.enable_alert(alert_id)
scene_index.disable_alert(alert_id)

// List alerts
const alerts = await sceneIndex.listAlerts();

// Enable/disable
await sceneIndex.enableAlert(alertId);
await sceneIndex.disableAlert(alertId);

ws = conn.connect_websocket()
await ws.connect()

# Pass ws_connection_id to methods
rtstream.start_transcript(ws_connection_id=ws.connection_id)

# Receive events
async for ev in ws.stream():
    channel = ev.get("channel")

    if channel == "transcript":
        print(f"TRANSCRIPT: {ev['data']['text']}")
    elif channel == "scene_index":
        print(f"SCENE: {ev['data']['text']}")
    elif channel == "alert":
        print(f"ALERT: {ev['data']}")

const ws = conn.connectWebsocket();
await ws.connect();

// Pass wsConnectionId to methods
await rtstream.startTranscript(ws.connectionId);

// Receive events
for await (const ev of ws.stream()) {
    const channel = ev.channel;

    if (channel === "transcript") {
        console.log(`TRANSCRIPT: ${ev.data.text}`);
    } else if (channel === "scene_index") {
        console.log(`SCENE: ${ev.data.text}`);
    } else if (channel === "alert") {
        console.log(`ALERT: ${ev.data}`);
    }
}