Profanity Detection

import videodb

# Set your API key
api_key = "your_api_key"

# Connect to VideoDB
conn = videodb.connect(api_key=api_key)
coll = conn.get_collection()

import { connect } from 'videodb';

const conn = await connect({ apiKey: process.env.VIDEO_DB_API_KEY });

from videodb import play_stream

# Joe rogan video clip
coll = conn.get_collection()
video = coll.upload(url='https://www.youtube.com/watch?v=7MV6tUCUd-c')

# watch the original video
o_stream = video.generate_stream()
play_stream(o_stream)

// Joe rogan video clip
const coll = await conn.getCollection();
const video = await coll.uploadURL({ url: 'https://www.youtube.com/watch?v=7MV6tUCUd-c' });

// watch the original video
const oStream = await video.generateStream();
console.log(oStream);

# index spoken content in the video
video.index_spoken_words()

// index spoken content in the video
await video.indexSpokenWords();

# Import Editor SDK components
from videodb.editor import VideoAsset, AudioAsset, Timeline, Track, Clip

# upload beep sound - This is just a sample, you can replace it with quack or any other sound effect.
beep = coll.upload(file_path="beep.wav")

# Create audio asset from beep sound
beep_asset = AudioAsset(id=beep.id)

import { VideoAsset, AudioAsset, EditorTimeline, Track, Clip } from 'videodb';

// upload beep sound - This is just a sample, you can replace it with quack or any other sound effect.
const coll = await conn.getCollection();
const beep = await coll.uploadFile({
  filePath: "beep.wav"
});

// Create audio asset from beep sound
const beepAsset = new AudioAsset({ id: beep.id });

curse_words_list = ['shit', 'ass', 'shity', 'fuck', 'motherfucker','damn', 'fucking', 'motherfuker']

const curseWordsList = ['shit', 'ass', 'shity', 'fuck', 'motherfucker', 'damn', 'fucking', 'motherfuker'];

transcript = video.get_transcript()

const transcript = await video.getTranscript();

#install spacy
!pip -q install spacy

#install dataset english core
!python -m spacy download en_core_web_sm

# load the english corpus
import spacy
import re
nlp = spacy.load("en_core_web_sm")

def get_root_word(word):
    """
    This function convert each word into its root word
    """
    try:
        #clean punctuations
        cleaned_word = re.sub(r'[^\w\s]', '', word)

        # Process the sentence
        doc = nlp(cleaned_word)

        # Lemmatize the word
        lemmatized_word = [token.lemma_ for token in doc][0]  # Assuming single word input

        return lemmatized_word
    except Exception as e:
        print(f"some issue with lemma for the word {word}")
        return word

// Install natural: npm install natural
import natural from 'natural';

const stemmer = natural.PorterStemmer;

// Pre-stem the curse words list so comparisons work correctly
const stemmedCurseWords = curseWordsList.map(w => stemmer.stem(w));

function getRootWord(word) {
    /**
     * This function converts each word into its root word (stem)
     */
    try {
        // Clean punctuations
        const cleanedWord = word.replace(/[^\w\s]/g, '');

        // Stem the word
        const stemmedWord = stemmer.stem(cleanedWord);

        return stemmedWord;
    } catch (e) {
        console.log(`some issue with stemming for the word ${word}`);
        return word;
    }
}

# 1. Filter and prepare curse metadata
padding = 0.15
curse_intervals = [
    {
        'word': w.get('text'),
        'start': max(0.0, float(w['start']) - padding),
        'end': min(float(video.length), float(w['end']) + padding),
        'raw_start': float(w['start']),
        'raw_end': float(w['end'])
    }
    for w in transcript
    if w.get('text') != '-' and get_root_word(w.get('text')) in curse_words_list
]

# 2. Building the Timeline

from videodb.editor import Timeline, Track, VideoAsset, AudioAsset, Clip

timeline = Timeline(conn)
video_track = Track()
beep_track = Track()
current_time = 0.0

print(f"{'WORD':<15} | {'START':<8} | {'END':<8} | {'DURATION'}")
print("-" * 50)

