Stream Lifecycle

import videodb

conn = videodb.connect()
coll = conn.get_collection()

# Get existing stream
rtstream = coll.get_rtstream("rts-xxx")

# Control lifecycle
rtstream.stop()   # Pause ingestion
rtstream.start()  # Resume ingestion

import { connect } from 'videodb';

const conn = await connect();
const coll = await conn.getCollection();

// Get existing stream
const rtstream = await coll.getRTStream("rts-xxx");

// Control lifecycle
await rtstream.stop();   // Pause ingestion
await rtstream.start();  // Resume ingestion

# Pause ingestion (stream remains configured)
rtstream.stop()

# Resume ingestion
rtstream.start()

// Pause ingestion
await rtstream.stop();

// Resume ingestion
await rtstream.start();

# Export a stopped stream as a video/audio asset
result = rtstream.export(name="my_recording")

# RTStreamExportResult attributes
print(result.video_id)     # "m-xxx"
print(result.stream_url)   # HLS stream URL
print(result.player_url)   # Player URL (None for audio-only)
print(result.duration)     # Duration in seconds

# Generate embed code from export
embed_html = result.get_embed_code()

// Export a stopped stream as a video/audio asset
const result = await rtstream.export("my_recording");

// RTStreamExportResult attributes
console.log(result.videoId);    // "m-xxx"
console.log(result.streamUrl);  // HLS stream URL
console.log(result.playerUrl);  // Player URL (null for audio-only)
console.log(result.duration);   // Duration in seconds

// Generate embed code from export
const embedHtml = result.getEmbedCode();

scene_index = rtstream.get_scene_index(index_id)

# Pause indexing (stream continues)
scene_index.stop()

# Resume indexing
scene_index.start()

const sceneIndex = await rtstream.getSceneIndex(indexId);

// Pause indexing
await sceneIndex.stop();

// Resume indexing
await sceneIndex.start();

meeting = conn.record_meeting(
    meeting_url="https://meet.google.com/abc-defg-hij",
    bot_name="Meeting Recorder",
    bot_image_url="https://your-domain.com/bot-avatar.jpg",
    meeting_title="Weekly Standup",
    callback_url="https://your-backend.com/webhooks/meeting",
    callback_data={"internal_id": "123"}
)
print(f"Recording started: {meeting.id}")

const meeting = await conn.recordMeeting({
    meetingUrl: "https://meet.google.com/abc-defg-hij",
    botName: "Meeting Recorder",
    botImageUrl: "https://your-domain.com/bot-avatar.jpg",
    meetingTitle: "Weekly Standup",
    callbackUrl: "https://your-backend.com/webhooks/meeting",
    callbackData: { internalId: "123" }
});
console.log(`Recording started: ${meeting.id}`);

coll = conn.get_collection("your-collection-id")

meeting = coll.record_meeting(
    meeting_url="https://zoom.us/j/123456789",
    bot_name="Team Recorder",
    meeting_title="Sprint Planning",
    callback_url="https://your-backend.com/webhooks"
)

const coll = await conn.getCollection("your-collection-id");

const meeting = await coll.recordMeeting({
    meetingUrl: "https://zoom.us/j/123456789",
    botName: "Team Recorder",
    meetingTitle: "Sprint Planning",
    callbackUrl: "https://your-backend.com/webhooks"
});

# Poll status
meeting.refresh()
print(f"Status: {meeting.status}")

# Wait for completion
if meeting.wait_for_status("done", timeout=3600, interval=60):
    print("Recording complete!")
    video = coll.get_video(meeting.video_id)

// Poll status
await meeting.refresh();
console.log(`Status: ${meeting.status}`);

// Wait for completion
const success = await meeting.waitForStatus("done", 3600, 60);
if (success) {
    console.log("Recording complete!");
    const video = await coll.getVideo(meeting.videoId);
}

meeting = coll.get_meeting("meeting-id")

# Get the recorded video
video = coll.get_video(meeting.video_id)

understanding = video.understand(
    analyzers=[{"type": "spoken_words", "name": "transcript"}],
)
understanding.wait_until_complete()
transcript_analyzer = understanding.get_analyzer("transcript")
transcript_index = video.index(
    name="meeting_transcript",
    source=transcript_analyzer,
    use_for=["semantic"],
    fields={"semantic": ["text"]},
)
transcript_index.wait_until_complete()

const meeting = await coll.getMeeting("meeting-id");

// Get the recorded video
const video = await coll.getVideo(meeting.videoId);

const understanding = await video.understand([
  { type: "spoken_words", name: "transcript" },
]);
await understanding.waitUntilComplete();
const transcriptAnalyzer = await understanding.getAnalyzer("transcript");
const transcriptIndex = await video.index(transcriptAnalyzer, {
  name: "meeting_transcript",
  useFor: ["semantic"],
  fields: { semantic: ["text"] },
});
await transcriptIndex.waitUntilComplete();