ytxt 0.1.0__tar.gz

ytxt-0.1.0/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: ytxt
+Version: 0.1.0
+Summary: Local audio and YouTube transcription CLI
+Author: Rayan Rane
+License: MIT
+Project-URL: Homepage, https://github.com/rayanrane/ytxt
+Project-URL: Bug Tracker, https://github.com/rayanrane/ytxt/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: yt-dlp
+Requires-Dist: faster-whisper
+
+# ytxt
+
+`ytxt` is a local, private CLI tool for transcribing audio from YouTube, web URLs, or local files using `faster-whisper`. All processing happens securely on your machine—no external APIs or cloud services required.
+
+## Installation
+
+Ensure you have `ffmpeg` installed on your system. Then, install the project:
+
+```bash
+pip install .
+```
+
+Alternatively, if you are running from the source:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+Basic usage:
+```bash
+ytxt <url_or_local_file_path>
+```
+
+### Options
+
+- `--format [text|markdown|srt|json]`: Specify output format.
+- `--model [base|small|medium|large]`: Choose the Whisper model size.
+- `--timestamps`: Include start and end times in text/markdown output.
+- `--output <path>`: Save the transcript to a file.
+- `--no-cache`: Force a re-transcription by ignoring existing cache.
+
+### Examples
+
+**Transcribe a web URL (YouTube or other):**
+```bash
+ytxt https://www.example.com/audio.mp3 --format markdown --timestamps --output transcript.md
+```
+
+**Transcribe a local audio file:**
+```bash
+ytxt path/to/audio.mp3 --model medium --output transcript.txt
+```
+
+## Features
+
+- **Local-Only:** Privacy-first; no data leaves your machine.
+- **Universal Support:** Transcribe YouTube videos, web audio URLs, and local files.
+- **Caching:** Efficiently caches results to avoid redundant work.
+- **Formats:** Supports text, Markdown, SRT, and JSON.
+- **Model Selection:** Flexibility to balance accuracy and performance by choosing your desired Whisper model size.

ytxt-0.1.0/README.md

@@ -0,0 +1,52 @@
+# ytxt
+
+`ytxt` is a local, private CLI tool for transcribing audio from YouTube, web URLs, or local files using `faster-whisper`. All processing happens securely on your machine—no external APIs or cloud services required.
+
+## Installation
+
+Ensure you have `ffmpeg` installed on your system. Then, install the project:
+
+```bash
+pip install .
+```
+
+Alternatively, if you are running from the source:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+Basic usage:
+```bash
+ytxt <url_or_local_file_path>
+```
+
+### Options
+
+- `--format [text|markdown|srt|json]`: Specify output format.
+- `--model [base|small|medium|large]`: Choose the Whisper model size.
+- `--timestamps`: Include start and end times in text/markdown output.
+- `--output <path>`: Save the transcript to a file.
+- `--no-cache`: Force a re-transcription by ignoring existing cache.
+
+### Examples
+
+**Transcribe a web URL (YouTube or other):**
+```bash
+ytxt https://www.example.com/audio.mp3 --format markdown --timestamps --output transcript.md
+```
+
+**Transcribe a local audio file:**
+```bash
+ytxt path/to/audio.mp3 --model medium --output transcript.txt
+```
+
+## Features
+
+- **Local-Only:** Privacy-first; no data leaves your machine.
+- **Universal Support:** Transcribe YouTube videos, web audio URLs, and local files.
+- **Caching:** Efficiently caches results to avoid redundant work.
+- **Formats:** Supports text, Markdown, SRT, and JSON.
+- **Model Selection:** Flexibility to balance accuracy and performance by choosing your desired Whisper model size.

ytxt-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ytxt"
+version = "0.1.0"
+authors = [
+  { name="Rayan Rane" },
+]
+description = "Local audio and YouTube transcription CLI"
+readme = "README.md"
+requires-python = ">=3.7"
+license = {text = "MIT"}
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "yt-dlp",
+    "faster-whisper",
+]
+
+[project.urls]
+"Homepage" = "https://github.com/rayanrane/ytxt"
+"Bug Tracker" = "https://github.com/rayanrane/ytxt/issues"
+
+[project.scripts]
+ytxt = "ytxt.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

ytxt-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ytxt-0.1.0/src/ytxt/__init__.py

@@ -0,0 +1,12 @@
+from .downloader import download_audio
+from .transcriber import transcribe_audio
+from .formatter import format_transcript
+from .cache import read_cache, write_cache
+
+__all__ = [
+    "download_audio",
+    "transcribe_audio",
+    "format_transcript",
+    "read_cache",
+    "write_cache",
+]

ytxt-0.1.0/src/ytxt/cache.py