for interval in curse_intervals:
    # A. Clean segment
    if interval['start'] > current_time:
        clean_dur = interval['start'] - current_time
        video_track.add_clip(current_time, Clip(asset=VideoAsset(id=video.id, start=current_time), duration=clean_dur))

    # B. Muted segment
    mute_dur = interval['end'] - interval['start']
    video_track.add_clip(interval['start'], Clip(asset=VideoAsset(id=video.id, start=interval['start'], volume=0.0), duration=mute_dur))

    # C. Beep overlay
    beep_dur = interval['raw_end'] - interval['raw_start']
    beep_track.add_clip(interval['raw_start'], Clip(asset=AudioAsset(id=beep.id, start=0, volume=2.0), duration=min(beep_dur, float(beep.length))))

    # D. Professional Print Message
    print(f"{interval['word']:<15} | {interval['raw_start']:<8.2f} | {interval['raw_end']:<8.2f} | {beep_dur:.2f}s")

    current_time = interval['end']

# E. Final clean segment
if current_time < float(video.length):
    video_track.add_clip(current_time, Clip(asset=VideoAsset(id=video.id, start=current_time), duration=float(video.length) - current_time))

timeline.add_track(video_track)
timeline.add_track(beep_track)

stream_url = timeline.generate_stream()
print(f"\nProcessing complete. Stream URL: {stream_url}")

// 1. Filter and prepare curse metadata
const padding = 0.15;
const curseIntervals = transcript
    .filter(w => w.text !== '-' && stemmedCurseWords.includes(getRootWord(w.text)))
    .map(w => ({
        word: w.text,
        start: Math.max(0.0, parseFloat(w.start) - padding),
        end: Math.min(parseFloat(video.length), parseFloat(w.end) + padding),
        rawStart: parseFloat(w.start),
        rawEnd: parseFloat(w.end)
    }));

// 2. Building the Timeline

import { EditorTimeline, Track, VideoAsset, AudioAsset, Clip } from 'videodb';

const timeline = new EditorTimeline(conn);
const videoTrack = new Track();
const beepTrack = new Track();
let currentTime = 0.0;

console.log(`${'WORD'.padEnd(15)} | ${'START'.padEnd(8)} | ${'END'.padEnd(8)} | DURATION`);
console.log('-'.repeat(50));

for (const interval of curseIntervals) {
    // A. Clean segment
    if (interval.start > currentTime) {
        const cleanDur = interval.start - currentTime;
        videoTrack.addClip(currentTime, new Clip({
            asset: new VideoAsset({ id: video.id, start: currentTime }),
            duration: cleanDur
        }));
    }

    // B. Muted segment
    const muteDur = interval.end - interval.start;
    videoTrack.addClip(interval.start, new Clip({
        asset: new VideoAsset({ id: video.id, start: interval.start, volume: 0.0 }),
        duration: muteDur
    }));

    // C. Beep overlay
    const beepDur = interval.rawEnd - interval.rawStart;
    beepTrack.addClip(interval.rawStart, new Clip({
        asset: new AudioAsset({ id: beep.id, start: 0, volume: 2.0 }),
        duration: Math.min(beepDur, parseFloat(beep.length))
    }));

    // D. Professional Print Message
    console.log(`${interval.word.padEnd(15)} | ${interval.rawStart.toFixed(2).padEnd(8)} | ${interval.rawEnd.toFixed(2).padEnd(8)} | ${beepDur.toFixed(2)}s`);

    currentTime = interval.end;
}

// E. Final clean segment
if (currentTime < parseFloat(video.length)) {
    videoTrack.addClip(currentTime, new Clip({
        asset: new VideoAsset({ id: video.id, start: currentTime }),
        duration: parseFloat(video.length) - currentTime
    }));
}

timeline.addTrack(videoTrack);
timeline.addTrack(beepTrack);

const streamUrl = await timeline.generateStream();
console.log(`\nProcessing complete. Stream URL: ${streamUrl}`);

from videodb import play_stream
play_stream(stream_url)

console.log(streamUrl);