🥔 TATERS¶
Takes All Things, Extracts Relevant Stuff
Status: very early and evolving. It already works for many common workflows, but expect rough edges and the occasional renaming as things mature. Pin a version if you need stability.
Taters is a Python toolkit and CLI for getting from raw media to analysis-ready data. Point it at video, audio, or text, and it will turn your raw files into analyzable features.
In practice, that means things like this. If you have a folder of text data and want readability scores for each row, that is one command. If you have a CSV of social media posts and want to aggregate all text per user and then calculate dictionary-based scores for each one, that is also one command.
The same holds for longer chains. Given a folder of video files, you can extract the audio, transcribe it (diarized or not), compute transformer-based embeddings for each utterance, aggregate text by speaker, and calculate dictionary-based scores — again from a single command.
Taters is a growing toolbox of single-purpose tools for feature extraction, aimed at social scientists. It also ships pre-made pipelines that chain those tools together in a fixed, predictable order. You can mix and match feature types, call them from a Python script or the CLI, and write your own pipeline files for jobs the built-in presets do not cover.
What problems Taters tries to solve¶
- Lower the "first mile" cost of multimodal analysis (A/V + text) by shipping batteries-included tools that work well together.
- Standardize I/O so outputs land in predictable places (for example,
./features/<kind>/<file>.csv) and feed into downstream tools without hunting through folders. - Keep the knobs. Every step is a clear, reusable function (and CLI entry point), not a black box. Use them à la carte or chain them together with reusable, customizable YAML presets.
- Make batch runs sane: a pipeline runner coordinates per-item steps (e.g., per input file) and/or global steps (e.g., process a single file, aggregate data in a single step, etc.).
Every tool follows the same "don't overwrite unless asked" rule and has sensible defaults. If you don't pass an output path, Taters picks one.
How you'll use it¶
Python: processing a video file with individual functions¶
from taters import Taters
t = Taters()
# Extract audio from video
wavs = t.audio.extract_wavs_from_video(input_path="input.mp4")
# Diarize & transcribe (CSV/SRT/TXT). For single-speaker recordings, swap in
# t.audio.transcribe_with_whisper — same arguments, same return shape, and it
# needs nothing beyond the base install.
diar = t.audio.diarize_with_thirdparty(audio_path=wavs[0], device="cuda")
# Either one returns a small object; the transcript CSV lives in .raw_files
transcript = diar.raw_files["csv"] # also: diar.raw_files["srt"] / ["txt"]
# Features land under ./features/<kind>/ by default
t.audio.extract_whisper_embeddings(source_wav=wavs[0], transcript_csv=transcript)
t.text.analyze_with_dictionaries(csv_path=transcript, dict_paths=["dicts/EPrime-Dictionary.dicx"])
t.text.analyze_with_archetypes(csv_path=transcript, archetype_csvs=["archetypes/Resilience.csv"])
t.text.extract_sentence_embeddings(csv_path=transcript, text_cols=["text"], id_cols=["speaker"], group_by=["speaker"])
CLI Example¶
# Diarize a single file
python -m taters.audio.diarize_with_thirdparty --audio_path audio/session.wav --device cuda
# Or, for one speaker, transcribe it without the diarization stack
python -m taters.audio.transcribe_with_whisper --audio_path audio/lecture.wav
# Gather text from CSV (auto-names the output if --out omitted)
python -m taters.helpers.text_gather \
--csv transcripts/session.csv \
--text-col text \
--group-by speaker \
--delimiter ,
Every function ships with a helpful --help page; you can compose these pieces into YAML pipelines to batch entire studies.
Pipelines (do it all at once)¶
Pick a preset, point it at a dataset, and Taters runs the steps in order, feeding each step's output into the next. Variables such as device, model, and overwrite behavior can be overridden on the command line. The preset library is still small, but the ones that exist are useful, and you can write your own.
Who it's for¶
Researchers and engineers who:
- wrangle interviews, conversations, text data, or any combination of those data types (and others)
- need consistent, analysis-ready features extracted from their raw data
- want reproducible pipelines without giving up control over the individual steps
What it isn't¶
It isn't edible. It also isn't a monolithic, one-click application. Taters gives you small, composable building blocks with predictable I/O, plus a pipeline runner to tie them together when you need it.