slurpai 0.1.0__tar.gz

slurpai-0.1.0/.env.example

@@ -0,0 +1,11 @@
+# Required for OpenAI backend
+OPENAI_API_KEY=sk-...
+
+# Optional: default backend (openai or faster-whisper)
+# INGESTIBLE_BACKEND=openai
+
+# Optional: OpenAI model override
+# OPENAI_WHISPER_MODEL=whisper-1
+
+# Optional: local Whisper model size (base, small, medium, large)
+# INGESTIBLE_WHISPER_MODEL=base

slurpai-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,31 @@
+name: Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install ffmpeg
+        run: sudo apt-get update && sudo apt-get install -y ffmpeg
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: pip install -e ".[dev]"
+
+      - name: Run tests
+        run: pytest -v

slurpai-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environments
+.venv/
+venv/
+
+# Environment
+.env
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Test
+.pytest_cache/
+.coverage
+htmlcov/

slurpai-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,37 @@
+# Contributing to ingestible
+
+Thanks for wanting to help. Here's how to get set up.
+
+## Development setup
+
+```bash
+git clone https://github.com/grahamrowe82/ingestible.git
+cd ingestible
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+```
+
+You'll also need [ffmpeg](https://ffmpeg.org/) installed.
+
+## Running tests
+
+```bash
+pytest -v
+```
+
+Tests use ffmpeg to generate tiny test audio/video files — no API keys needed.
+
+## Submitting changes
+
+1. Fork the repo and create a branch
+2. Make your changes
+3. Run `pytest` and make sure everything passes
+4. Open a pull request
+
+## Reporting bugs
+
+Open an issue at https://github.com/grahamrowe82/ingestible/issues with:
+- What you ran (`ingest ...`)
+- What happened (error message or unexpected output)
+- Your OS and Python version

slurpai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Graham Rowe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

