Filter profanity

import logging
from typing import Type
import assemblyai as aai
from assemblyai.streaming.v3 import (
    BeginEvent,
    StreamingClient,
    StreamingClientOptions,
    StreamingError,
    StreamingEvents,
    StreamingParameters,
    TurnEvent,
    TerminationEvent,
)

api_key = "<YOUR_API_KEY>"
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

def on_begin(self: Type[StreamingClient], event: BeginEvent):
    print(f"Session started: {event.id}")

def on_turn(self: Type[StreamingClient], event: TurnEvent):
    print(f"{event.transcript} (end_of_turn={event.end_of_turn})")

def on_terminated(self: Type[StreamingClient], event: TerminationEvent):
    print(
        f"Session terminated: {event.audio_duration_seconds} seconds of audio processed"
    )

def on_error(self: Type[StreamingClient], error: StreamingError):
    print(f"Error occurred: {error}")

def main():
    client = StreamingClient(
        StreamingClientOptions(
            api_key=api_key,
            api_host="streaming.assemblyai.com",
        )
    )
    client.on(StreamingEvents.Begin, on_begin)
    client.on(StreamingEvents.Turn, on_turn)
    client.on(StreamingEvents.Termination, on_terminated)
    client.on(StreamingEvents.Error, on_error)

    client.connect(
        StreamingParameters(
            sample_rate=16000,
            speech_model="u3-rt-pro",
            format_turns=True,
            filter_profanity=True,
        )
    )
    try:
        client.stream(
            aai.extras.MicrophoneStream(sample_rate=16000)
        )
    finally:
        client.disconnect(terminate=True)

if __name__ == "__main__":
    main()

import WebSocket from "ws";
import recorder from "node-record-lpcm16";

const YOUR_API_KEY = "<YOUR_API_KEY>";
const SAMPLE_RATE = 16000;

const params = new URLSearchParams({
  sample_rate: String(SAMPLE_RATE),
  speech_model: "u3-rt-pro",
  format_turns: "true",
  filter_profanity: "true",
});

const url = `wss://streaming.assemblyai.com/v3/ws?${params}`;
const ws = new WebSocket(url, {
  headers: { Authorization: YOUR_API_KEY },
});

let recording;

ws.on("open", () => {
  console.log("Connected to AssemblyAI Streaming API");
  recording = recorder.record({
    channels: 1,
    sampleRate: SAMPLE_RATE,
    audioType: "raw",
  });
  recording.stream().on("data", (chunk) => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.send(chunk);
    }
  });
});

ws.on("message", (data) => {
  const msg = JSON.parse(data);
  if (msg.type === "Turn" && msg.end_of_turn) {
    console.log(msg.transcript);
  }
});

ws.on("error", (err) => console.error("WebSocket error:", err));
ws.on("close", () => console.log("Disconnected"));

process.on("SIGINT", () => {
  if (recording) recording.stop();
  if (ws.readyState === WebSocket.OPEN) {
    ws.send(JSON.stringify({ type: "Terminate" }));
  }
  setTimeout(() => {
    ws.close();
    process.exit(0);
  }, 500);
});

import { AssemblyAI } from "assemblyai";
import recorder from "node-record-lpcm16";

const apiKey = "<YOUR_API_KEY>";
const SAMPLE_RATE = 16000;

const client = new AssemblyAI({ apiKey });

const transcriber = client.streaming.transcriber({
  sampleRate: SAMPLE_RATE,
  speechModel: "u3-rt-pro",
  formatTurns: true,
  filterProfanity: true,
});

transcriber.on("open", ({ id }) => {
  console.log(`Session started: ${id}`);
});

transcriber.on("turn", (turn) => {
  console.log(`${turn.transcript} (end_of_turn=${turn.end_of_turn})`);
});

transcriber.on("close", (code, reason) => {
  console.log(`Session terminated: ${code} ${reason}`);
});

transcriber.on("error", (error) => {
  console.error(`Error occurred: ${error}`);
});

async function main() {
  await transcriber.connect();
  console.log("Speak into your microphone. Press Ctrl+C to stop.");

  const recording = recorder.record({
    channels: 1,
    sampleRate: SAMPLE_RATE,
    audioType: "raw",
  });

  recording.stream().on("data", (chunk) => transcriber.sendAudio(chunk));

  process.on("SIGINT", async () => {
    recording.stop();
    await transcriber.close(true);
    process.exit(0);
  });
}

main();