PII/PHI Redaction

curl -sS -X POST https://platform.modulate.ai/api/velma-2-pii-phi-redaction-batch \
  -H "X-API-Key: $MODULATE_API_KEY" \
  -F "upload_file=@audio.mp3" \
  -F "speaker_diarization=true" \
  -D response_headers.txt -o response.multipart

# The metadata part is text, so awk can lift it out of the envelope.
boundary=$(sed -n 's/.*boundary=//p' response_headers.txt | tr -d '\r\n')

awk -v b="--$boundary" -v mp="$boundary" '
  mp == ""       { print; next }   # a rejected call returns plain JSON, not multipart
  index($0,b)==1 { p++; h=1; next }
  h && /^\r?$/   { h=0; next }
  p==1 && !h
' response.multipart | tr -d '\r' \
| jq -r 'if .detail then "error: \(.detail)" else
    .text,
    (.utterances[] | "  [\(.start_ms)ms] Speaker \(.speaker): \(.text)"),
    "",
    "silenced: \(.redaction_ranges | map("\(.[0])-\(.[1])ms") | join(", "))"
  end'

import os, json, requests
from requests_toolbelt.multipart.decoder import MultipartDecoder

response = requests.post(
    "https://platform.modulate.ai/api/velma-2-pii-phi-redaction-batch",
    headers={"X-API-Key": os.environ["MODULATE_API_KEY"]},
    data={"speaker_diarization": "true"},
    files={"upload_file": open("audio.mp3", "rb")},
)
response.raise_for_status()

for part in MultipartDecoder.from_response(response).parts:
    disposition = part.headers.get(b"Content-Disposition", b"").decode()
    if 'name="metadata"' in disposition:
        metadata = json.loads(part.content)
        print(metadata["text"])
        for u in metadata["utterances"]:
            print(f"  [{u['start_ms']}ms] Speaker {u['speaker']}: {u['text']}")
        ranges = ", ".join(f"{a}-{b}ms" for a, b in metadata["redaction_ranges"])
        print(f"\nsilenced: {ranges}")
    elif 'name="audio"' in disposition:
        with open("redacted.mp3", "wb") as f:
            f.write(part.content)
        print(f"wrote redacted.mp3 ({len(part.content)} bytes)")

import os, asyncio, json, websockets

API_KEY = os.environ["MODULATE_API_KEY"]
AUDIO_FILE = "audio.mp3"
CHUNK_SIZE = 4096

async def redact():
    url = (
        f"wss://platform.modulate.ai/api/velma-2-pii-phi-redaction-streaming"
        f"?api_key={API_KEY}&speaker_diarization=true"
    )
    audio_clips = []

    async with websockets.connect(url) as ws:
        async def send():
            with open(AUDIO_FILE, "rb") as f:
                while chunk := f.read(CHUNK_SIZE):
                    await ws.send(chunk)
            await ws.send("")  # end of stream

        async def receive():
            is_done = False
            async for message in ws:
                if isinstance(message, bytes):
                    audio_clips.append(message)
                    if is_done:          # the trailing clip after done
                        break
                    continue
                msg = json.loads(message)
                if msg["type"] == "utterance":
                    u = msg["utterance"]
                    print(f"  [{u['start_ms']}ms] Speaker {u['speaker']}: {u['text']}")
                elif msg["type"] == "done":
                    is_done = True
                    if not msg.get("trailing_redacted_audio"):
                        break            # no binary frame follows
                elif msg["type"] == "error":
                    raise RuntimeError(msg["error"])

        await asyncio.gather(send(), receive())

    if audio_clips:
        with open("redacted.mp3", "wb") as f:
            for clip in audio_clips:
                f.write(clip)
        written = sum(len(clip) for clip in audio_clips)
        print(f"wrote redacted.mp3 ({written} bytes)")

asyncio.run(redact())