@@ -0,0 +1,21 @@
+import json
+import hashlib
+from pathlib import Path
+from typing import Optional, List, Dict
+
+CACHE_DIR = Path("cache")
+
+def get_cache_path(video_id: str) -> Path:
+    CACHE_DIR.mkdir(exist_ok=True)
+    return CACHE_DIR / f"{video_id}.json"
+
+def read_cache(video_id: str) -> Optional[List[Dict]]:
+    path = get_cache_path(video_id)
+    if path.exists():
+        with open(path, "r") as f:
+            return json.load(f)
+    return None
+
+def write_cache(video_id: str, transcript: List[Dict]):
+    with open(get_cache_path(video_id), "w") as f:
+        json.dump(transcript, f)

ytxt-0.1.0/src/ytxt/cli.py

@@ -0,0 +1,72 @@
+import argparse
+import sys
+import hashlib
+import re
+from pathlib import Path
+from .downloader import download_audio
+from .transcriber import transcribe_audio
+from .formatter import format_transcript
+from .cache import read_cache, write_cache
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="ytxt: Local YouTube transcript CLI")
+    parser.add_argument("url", help="YouTube/Audio URL or local file path to transcribe")
+    parser.add_argument("--output", help="Output file path")
+    parser.add_argument("--format", choices=["text", "markdown", "srt", "json"], default="text", help="Output format")
+    parser.add_argument("--model", default="base", help="Whisper model to use")
+    parser.add_argument("--timestamps", action="store_true", help="Include timestamps in output")
+    parser.add_argument("--no-cache", action="store_true", help="Skip cache usage")
+    
+    return parser.parse_args()
+
+def main():
+    args = parse_args()
+    
+    input_path = Path(args.url)
+    
+    # Check if local file
+    if input_path.exists() and input_path.is_file():
+        audio_file = input_path
+        # Use absolute path for consistent cache key
+        cache_key = hashlib.md5(str(input_path.absolute()).encode()).hexdigest()
+        print(f"Using local file: {input_path}")
+    else:
+        # It's a URL
+        # Use URL as cache key for web sources
+        cache_key = hashlib.md5(args.url.encode()).hexdigest()
+        
+        # Check cache first
+        transcript = None
+        if not args.no_cache:
+            transcript = read_cache(cache_key)
+            if transcript:
+                print("Using cached transcript...")
+        
+        if not transcript:
+            print(f"Downloading audio from {args.url}...")
+            audio_file = download_audio(args.url)
+            print("Transcribing...")
+            transcript = transcribe_audio(audio_file, args.model)
+            write_cache(cache_key, transcript)
+            # Cleanup temp file
+            if audio_file.exists():
+                audio_file.unlink()
+        else:
+            # We already have the transcript from cache
+            pass
+
+    # Ensure transcript is loaded (from file transcription or cached/downloaded)
+    if 'transcript' not in locals():
+        print("Transcribing...")
+        transcript = transcribe_audio(audio_file, args.model)
+    
+    output = format_transcript(transcript, args.format, args.timestamps)
+    
+    if args.output:
+        out_path = Path(args.output)
+        out_path.parent.mkdir(parents=True, exist_ok=True)
+        out_path.write_text(output)
+        print(f"Transcript saved to {out_path}")
+    else:
+        print(output)
+

ytxt-0.1.0/src/ytxt/downloader.py

@@ -0,0 +1,33 @@
+import yt_dlp
+import uuid
+from pathlib import Path
+
+def download_audio(url: str, output_dir: Path = Path("temp")) -> Path:
+    """Downloads audio from any yt-dlp supported site."""
+    output_dir.mkdir(exist_ok=True)
+    
+    # Use a unique ID for the filename to prevent collisions
+    unique_id = str(uuid.uuid4())
+    
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'outtmpl': str(output_dir / f"{unique_id}.%(ext)s"),
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+    }
+    
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        info = ydl.extract_info(url, download=True)
+        
+        # yt-dlp returns info about the download. 
+        # If it was a playlist, we might need to handle multiple files, 
+        # but for now we assume a single download.
+        if 'entries' in info:
+            # Handle playlist: get the first item
+            info = info['entries'][0]
+            
+        audio_file = output_dir / f"{unique_id}.mp3"
+        return audio_file

ytxt-0.1.0/src/ytxt/formatter.py