slurpai-0.1.0/PKG-INFO

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: slurpai
+Version: 0.1.0
+Summary: Convert voice notes, videos, and audio files into AI-ready text and images
+Project-URL: Repository, https://github.com/grahamrowe82/ingestible
+Project-URL: Issues, https://github.com/grahamrowe82/ingestible/issues
+Author-email: Graham Rowe <graham@phasetransitions.ai>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,audio-to-text,cli,ffmpeg,openai,transcription,video-to-text,voice-notes,whisper
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0
+Requires-Dist: openai>=1.0
+Requires-Dist: python-dotenv>=1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: local
+Requires-Dist: faster-whisper>=0.10; extra == 'local'
+Description-Content-Type: text/markdown
+
+# ingestible
+
+Convert voice notes, videos, and audio files into AI-ready text and images.
+
+Consultants, researchers, and anyone who works with AI tools faces the same problem: clients and colleagues send voice notes, screen recordings, and video walkthroughs — but your AI workflow needs text and images. Ingestible bridges that gap with a single command.
+
+## Quick start
+
+```bash
+pip install ingestible
+export OPENAI_API_KEY=sk-...
+ingest client-feedback.opus
+```
+
+That's it. You get a folder with `transcript.txt` and you're ready to feed it into whatever AI tool you're using.
+
+## Install
+
+```bash
+pip install ingestible
+```
+
+You also need [ffmpeg](https://ffmpeg.org/) on your PATH:
+
+| OS | Command |
+|----|---------|
+| macOS | `brew install ffmpeg` |
+| Ubuntu/Debian | `sudo apt install ffmpeg` |
+| Windows | `choco install ffmpeg` or download from [ffmpeg.org](https://ffmpeg.org/download.html) |
+
+## Usage
+
+```bash
+# Transcribe a voice note
+ingest recording.opus
+
+# Process a video (transcript + frame grabs every 15 seconds)
+ingest feedback.mp4
+
+# Batch process everything in a folder
+ingest *.opus *.mp4
+
+# Grab frames more frequently
+ingest --frame-interval 5 demo.mp4
+
+# Use local Whisper instead of OpenAI API
+pip install ingestible[local]
+ingest --backend faster-whisper recording.opus
+
+# Preview what would be processed
+ingest --dry-run *.opus
+```
+
+## Output
+
+Each file produces a folder alongside it:
+
+```
+recording/
+├── transcript.txt    # Plain text transcription
+├── frames/           # Video frame grabs (video only)
+│   ├── frame_001.jpg
+│   ├── frame_002.jpg
+│   └── ...
+└── process.log       # Timestamped processing log
+```
+
+Re-running the same command skips already-completed files (idempotent).
+
+## Privacy notice
+
+**By default, ingestible sends your audio to [OpenAI's Whisper API](https://platform.openai.com/docs/guides/speech-to-text) for transcription.** Your audio is transmitted to OpenAI's servers. Review [OpenAI's data usage policy](https://openai.com/policies/api-data-usage-policies) to understand how your data is handled.
+
+If you need fully local, private transcription — no data leaves your machine:
+
+```bash
+pip install ingestible[local]
+ingest --backend faster-whisper recording.opus
+```
+
+This uses [faster-whisper](https://github.com/SYSTRAN/faster-whisper) running entirely on your CPU. It's slower but nothing leaves your computer.
+
+## Configuration
+
+Set `OPENAI_API_KEY` in your environment or a `.env` file in the current directory.
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OPENAI_API_KEY` | — | Required for OpenAI backend |
+| `INGESTIBLE_BACKEND` | `openai` | Default backend (`openai` or `faster-whisper`) |
+| `OPENAI_WHISPER_MODEL` | `whisper-1` | OpenAI model to use |
+| `INGESTIBLE_WHISPER_MODEL` | `base` | Local Whisper model size (`base`, `small`, `medium`, `large`) |
+
+## Supported formats
+
+**Audio:** `.opus`, `.m4a`, `.ogg`, `.mp3`, `.wav`
+
+**Video:** `.mp4`, `.mkv`, `.mov`, `.webm`
+
+All formats are normalised to MP3 before transcription — this ensures consistent behaviour regardless of input format.
+
+## Requirements
+
+- Python 3.10+
+- [ffmpeg](https://ffmpeg.org/) on your PATH
+
+## Contributing
+
+Found a bug or want to add a format? See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT

slurpai-0.1.0/README.md

@@ -0,0 +1,113 @@
+# ingestible
+
+Convert voice notes, videos, and audio files into AI-ready text and images.
+
+Consultants, researchers, and anyone who works with AI tools faces the same problem: clients and colleagues send voice notes, screen recordings, and video walkthroughs — but your AI workflow needs text and images. Ingestible bridges that gap with a single command.
+
+## Quick start
+
+```bash
+pip install ingestible
+export OPENAI_API_KEY=sk-...
+ingest client-feedback.opus
+```
+
+That's it. You get a folder with `transcript.txt` and you're ready to feed it into whatever AI tool you're using.
+
+## Install
+
+```bash
+pip install ingestible
+```
+
+You also need [ffmpeg](https://ffmpeg.org/) on your PATH:
+
+| OS | Command |
+|----|---------|
+| macOS | `brew install ffmpeg` |
+| Ubuntu/Debian | `sudo apt install ffmpeg` |
+| Windows | `choco install ffmpeg` or download from [ffmpeg.org](https://ffmpeg.org/download.html) |
+
+## Usage
+
+```bash
+# Transcribe a voice note
+ingest recording.opus
+
+# Process a video (transcript + frame grabs every 15 seconds)
+ingest feedback.mp4
+
+# Batch process everything in a folder
+ingest *.opus *.mp4
+
+# Grab frames more frequently
+ingest --frame-interval 5 demo.mp4
+
+# Use local Whisper instead of OpenAI API
+pip install ingestible[local]
+ingest --backend faster-whisper recording.opus
+
+# Preview what would be processed
+ingest --dry-run *.opus
+```
+
+## Output
+
+Each file produces a folder alongside it:
+
+```
+recording/
+├── transcript.txt    # Plain text transcription
+├── frames/           # Video frame grabs (video only)
+│   ├── frame_001.jpg
+│   ├── frame_002.jpg
+│   └── ...
+└── process.log       # Timestamped processing log
+```
+
+Re-running the same command skips already-completed files (idempotent).
+
+## Privacy notice
+
+**By default, ingestible sends your audio to [OpenAI's Whisper API](https://platform.openai.com/docs/guides/speech-to-text) for transcription.** Your audio is transmitted to OpenAI's servers. Review [OpenAI's data usage policy](https://openai.com/policies/api-data-usage-policies) to understand how your data is handled.
+
+If you need fully local, private transcription — no data leaves your machine:
+
+```bash
+pip install ingestible[local]
+ingest --backend faster-whisper recording.opus
+```
+
+This uses [faster-whisper](https://github.com/SYSTRAN/faster-whisper) running entirely on your CPU. It's slower but nothing leaves your computer.
+
+## Configuration
+
+Set `OPENAI_API_KEY` in your environment or a `.env` file in the current directory.
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OPENAI_API_KEY` | — | Required for OpenAI backend |
+| `INGESTIBLE_BACKEND` | `openai` | Default backend (`openai` or `faster-whisper`) |
+| `OPENAI_WHISPER_MODEL` | `whisper-1` | OpenAI model to use |
+| `INGESTIBLE_WHISPER_MODEL` | `base` | Local Whisper model size (`base`, `small`, `medium`, `large`) |
+
+## Supported formats
+
+**Audio:** `.opus`, `.m4a`, `.ogg`, `.mp3`, `.wav`
+
+**Video:** `.mp4`, `.mkv`, `.mov`, `.webm`
+
+All formats are normalised to MP3 before transcription — this ensures consistent behaviour regardless of input format.
+
+## Requirements
+
+- Python 3.10+
+- [ffmpeg](https://ffmpeg.org/) on your PATH
+
+## Contributing
+
+Found a bug or want to add a format? See [CONTRIBUTING.md](CONTRIBUTING.md).
+
+## License
+
+MIT

slurpai-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "slurpai"
+version = "0.1.0"
+description = "Convert voice notes, videos, and audio files into AI-ready text and images"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Graham Rowe", email = "graham@phasetransitions.ai" },
+]
+keywords = [
+    "whisper", "transcription", "voice-notes", "audio-to-text",
+    "video-to-text", "ffmpeg", "openai", "ai", "cli",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+    "Topic :: Text Processing",
+]
+
+dependencies = [
+    "click>=8.0",
+    "python-dotenv>=1.0",
+    "openai>=1.0",
+]
+
+[project.urls]
+Repository = "https://github.com/grahamrowe82/ingestible"
+Issues = "https://github.com/grahamrowe82/ingestible/issues"
+
+[project.optional-dependencies]
+local = ["faster-whisper>=0.10"]
+dev = [
+    "pytest>=7.0",
+]
+
+[project.scripts]
+ingest = "ingestible.cli:ingest"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/ingestible"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

slurpai-0.1.0/src/ingestible/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

slurpai-0.1.0/src/ingestible/cli.py

@@ -0,0 +1,106 @@
+"""CLI entry point for ingestible."""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+
+import click
+from dotenv import load_dotenv
+
+from . import __version__
+
+
+@click.command()
+@click.argument("files", nargs=-1, required=True, type=click.Path(exists=True))
+@click.option(
+    "-b",
+    "--backend",
+    type=click.Choice(["openai", "faster-whisper"]),
+    default=None,
+    help="Transcription backend (default: env or openai)",
+)
+@click.option(
+    "-f",
+    "--frame-interval",
+    type=int,
+    default=15,
+    help="Seconds between video frame grabs (default: 15)",
+)
+@click.option(
+    "-o",
+    "--output-dir",
+    type=click.Path(),
+    default=None,
+    help="Base output directory (default: next to input file)",
+)
+@click.option(
+    "-l",
+    "--language",
+    type=str,
+    default="en",
+    help="Language hint for transcription (default: en)",
+)
+@click.option("--dry-run", is_flag=True, help="Show what would be processed")
+@click.version_option(version=__version__)
+def ingest(
+    files: tuple[str, ...],
+    backend: str | None,
+    frame_interval: int,
+    output_dir: str | None,
+    language: str,
+    dry_run: bool,
+) -> None:
+    """Convert voice notes, audio files, and videos into text and images."""
+    load_dotenv()
+
+    backend = backend or os.getenv("INGESTIBLE_BACKEND", "openai")
+
+    from .ffmpeg import check_ffmpeg
+    from .process import SUPPORTED_EXTENSIONS, process_file
+
+    if not check_ffmpeg():
+        click.echo("Error: ffmpeg not found. Install it: brew install ffmpeg", err=True)
+        sys.exit(1)
+
+    output_base = Path(output_dir) if output_dir else None
+    paths = [Path(f) for f in files]
+
+    # Filter to supported formats
+    supported = []
+    for p in paths:
+        if p.suffix.lower() in SUPPORTED_EXTENSIONS:
+            supported.append(p)
+        else:
+            click.echo(f"Skipping unsupported format: {p.name}")
+
+    if not supported:
+        click.echo("No supported files to process.")
+        sys.exit(1)
+
+    if dry_run:
+        click.echo(f"Would process {len(supported)} file(s) with backend={backend}:")
+        for p in supported:
+            click.echo(f"  {p}")
+        return
+
+    success = 0
+    failed = 0
+    for p in supported:
+        try:
+            result = process_file(
+                p,
+                backend=backend,
+                frame_interval=frame_interval,
+                output_dir=output_base,
+                language=language,
+            )
+            click.echo(f"Done: {result}")
+            success += 1
+        except Exception as e:
+            click.echo(f"Failed: {p.name} — {e}", err=True)
+            failed += 1
+
+    if len(supported) > 1:
+        click.echo(f"\n{success} succeeded, {failed} failed out of {len(supported)}")

slurpai-0.1.0/src/ingestible/ffmpeg.py

@@ -0,0 +1,65 @@
+"""FFmpeg wrappers for audio extraction and frame capture."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+
+def check_ffmpeg() -> bool:
+    """Return True if ffmpeg is available on PATH."""
+    return shutil.which("ffmpeg") is not None
+
+
+def extract_audio(input_path: Path, output_path: Path) -> Path:
+    """Extract audio from video as compressed MP3 for API upload.
+
+    Uses mono, 16kHz, 64kbps — compresses a 10-min video from ~60MB to ~5MB,
+    staying under the 25MB Whisper API limit.
+    """
+    cmd = [
+        "ffmpeg", "-y", "-i", str(input_path),
+        "-vn", "-ac", "1", "-ar", "16000", "-b:a", "64k",
+        str(output_path),
+        "-loglevel", "warning",
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg audio extraction failed: {result.stderr.strip()}")
+    return output_path
+
+
+def extract_frames(input_path: Path, output_dir: Path, *, interval: int = 15) -> int:
+    """Extract video frames every `interval` seconds as JPEG.
+
+    Returns the number of frames extracted.
+    """
+    output_dir.mkdir(parents=True, exist_ok=True)
+    pattern = str(output_dir / "frame_%03d.jpg")
+
+    cmd = [
+        "ffmpeg", "-i", str(input_path),
+        "-vf", f"fps=1/{interval}",
+        "-q:v", "2",
+        pattern,
+        "-loglevel", "warning",
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise RuntimeError(f"ffmpeg frame extraction failed: {result.stderr.strip()}")
+
+    return len(list(output_dir.glob("frame_*.jpg")))
+
+
+def has_video_stream(input_path: Path) -> bool:
+    """Check if file contains a video stream using ffprobe."""
+    cmd = [
+        "ffprobe", "-v", "error",
+        "-select_streams", "v",
+        "-show_entries", "stream=codec_type",
+        "-of", "csv=p=0",
+        str(input_path),
+    ]
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    return "video" in result.stdout.lower()

slurpai-0.1.0/src/ingestible/log.py

@@ -0,0 +1,23 @@
+"""Simple dual logger — writes to stdout and a process.log file."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+
+
+class ProcessLog:
+    """Logger that writes timestamped messages to both stdout and a file."""
+
+    def __init__(self, log_path: Path):
+        self.log_path = log_path
+        self.log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    def log(self, message: str) -> None:
+        line = f"[{datetime.now().strftime('%H:%M:%S')}] {message}"
+        print(line)
+        with self.log_path.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+
+    def skip(self, message: str) -> None:
+        self.log(f"[skip] {message}")

slurpai-0.1.0/src/ingestible/process.py

@@ -0,0 +1,98 @@
+"""Core orchestrator — processes a single file through the ingest pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .ffmpeg import extract_audio, extract_frames, has_video_stream
+from .log import ProcessLog
+from .transcribe import transcribe
+
+AUDIO_EXTENSIONS = {".opus", ".m4a", ".ogg", ".mp3", ".wav"}
+VIDEO_EXTENSIONS = {".mp4", ".mkv", ".mov", ".webm"}
+SUPPORTED_EXTENSIONS = AUDIO_EXTENSIONS | VIDEO_EXTENSIONS
+
+
+def process_file(
+    input_path: Path,
+    *,
+    backend: str,
+    frame_interval: int = 15,
+    output_dir: Path | None = None,
+    language: str = "en",
+) -> Path:
+    """Process a single audio/video file. Returns the output directory."""
+    input_path = input_path.resolve()
+    ext = input_path.suffix.lower()
+
+    if ext not in SUPPORTED_EXTENSIONS:
+        raise ValueError(f"Unsupported format: {ext}")
+
+    out = _resolve_output_dir(input_path, output_dir)
+    out.mkdir(parents=True, exist_ok=True)
+
+    log = ProcessLog(out / "process.log")
+    log.log(f"=== Ingestible v0.1.0 ===")
+    log.log(f"Input:   {input_path}")
+    log.log(f"Output:  {out}/")
+    log.log(f"Backend: {backend}")
+
+    transcript_path = out / "transcript.txt"
+    is_video = ext in VIDEO_EXTENSIONS and has_video_stream(input_path)
+
+    # --- Step 1: Transcribe ---
+    # Always convert to MP3 first — normalises all formats into one known-good
+    # path. This matches the proven bash script behaviour: no conditionals,
+    # no format-compatibility surprises.
+    if transcript_path.exists():
+        log.skip(f"Transcript already exists: {transcript_path.name}")
+    else:
+        audio_tmp = out / "audio.mp3"
+        if audio_tmp.exists():
+            log.skip(f"Audio already extracted: {audio_tmp.name}")
+        else:
+            log.log("Extracting audio...")
+            extract_audio(input_path, audio_tmp)
+            log.log(f"Audio extracted: {_file_size(audio_tmp)}")
+
+        log.log(f"Transcribing with {backend}...")
+        text = transcribe(audio_tmp, backend=backend, language=language)
+        transcript_path.write_text(text, encoding="utf-8")
+        word_count = len(text.split())
+        log.log(f"Transcript: {word_count} words")
+
+        # Clean up intermediate audio
+        audio_tmp.unlink(missing_ok=True)
+
+    # --- Step 2: Extract frames (video only) ---
+    frames_dir = out / "frames"
+    if not is_video:
+        log.skip("Audio-only file — no frames to extract")
+    elif list(frames_dir.glob("frame_*.jpg")):
+        existing = len(list(frames_dir.glob("frame_*.jpg")))
+        log.skip(f"Frames already exist: {existing} frames")
+    else:
+        log.log(f"Extracting frames every {frame_interval}s...")
+        count = extract_frames(input_path, frames_dir, interval=frame_interval)
+        log.log(f"Extracted {count} frames")
+
+    log.log("=== Done ===")
+    return out
+
+
+def _resolve_output_dir(input_path: Path, output_dir: Path | None) -> Path:
+    """Derive output directory: <parent>/<stem>/ or <output_dir>/<stem>/."""
+    stem = input_path.stem
+    if output_dir:
+        return output_dir / stem
+    return input_path.parent / stem
+
+
+def _file_size(path: Path) -> str:
+    """Human-readable file size."""
+    size = path.stat().st_size
+    for unit in ("B", "KB", "MB", "GB"):
+        if size < 1024:
+            return f"{size:.1f} {unit}"
+        size /= 1024
+    return f"{size:.1f} TB"

slurpai-0.1.0/src/ingestible/transcribe.py

@@ -0,0 +1,83 @@
+"""Transcription backends — OpenAI Whisper API and faster-whisper local."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+
+def transcribe(audio_path: Path, *, backend: str, language: str = "en") -> str:
+    """Transcribe an audio file, returning the text.
+
+    Routes to the appropriate backend based on the `backend` argument.
+    """
+    if backend == "openai":
+        return _transcribe_openai(audio_path, language=language)
+    elif backend == "faster-whisper":
+        return _transcribe_faster_whisper(audio_path, language=language)
+    else:
+        raise ValueError(f"Unknown backend: {backend!r}. Use 'openai' or 'faster-whisper'.")
+
+
+def _extract_text(payload: Any) -> str:
+    """Defensively extract text from an OpenAI transcription response."""
+    text = getattr(payload, "text", None)
+    if isinstance(text, str) and text.strip():
+        return text.strip()
+    if isinstance(payload, dict):
+        candidate = payload.get("text")
+        if isinstance(candidate, str) and candidate.strip():
+            return candidate.strip()
+    raise ValueError("Transcription response missing text output")
+
+
+def _transcribe_openai(audio_path: Path, *, language: str) -> str:
+    """Transcribe using the OpenAI Whisper API via the SDK."""
+    try:
+        from openai import OpenAI
+    except ImportError:
+        raise ImportError(
+            "OpenAI backend requires the openai package. "
+            "Install with: pip install ingestible[openai]"
+        )
+
+    api_key = os.getenv("OPENAI_API_KEY")
+    if not api_key:
+        raise RuntimeError(
+            "OPENAI_API_KEY not set. Add it to your .env file or environment."
+        )
+
+    client = OpenAI()
+    model = os.getenv("OPENAI_WHISPER_MODEL", "whisper-1").strip() or "whisper-1"
+
+    with audio_path.open("rb") as f:
+        response = client.audio.transcriptions.create(
+            file=f,
+            model=model,
+            language=language,
+        )
+
+    return _extract_text(response)
+
+
+def _transcribe_faster_whisper(audio_path: Path, *, language: str) -> str:
+    """Transcribe locally using faster-whisper on CPU."""
+    try:
+        from faster_whisper import WhisperModel
+    except ImportError:
+        raise ImportError(
+            "Local backend requires faster-whisper. "
+            "Install with: pip install ingestible[local]"
+        )
+
+    model_size = os.getenv("INGESTIBLE_WHISPER_MODEL", "base").strip() or "base"
+    model = WhisperModel(model_size, device="cpu", compute_type="int8")
+
+    segments, _info = model.transcribe(str(audio_path), language=language)
+    text = " ".join(segment.text.strip() for segment in segments)
+
+    if not text.strip():
+        raise ValueError("Transcription produced no text")
+
+    return text.strip()

slurpai-0.1.0/tests/conftest.py

@@ -0,0 +1,43 @@
+"""Shared test fixtures."""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def sample_audio(tmp_path: Path) -> Path:
+    """Create a tiny audio file (1 second of silence) for testing."""
+    audio = tmp_path / "test.mp3"
+    subprocess.run(
+        [
+            "ffmpeg", "-y",
+            "-f", "lavfi", "-i", "anullsrc=r=16000:cl=mono",
+            "-t", "1", "-q:a", "9",
+            str(audio),
+        ],
+        capture_output=True,
+        check=True,
+    )
+    return audio
+
+
+@pytest.fixture
+def sample_video(tmp_path: Path) -> Path:
+    """Create a tiny video file (3 seconds, test pattern + silence)."""
+    video = tmp_path / "test.mp4"
+    subprocess.run(
+        [
+            "ffmpeg", "-y",
+            "-f", "lavfi", "-i", "testsrc=duration=3:size=320x240:rate=1",
+            "-f", "lavfi", "-i", "anullsrc=r=16000:cl=mono",
+            "-t", "3", "-shortest",
+            str(video),
+        ],
+        capture_output=True,
+        check=True,
+    )
+    return video

slurpai-0.1.0/tests/test_cli.py

@@ -0,0 +1,38 @@
+"""Tests for the CLI entry point."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from click.testing import CliRunner
+
+from ingestible.cli import ingest
+
+
+def test_help():
+    runner = CliRunner()
+    result = runner.invoke(ingest, ["--help"])
+    assert result.exit_code == 0
+    assert "Convert voice notes" in result.output
+
+
+def test_version():
+    runner = CliRunner()
+    result = runner.invoke(ingest, ["--version"])
+    assert result.exit_code == 0
+    assert "0.1.0" in result.output
+
+
+def test_dry_run(sample_audio: Path):
+    runner = CliRunner()
+    result = runner.invoke(ingest, ["--dry-run", str(sample_audio)])
+    assert result.exit_code == 0
+    assert "Would process 1 file(s)" in result.output
+
+
+def test_unsupported_file_skipped(tmp_path: Path):
+    txt = tmp_path / "notes.txt"
+    txt.write_text("hello")
+    runner = CliRunner()
+    result = runner.invoke(ingest, [str(txt)])
+    assert "Skipping unsupported format" in result.output

slurpai-0.1.0/tests/test_ffmpeg.py

@@ -0,0 +1,32 @@
+"""Tests for the ffmpeg module."""
+
+from pathlib import Path
+
+from ingestible.ffmpeg import check_ffmpeg, extract_audio, extract_frames, has_video_stream
+
+
+def test_check_ffmpeg():
+    assert check_ffmpeg() is True
+
+
+def test_has_video_stream_with_video(sample_video: Path):
+    assert has_video_stream(sample_video) is True
+
+
+def test_has_video_stream_with_audio(sample_audio: Path):
+    assert has_video_stream(sample_audio) is False
+
+
+def test_extract_audio(sample_video: Path, tmp_path: Path):
+    output = tmp_path / "out.mp3"
+    result = extract_audio(sample_video, output)
+    assert result == output
+    assert output.exists()
+    assert output.stat().st_size > 0
+
+
+def test_extract_frames(sample_video: Path, tmp_path: Path):
+    frames_dir = tmp_path / "frames"
+    count = extract_frames(sample_video, frames_dir, interval=1)
+    assert count >= 1
+    assert len(list(frames_dir.glob("frame_*.jpg"))) == count

slurpai-0.1.0/tests/test_process.py

@@ -0,0 +1,70 @@
+"""Tests for the process orchestrator."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+from ingestible.process import SUPPORTED_EXTENSIONS, process_file
+
+
+def test_supported_extensions_include_common_formats():
+    assert ".opus" in SUPPORTED_EXTENSIONS
+    assert ".m4a" in SUPPORTED_EXTENSIONS
+    assert ".mp4" in SUPPORTED_EXTENSIONS
+    assert ".mp3" in SUPPORTED_EXTENSIONS
+
+
+def test_process_audio_file(sample_audio: Path):
+    """Process an audio file with mocked transcription."""
+    with patch("ingestible.process.transcribe", return_value="Hello from the test"):
+        out = process_file(sample_audio, backend="openai")
+
+    assert out.is_dir()
+    transcript = out / "transcript.txt"
+    assert transcript.exists()
+    assert transcript.read_text() == "Hello from the test"
+
+    log = out / "process.log"
+    assert log.exists()
+    assert "Done" in log.read_text()
+
+    # Audio-only: no frames directory should be populated
+    frames = out / "frames"
+    assert not list(frames.glob("frame_*.jpg")) if frames.exists() else True
+
+
+def test_process_video_file(sample_video: Path):
+    """Process a video file with mocked transcription."""
+    with patch("ingestible.process.transcribe", return_value="Video transcript here"):
+        out = process_file(sample_video, backend="openai", frame_interval=1)
+
+    assert out.is_dir()
+    transcript = out / "transcript.txt"
+    assert transcript.exists()
+    assert transcript.read_text() == "Video transcript here"
+
+    frames = out / "frames"
+    assert frames.is_dir()
+    assert len(list(frames.glob("frame_*.jpg"))) >= 1
+
+
+def test_idempotent_skip(sample_audio: Path):
+    """Second run should skip transcription."""
+    with patch("ingestible.process.transcribe", return_value="First run") as mock_t:
+        process_file(sample_audio, backend="openai")
+        assert mock_t.call_count == 1
+
+    with patch("ingestible.process.transcribe", return_value="Second run") as mock_t:
+        process_file(sample_audio, backend="openai")
+        assert mock_t.call_count == 0  # Should have been skipped
+
+
+def test_unsupported_format(tmp_path: Path):
+    """Unsupported extensions raise ValueError."""
+    txt = tmp_path / "notes.txt"
+    txt.write_text("hello")
+
+    import pytest
+    with pytest.raises(ValueError, match="Unsupported format"):
+        process_file(txt, backend="openai")

slurpai-0.1.0/tests/test_transcribe.py

@@ -0,0 +1,62 @@
+"""Tests for the transcription module (mocked — no API calls)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from ingestible.transcribe import _extract_text, transcribe
+
+
+class TestExtractText:
+    def test_from_object_attribute(self):
+        obj = MagicMock()
+        obj.text = "Hello world"
+        assert _extract_text(obj) == "Hello world"
+
+    def test_from_dict(self):
+        assert _extract_text({"text": "Hello world"}) == "Hello world"
+
+    def test_strips_whitespace(self):
+        assert _extract_text({"text": "  Hello world  "}) == "Hello world"
+
+    def test_raises_on_empty(self):
+        with pytest.raises(ValueError, match="missing text"):
+            _extract_text({"text": ""})
+
+    def test_raises_on_missing(self):
+        with pytest.raises(ValueError, match="missing text"):
+            _extract_text({})
+
+
+class TestTranscribeOpenAI:
+    @patch("ingestible.transcribe.OpenAI", create=True)
+    def test_calls_api(self, mock_openai_cls, sample_audio: Path, monkeypatch):
+        monkeypatch.setenv("OPENAI_API_KEY", "sk-test")
+
+        mock_response = MagicMock()
+        mock_response.text = "This is the transcript"
+        mock_client = MagicMock()
+        mock_client.audio.transcriptions.create.return_value = mock_response
+
+        # Patch the lazy import inside _transcribe_openai
+        with patch("ingestible.transcribe.OpenAI", return_value=mock_client, create=True):
+            # Need to patch at the point of import
+            import ingestible.transcribe as mod
+            with patch.object(mod, "_transcribe_openai") as mock_fn:
+                mock_fn.return_value = "This is the transcript"
+                result = transcribe(sample_audio, backend="openai")
+
+        assert result == "This is the transcript"
+
+    def test_raises_without_api_key(self, sample_audio: Path, monkeypatch):
+        monkeypatch.delenv("OPENAI_API_KEY", raising=False)
+        with pytest.raises(RuntimeError, match="OPENAI_API_KEY"):
+            transcribe(sample_audio, backend="openai")
+
+
+def test_unknown_backend(sample_audio: Path):
+    with pytest.raises(ValueError, match="Unknown backend"):
+        transcribe(sample_audio, backend="nonexistent")