Video Module

The praisonai.video module provides end-to-end AI-powered video editing capabilities. It automatically:

Transcribes audio with word-level timestamps
Removes filler words (um, uh, like, you know)
Detects and removes repetitions (stutters, restarts)
Identifies tangent segments (off-topic content)
Removes long silences
Generates captions (SRT format or burned-in)
Produces edit decision lists (EDL)

Requirements

FFmpeg: Required for video processing

# macOS
brew install ffmpeg

# Linux
apt install ffmpeg

OpenAI API Key: Required for transcription and content analysis
export OPENAI_API_KEY="your-key-here"

Quick Start

Python API

from praisonai import video

# Simple edit with preset
result = video.edit(
    input_path="input.mp4",
    preset="podcast",
    output_path="out.mp4"
)

print(f"Output: {result.output_path}")
print(f"Original: {result.original_duration:.1f}s")
print(f"Final: {result.final_duration:.1f}s")
print(f"Saved: {result.time_saved:.1f}s")

CLI

# Basic podcast editing
praisonai video edit input.mp4 --preset podcast --output out.mp4

# With custom options
praisonai video edit input.mp4 \
  --remove-fillers \
  --remove-repetitions \
  --target-length 10m \
  --verbose

API Reference

`video.edit()`

Main function for AI-powered video editing.

result = video.edit(
    input_path: str,
    output_path: str = None,
    preset: str = "podcast",
    workdir: str = None,
    remove_fillers: bool = None,
    remove_repetitions: bool = None,
    remove_tangents: bool = None,
    remove_silence: bool = None,
    auto_crop: str = "off",
    target_length: str = None,
    captions: str = "srt",
    provider: str = "auto",
    use_llm: bool = True,
    force: bool = False,
    verbose: bool = False
)

Parameters:

Parameter	Type	Default	Description
`input_path`	str	required	Path to input video file
`output_path`	str	None	Output path (default: input_edited.mp4)
`preset`	str	”podcast”	Edit preset (podcast, meeting, course, clean)
`workdir`	str	None	Working directory for temp files
`remove_fillers`	bool	None	Remove filler words (overrides preset)
`remove_repetitions`	bool	None	Remove repeated phrases
`remove_tangents`	bool	None	Remove off-topic content
`remove_silence`	bool	None	Remove long silences
`auto_crop`	str	”off”	Crop mode (off, center, face)
`target_length`	str	None	Target duration (e.g., “6m”, ”90s”)
`captions`	str	”srt”	Caption mode (off, srt, burn)
`provider`	str	”auto”	Transcription provider (openai, local, auto)
`use_llm`	bool	True	Use LLM for content analysis
`force`	bool	False	Overwrite output if exists
`verbose`	bool	False	Print progress messages

Returns: VideoEditResult object

`video.probe()`

Extract video metadata.

result = video.probe(input_path: str)

Returns: VideoProbeResult with:

duration: Video duration in seconds
width, height: Resolution
fps: Frame rate
codec: Video codec
audio_codec: Audio codec
file_size: File size in bytes

`video.transcript()`

Generate transcript with word-level timestamps.

result = video.transcript(
    input_path: str,
    provider: str = "auto",
    language: str = "en"
)

Returns: TranscriptResult with:

text: Full transcript text
words: List of words with timestamps
duration: Audio duration
provider: Provider used

Presets

Preset	Fillers	Repetitions	Tangents	Silence Threshold
`podcast`	✓	✓	✗	700ms
`meeting`	✓	✓	✓	1000ms
`course`	✓	✓	✗	500ms
`clean`	✓	✓	✓	600ms

Output Files

After editing, you’ll find:

File	Description
`*_edited.mp4`	Final edited video
`transcript.txt`	Plain text transcript
`captions.srt`	SRT caption file
`edit_plan.json`	Detailed edit plan
`edit_decision_list.edl`	Professional EDL
`report.json`	Complete processing report

Result Objects

VideoEditResult

result.output_path      # Path to edited video
result.report_path      # Path to JSON report
result.transcript_path  # Path to transcript
result.srt_path         # Path to SRT captions
result.edl_path         # Path to EDL file
result.original_duration  # Original duration (seconds)
result.final_duration   # Final duration (seconds)
result.time_saved       # Time removed (seconds)
result.compression_ratio  # final/original ratio
result.edit_plan        # EditPlan object

EditPlan

plan.segments_to_keep    # List of kept segments
plan.segments_to_remove  # List of removed segments
plan.chapters           # Chapter markers
plan.summary            # Content summary
plan.topics             # Detected topics
plan.total_keep_duration
plan.total_remove_duration
plan.removal_stats      # Dict of duration by category

Examples

Custom Filler Removal

from praisonai import video

result = video.edit(
    input_path="podcast.mp4",
    remove_fillers=True,
    remove_repetitions=True,
    remove_silence=True,
    
)

# Check what was removed
for category, duration in result.edit_plan.removal_stats.items():
    print(f"{category}: {duration:.1f}s removed")

Meeting with Target Length

result = video.edit(
    input_path="meeting.mp4",
    preset="meeting",
    remove_tangents=True,
    target_length="30m",
    output_path="meeting_summary.mp4"
)

Generate Transcript Only

from praisonai import video

transcript = video.transcript("lecture.mp4")
print(transcript.text)

# Save as SRT
transcript.to_srt("lecture.srt")

Probe Video Metadata

from praisonai import video

info = video.probe("video.mp4")
print(f"Duration: {info.duration}s")
print(f"Resolution: {info.width}x{info.height}")
print(f"FPS: {info.fps}")

CLI Reference

`praisonai video edit`

praisonai video edit <input> [options]

Options:
  --output, -o PATH       Output video path
  --preset PRESET         Edit preset (podcast, meeting, course, clean)
  --remove-fillers        Remove filler words
  --remove-repetitions    Remove repeated phrases
  --remove-tangents       Remove off-topic content
  --auto-crop MODE        Crop mode (off, center, face)
  --target-length TIME    Target duration (e.g., 6m, 90s)
  --captions MODE         Caption mode (off, srt, burn)
  --provider PROVIDER     Transcription provider (openai, local, auto)
  --no-llm                Use simple pattern matching
  --force                 Overwrite output if exists
  --json-report PATH      Save JSON report
  --verbose, -v           Enable verbose output

`praisonai video probe`

praisonai video probe <input> [--json]

`praisonai video transcript`

praisonai video transcript <input> [options]

Options:
  --output, -o PATH       Output file path
  --format FORMAT         Output format (srt, txt, json)
  --provider PROVIDER     Transcription provider
  --language LANG         Language code (default: en)

Installation

# Basic video support
pip install "praisonai[video]"

# With local transcription (faster-whisper)
pip install "praisonai[video-local]"

​Video Module

​Requirements

​Quick Start

​Python API

​CLI

​API Reference

​video.edit()

​video.probe()

​video.transcript()

​Presets

​Output Files

​Result Objects

​VideoEditResult

​EditPlan

​Examples

​Custom Filler Removal

​Meeting with Target Length

​Generate Transcript Only

​Probe Video Metadata

​CLI Reference

​praisonai video edit

​praisonai video probe

​praisonai video transcript

​Installation