@@ -0,0 +1,28 @@
+import json
+from pathlib import Path
+from typing import List, Dict
+
+def format_transcript(transcript: List[Dict], format_type: str, include_timestamps: bool = False) -> str:
+    """Formats transcript data into requested format."""
+    if format_type == "json":
+        return json.dumps(transcript, indent=2)
+    
+    output = []
+    for segment in transcript:
+        line = ""
+        if include_timestamps:
+            line += f"[{segment['start']:.2f} - {segment['end']:.2f}] "
+        line += segment['text']
+        output.append(line)
+    
+    if format_type == "markdown":
+        return "\n\n".join(output)
+    elif format_type == "srt":
+        srt_output = []
+        for i, segment in enumerate(transcript, 1):
+            start = f"{int(segment['start']//3600):02}:{int((segment['start']%3600)//60):02}:{int(segment['start']%60):02},{int((segment['start']*1000)%1000):03}"
+            end = f"{int(segment['end']//3600):02}:{int((segment['end']%3600)//60):02}:{int(segment['end']%60):02},{int((segment['end']*1000)%1000):03}"
+            srt_output.append(f"{i}\n{start} --> {end}\n{segment['text']}\n")
+        return "\n".join(srt_output)
+        
+    return "\n".join(output)

ytxt-0.1.0/src/ytxt/transcriber.py

@@ -0,0 +1,17 @@
+from faster_whisper import WhisperModel
+from pathlib import Path
+from typing import List, Dict
+
+def transcribe_audio(audio_path: Path, model_size: str = "base") -> List[Dict]:
+    """Transcribes audio using faster-whisper on CPU."""
+    model = WhisperModel(model_size, device="cpu", compute_type="int8")
+    segments, info = model.transcribe(str(audio_path), beam_size=5)
+    
+    transcript = []
+    for segment in segments:
+        transcript.append({
+            "start": segment.start,
+            "end": segment.end,
+            "text": segment.text.strip()
+        })
+    return transcript

ytxt-0.1.0/src/ytxt.egg-info/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: ytxt
+Version: 0.1.0
+Summary: Local audio and YouTube transcription CLI
+Author: Rayan Rane
+License: MIT
+Project-URL: Homepage, https://github.com/rayanrane/ytxt
+Project-URL: Bug Tracker, https://github.com/rayanrane/ytxt/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: yt-dlp
+Requires-Dist: faster-whisper
+
+# ytxt
+
+`ytxt` is a local, private CLI tool for transcribing audio from YouTube, web URLs, or local files using `faster-whisper`. All processing happens securely on your machine—no external APIs or cloud services required.
+
+## Installation
+
+Ensure you have `ffmpeg` installed on your system. Then, install the project:
+
+```bash
+pip install .
+```
+
+Alternatively, if you are running from the source:
+
+```bash
+pip install -r requirements.txt
+```
+
+## Usage
+
+Basic usage:
+```bash
+ytxt <url_or_local_file_path>
+```
+
+### Options
+
+- `--format [text|markdown|srt|json]`: Specify output format.
+- `--model [base|small|medium|large]`: Choose the Whisper model size.
+- `--timestamps`: Include start and end times in text/markdown output.
+- `--output <path>`: Save the transcript to a file.
+- `--no-cache`: Force a re-transcription by ignoring existing cache.
+
+### Examples
+
+**Transcribe a web URL (YouTube or other):**
+```bash
+ytxt https://www.example.com/audio.mp3 --format markdown --timestamps --output transcript.md
+```
+
+**Transcribe a local audio file:**
+```bash
+ytxt path/to/audio.mp3 --model medium --output transcript.txt
+```
+
+## Features
+
+- **Local-Only:** Privacy-first; no data leaves your machine.
+- **Universal Support:** Transcribe YouTube videos, web audio URLs, and local files.
+- **Caching:** Efficiently caches results to avoid redundant work.
+- **Formats:** Supports text, Markdown, SRT, and JSON.
+- **Model Selection:** Flexibility to balance accuracy and performance by choosing your desired Whisper model size.

ytxt-0.1.0/src/ytxt.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+src/ytxt/__init__.py
+src/ytxt/cache.py
+src/ytxt/cli.py
+src/ytxt/downloader.py
+src/ytxt/formatter.py
+src/ytxt/transcriber.py
+src/ytxt.egg-info/PKG-INFO
+src/ytxt.egg-info/SOURCES.txt
+src/ytxt.egg-info/dependency_links.txt
+src/ytxt.egg-info/entry_points.txt
+src/ytxt.egg-info/requires.txt
+src/ytxt.egg-info/top_level.txt

ytxt-0.1.0/src/ytxt.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ytxt-0.1.0/src/ytxt.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ytxt = ytxt.cli:main

ytxt-0.1.0/src/ytxt.egg-info/requires.txt

@@ -0,0 +1,2 @@
+yt-dlp
+faster-whisper

ytxt-0.1.0/src/ytxt.egg-info/top_level.txt

@@ -0,0 +1 @@
+ytxt