s2t-py 0.1.0__tar.gz

s2t_py-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Draxon
+
+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.

s2t_py-0.1.0/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: s2t-py
+Version: 0.1.0
+Summary: Fast, multimodal speech-to-text CLI powered by DraxonLLMs
+Author: Draxon
+License: MIT
+Project-URL: Homepage, https://github.com/DraxonV1/Speech2Text
+Project-URL: Repository, https://github.com/DraxonV1/Speech2Text
+Project-URL: Issues, https://github.com/DraxonV1/Speech2Text/issues
+Keywords: speech-to-text,audio,transcription,llm,draxonllms,cli,gemini,qwen
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# s2t (Speech-to-Text CLI)
+
+A lightweight CLI tool for transcribing audio (`.mp3`, `.opus`, `.m4a`, `.wav`, `.flac`, `.ogg`, etc.) directly to plain text or clean multi-page PDF documents using [DraxonLLMs](https://ai.draxon.one).
+
+## Features
+
+- **Multi-Format Support**: Handles `.mp3`, `.opus`, `.m4a`, `.wav`, `.flac`, `.ogg`, etc. Auto-normalizes inputs to 16kHz mono WAV via `ffmpeg` if available.
+- **Multilingual LLM Audio Models**: Powered by audio-native models (`gemini-flash`, `gemini-pro`, `qwen3.8-omni-flash`, `mimo-v2.5-asr`).
+- **Flexible Outputs**:
+  - Direct raw text to `stdout`
+  - Output to plain text file (`.txt`)
+  - Standalone multi-page PDF export (`.pdf`) with automatic page wrapping and zero external dependencies
+- **Live Streaming**: Stream tokens directly to terminal in real-time (`--stream`).
+
+---
+
+## Installation
+
+### Via pip:
+
+```bash
+pip install s2t-py
+```
+
+### From source:
+
+```bash
+git clone https://github.com/DraxonV1/Speech2Text.git
+cd Speech2Text
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+### 1. Set API Key
+
+Set your DraxonLLMs API key via environment variable:
+
+```bash
+# Linux / macOS
+export DRAXON_API_KEY="drx_your_api_key_here"
+
+# Windows PowerShell
+$env:DRAXON_API_KEY="drx_your_api_key_here"
+
+# Windows Command Prompt
+set DRAXON_API_KEY=drx_your_api_key_here
+```
+
+*(You can also pass it explicitly with `--api-key="drx_..."`)*
+
+### 2. Transcribe Audio
+
+#### Print raw text directly to terminal:
+```bash
+s2t --input=voice.opus
+```
+
+#### Output to plain text file:
+```bash
+s2t --input=meeting.mp3 --output=transcript.txt
+```
+
+#### Output to formatted PDF document:
+```bash
+s2t --input=interview.m4a --output=interview.pdf
+```
+
+#### Real-time streaming transcription:
+```bash
+s2t --input=speech.wav --stream
+```
+
+---
+
+## CLI Options
+
+```text
+usage: s2t [-h] -i INPUT [-o OUTPUT] [--api-key API_KEY] [--api-base API_BASE]
+           [--model MODEL] [--stream]
+
+options:
+  -h, --help            show this help message and exit
+  -i INPUT, --input INPUT
+                        Input audio file (.mp3, .opus, .m4a, .wav, etc.)
+  -o OUTPUT, --output OUTPUT
+                        Output file (.txt or .pdf). If omitted, prints raw text to stdout.
+  --api-key API_KEY     DraxonLLMs API key (default: env DRAXON_API_KEY)
+  --api-base API_BASE   API base URL (default: https://ai.draxon.one/api/v1)
+  --model MODEL         Model name (default: gemini-flash)
+  --stream              Stream raw text from model in real time
+```
+
+---
+
+## Supported Models
+
+Refer to `models.txt` for the current audio model roster:
+
+- `gemini-flash` *(default)*: High accuracy, low latency, multilingual (English, Hindi, Spanish, etc.)
+- `gemini-pro`: Maximum reasoning and contextual transcription
+- `qwen3.8-omni-flash`: Omni-channel audio model
+- `mimo-v2.5-asr`: Specialized Chinese speech recognition
+
+To select a different model:
+```bash
+s2t --input=audio.mp3 --model=gemini-pro
+```
+
+---
+
+## License
+
+MIT

s2t_py-0.1.0/README.md

@@ -0,0 +1,116 @@
+# s2t (Speech-to-Text CLI)
+
+A lightweight CLI tool for transcribing audio (`.mp3`, `.opus`, `.m4a`, `.wav`, `.flac`, `.ogg`, etc.) directly to plain text or clean multi-page PDF documents using [DraxonLLMs](https://ai.draxon.one).
+
+## Features
+
+- **Multi-Format Support**: Handles `.mp3`, `.opus`, `.m4a`, `.wav`, `.flac`, `.ogg`, etc. Auto-normalizes inputs to 16kHz mono WAV via `ffmpeg` if available.
+- **Multilingual LLM Audio Models**: Powered by audio-native models (`gemini-flash`, `gemini-pro`, `qwen3.8-omni-flash`, `mimo-v2.5-asr`).
+- **Flexible Outputs**:
+  - Direct raw text to `stdout`
+  - Output to plain text file (`.txt`)
+  - Standalone multi-page PDF export (`.pdf`) with automatic page wrapping and zero external dependencies
+- **Live Streaming**: Stream tokens directly to terminal in real-time (`--stream`).
+
+---
+
+## Installation
+
+### Via pip:
+
+```bash
+pip install s2t-py
+```
+
+### From source:
+
+```bash
+git clone https://github.com/DraxonV1/Speech2Text.git
+cd Speech2Text
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+### 1. Set API Key
+
+Set your DraxonLLMs API key via environment variable:
+
+```bash
+# Linux / macOS
+export DRAXON_API_KEY="drx_your_api_key_here"
+
+# Windows PowerShell
+$env:DRAXON_API_KEY="drx_your_api_key_here"
+
+# Windows Command Prompt
+set DRAXON_API_KEY=drx_your_api_key_here
+```
+
+*(You can also pass it explicitly with `--api-key="drx_..."`)*
+
+### 2. Transcribe Audio
+
+#### Print raw text directly to terminal:
+```bash
+s2t --input=voice.opus
+```
+
+#### Output to plain text file:
+```bash
+s2t --input=meeting.mp3 --output=transcript.txt
+```
+
+#### Output to formatted PDF document:
+```bash
+s2t --input=interview.m4a --output=interview.pdf
+```
+
+#### Real-time streaming transcription:
+```bash
+s2t --input=speech.wav --stream
+```
+
+---
+
+## CLI Options
+
+```text
+usage: s2t [-h] -i INPUT [-o OUTPUT] [--api-key API_KEY] [--api-base API_BASE]
+           [--model MODEL] [--stream]
+
+options:
+  -h, --help            show this help message and exit
+  -i INPUT, --input INPUT
+                        Input audio file (.mp3, .opus, .m4a, .wav, etc.)
+  -o OUTPUT, --output OUTPUT
+                        Output file (.txt or .pdf). If omitted, prints raw text to stdout.
+  --api-key API_KEY     DraxonLLMs API key (default: env DRAXON_API_KEY)
+  --api-base API_BASE   API base URL (default: https://ai.draxon.one/api/v1)
+  --model MODEL         Model name (default: gemini-flash)
+  --stream              Stream raw text from model in real time
+```
+
+---
+
+## Supported Models
+
+Refer to `models.txt` for the current audio model roster:
+
+- `gemini-flash` *(default)*: High accuracy, low latency, multilingual (English, Hindi, Spanish, etc.)
+- `gemini-pro`: Maximum reasoning and contextual transcription
+- `qwen3.8-omni-flash`: Omni-channel audio model
+- `mimo-v2.5-asr`: Specialized Chinese speech recognition
+
+To select a different model:
+```bash
+s2t --input=audio.mp3 --model=gemini-pro
+```
+
+---
+
+## License
+
+MIT

s2t_py-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "s2t-py"
+version = "0.1.0"
+description = "Fast, multimodal speech-to-text CLI powered by DraxonLLMs"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "Draxon" }
+]
+keywords = ["speech-to-text", "audio", "transcription", "llm", "draxonllms", "cli", "gemini", "qwen"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Sound/Audio :: Speech",
+]
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.scripts]
+s2t = "s2t:cli"
+
+[project.urls]
+Homepage = "https://github.com/DraxonV1/Speech2Text"
+Repository = "https://github.com/DraxonV1/Speech2Text"
+Issues = "https://github.com/DraxonV1/Speech2Text/issues"

s2t_py-0.1.0/s2t.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+"""
+s2t - Speech-to-Text CLI using DraxonLLMs and Qwen 3.8 Omni Flash
+"""
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import textwrap
+from pathlib import Path
+from typing import Optional
+
+import requests
+
+DEFAULT_API_BASE = os.environ.get("DRAXON_API_BASE", "https://ai.draxon.one/api/v1")
+DEFAULT_API_KEY = os.environ.get("DRAXON_API_KEY", "drx_e1O-gFJJSaLDp9Uv_l1grVDi97vMydQ0")
+DEFAULT_MODEL = os.environ.get("DRAXON_MODEL", "gemini-flash")
+PROMPT = "Output only raw text nothing else, make sure every single letter in audio is outputed"
+
+
+def convert_audio_to_wav(input_path: Path) -> tuple[bytes, str]:
+    """
+    Read input audio file. If ffmpeg is available and file is not already wav,
+    normalize to 16kHz mono WAV for maximum model fidelity.
+    """
+    ext = input_path.suffix.lower().lstrip(".")
+    if not input_path.exists():
+        raise FileNotFoundError(f"Input file not found: {input_path}")
+
+    # If already wav, read directly
+    if ext == "wav":
+        return input_path.read_bytes(), "wav"
+
+    # Check for ffmpeg
+    ffmpeg_bin = shutil.which("ffmpeg")
+    if ffmpeg_bin:
+        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
+            tmp_wav = tmp.name
+
+        try:
+            cmd = [
+                ffmpeg_bin,
+                "-y",
+                "-i",
+                str(input_path),
+                "-vn",
+                "-ar",
+                "16000",
+                "-ac",
+                "1",
+                "-c:a",
+                "pcm_s16le",
+                tmp_wav,
+            ]
+            res = subprocess.run(cmd, capture_output=True, text=True)
+            if res.returncode == 0 and os.path.exists(tmp_wav) and os.path.getsize(tmp_wav) > 0:
+                with open(tmp_wav, "rb") as f:
+                    data = f.read()
+                return data, "wav"
+        finally:
+            if os.path.exists(tmp_wav):
+                try:
+                    os.remove(tmp_wav)
+                except Exception:
+                    pass
+
+    # Fallback to direct raw bytes
+    fmt = "mp3" if ext in {"mp3", "opus", "m4a", "aac", "flac", "ogg"} else ext
+    return input_path.read_bytes(), fmt
+
+
+def transcribe_audio(
+    audio_bytes: bytes,
+    audio_format: str,
+    api_key: str,
+    api_base: str,
+    model: str = DEFAULT_MODEL,
+    stream: bool = False,
+) -> str:
+    """Send audio to DraxonLLMs OpenAI-compatible chat completions endpoint."""
+    b64_data = base64.b64encode(audio_bytes).decode("utf-8")
+
+    payload = {
+        "model": model,
+        "messages": [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": PROMPT},
+                    {
+                        "type": "input_audio",
+                        "input_audio": {
+                            "data": b64_data,
+                            "format": audio_format,
+                        },
+                    },
+                ],
+            }
+        ],
+        "temperature": 0.0,
+        "stream": stream,
+    }
+
+    url = f"{api_base.rstrip('/')}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    if stream:
+        resp = requests.post(url, headers=headers, json=payload, stream=True, timeout=180)
+        resp.raise_for_status()
+        collected: list[str] = []
+        for line in resp.iter_lines(decode_unicode=True):
+            if not line:
+                continue
+            if line.startswith("data: "):
+                data_str = line[6:].strip()
+                if data_str == "[DONE]":
+                    break
+                try:
+                    chunk = json.loads(data_str)
+                    delta = chunk.get("choices", [{}])[0].get("delta", {})
+                    val = delta.get("content") or delta.get("reasoning_content") or ""
+                    if val:
+                        collected.append(val)
+                        sys.stdout.write(val)
+                        sys.stdout.flush()
+                except Exception:
+                    pass
+        if collected:
+            sys.stdout.write("\n")
+            sys.stdout.flush()
+    for attempt in range(5):
+        resp = requests.post(url, headers=headers, json=payload, timeout=180)
+        if resp.status_code == 200:
+            break
+        if resp.status_code in {429, 500, 502, 503, 504} and attempt < 4:
+            import time
+            sleep_sec = 3.0 * (attempt + 1)
+            time.sleep(sleep_sec)
+            continue
+        raise RuntimeError(f"API Error ({resp.status_code}): {resp.text[:300]}")
+
+    data = resp.json()
+    msg = data.get("choices", [{}])[0].get("message", {})
+    content = msg.get("content") or msg.get("reasoning_content") or ""
+    return (content or "").strip()
+
+
+def write_pdf(text: str, output_path: Path) -> None:
+    """Pure Python PDF generator supporting multiline text without third-party dependencies."""
+    max_chars_per_line = 85
+    lines_per_page = 48
+
+    all_lines: list[str] = []
+    for paragraph in text.splitlines():
+        if not paragraph.strip():
+            all_lines.append("")
+        else:
+            wrapped = textwrap.wrap(paragraph, width=max_chars_per_line)
+            all_lines.extend(wrapped)
+
+    if not all_lines:
+        all_lines = [""]
+
+    pages_lines = [all_lines[i : i + lines_per_page] for i in range(0, len(all_lines), lines_per_page)]
+    num_pages = len(pages_lines)
+
+    font_obj_idx = 3 + num_pages * 2
+    objects: dict[int, bytes] = {}
+    page_obj_ids = [3 + i for i in range(num_pages)]
+    content_obj_ids = [3 + num_pages + i for i in range(num_pages)]
+
+    objects[1] = b"<< /Type /Catalog /Pages 2 0 R >>"
+    kids_str = " ".join(f"{pid} 0 R" for pid in page_obj_ids)
+    objects[2] = f"<< /Type /Pages /Kids [{kids_str}] /Count {num_pages} >>".encode("ascii")
+
+    for i in range(num_pages):
+        pid = page_obj_ids[i]
+        cid = content_obj_ids[i]
+        objects[pid] = (
+            f"<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents {cid} 0 R "
+            f"/Resources << /Font << /F1 {font_obj_idx} 0 R >> >> >>"
+        ).encode("ascii")
+
+        page_content = ["BT", "/F1 11 Tf", "50 740 Td", "14 TL"]
+        first = True
+        for line in pages_lines[i]:
+            escaped = line.replace("\\", "\\\\").replace("(", "\\(").replace(")", "\\)")
+            escaped = "".join(c if ord(c) < 256 else "?" for c in escaped)
+            if first:
+                page_content.append(f"({escaped}) Tj")
+                first = False
+            else:
+                page_content.append(f"T* ({escaped}) Tj")
+        page_content.append("ET")
+
+        stream_bytes = "\n".join(page_content).encode("latin1", errors="replace")
+        objects[cid] = (
+            f"<< /Length {len(stream_bytes)} >>\nstream\n".encode("ascii")
+            + stream_bytes
+            + b"\nendstream"
+        )
+
+    objects[font_obj_idx] = b"<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >>"
+
+    buf = bytearray()
+    buf += b"%PDF-1.4\n"
+    total_objs = font_obj_idx
+    xref_offsets = [0] * (total_objs + 1)
+
+    for idx in range(1, total_objs + 1):
+        xref_offsets[idx] = len(buf)
+        buf += f"{idx} 0 obj\n".encode("ascii")
+        buf += objects[idx]
+        buf += b"\nendobj\n"
+
+    startxref = len(buf)
+    buf += b"0000000000 65535 f \n"
+    for idx in range(1, total_objs + 1):
+        buf += f"{xref_offsets[idx]:010d} 00000 n \n".encode("ascii")
+    buf += f"trailer\n<< /Size {total_objs + 1} /Root 1 0 R >>\nstartxref\n{startxref}\n%%EOF\n".encode("ascii")
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_bytes(buf)
+
+
+def main(argv: Optional[list[str]] = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="s2t",
+        description="Speech-to-Text CLI using DraxonLLMs and Qwen 3.8 Omni Flash",
+    )
+    parser.add_argument(
+        "-i",
+        "--input",
+        required=True,
+        help="Input audio file (.mp3, .opus, .m4a, .wav, .flac, .ogg, etc.)",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        required=False,
+        default=None,
+        help="Output file (.txt or .pdf). If omitted, prints raw text to stdout.",
+    )
+    parser.add_argument(
+        "--api-key",
+        default=DEFAULT_API_KEY,
+        help="DraxonLLMs API key (default: env DRAXON_API_KEY or built-in)",
+    )
+    parser.add_argument(
+        "--api-base",
+        default=DEFAULT_API_BASE,
+        help="DraxonLLMs API base URL (default: env DRAXON_API_BASE or https://ai.draxon.one/api/v1)",
+    )
+    parser.add_argument(
+        "--model",
+        default=DEFAULT_MODEL,
+        help=f"Model identifier (default: {DEFAULT_MODEL})",
+    )
+    parser.add_argument(
+        "--stream",
+        action="store_true",
+        help="Stream raw text from model in real time",
+    )
+
+    args = parser.parse_args(argv)
+
+    input_path = Path(args.input)
+    if not input_path.exists():
+        sys.stderr.write(f"Error: input file '{args.input}' does not exist.\n")
+        return 1
+
+    try:
+        audio_bytes, audio_format = convert_audio_to_wav(input_path)
+    except Exception as exc:
+        sys.stderr.write(f"Error reading audio file: {exc}\n")
+        return 1
+
+    # Transcribe via DraxonLLMs
+    try:
+        raw_text = transcribe_audio(
+            audio_bytes=audio_bytes,
+            audio_format=audio_format,
+            api_key=args.api_key,
+            api_base=args.api_base,
+            model=args.model,
+            stream=args.stream and not args.output,
+        )
+    except Exception as exc:
+        sys.stderr.write(f"Transcription error: {exc}\n")
+        return 1
+
+    # Output handling
+    if args.output:
+        out_path = Path(args.output)
+        ext = out_path.suffix.lower()
+        if ext == ".pdf":
+            try:
+                write_pdf(raw_text, out_path)
+                print(f"Saved PDF transcription to {out_path}")
+            except Exception as exc:
+                sys.stderr.write(f"Failed to write PDF: {exc}\n")
+                return 1
+        else:
+            try:
+                out_path.parent.mkdir(parents=True, exist_ok=True)
+                out_path.write_text(raw_text, encoding="utf-8")
+                print(f"Saved text transcription to {out_path}")
+            except Exception as exc:
+                sys.stderr.write(f"Failed to write output text: {exc}\n")
+                return 1
+    else:
+        if not args.stream:
+            print(raw_text)
+
+    return 0
+
+
+def cli() -> None:
+    """Entrypoint for setuptools / console_scripts."""
+    sys.exit(main())
+
+
+if __name__ == "__main__":
+    cli()

s2t_py-0.1.0/s2t_py.egg-info/PKG-INFO

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: s2t-py
+Version: 0.1.0
+Summary: Fast, multimodal speech-to-text CLI powered by DraxonLLMs
+Author: Draxon
+License: MIT
+Project-URL: Homepage, https://github.com/DraxonV1/Speech2Text
+Project-URL: Repository, https://github.com/DraxonV1/Speech2Text
+Project-URL: Issues, https://github.com/DraxonV1/Speech2Text/issues
+Keywords: speech-to-text,audio,transcription,llm,draxonllms,cli,gemini,qwen
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# s2t (Speech-to-Text CLI)
+
+A lightweight CLI tool for transcribing audio (`.mp3`, `.opus`, `.m4a`, `.wav`, `.flac`, `.ogg`, etc.) directly to plain text or clean multi-page PDF documents using [DraxonLLMs](https://ai.draxon.one).
+
+## Features
+
+- **Multi-Format Support**: Handles `.mp3`, `.opus`, `.m4a`, `.wav`, `.flac`, `.ogg`, etc. Auto-normalizes inputs to 16kHz mono WAV via `ffmpeg` if available.
+- **Multilingual LLM Audio Models**: Powered by audio-native models (`gemini-flash`, `gemini-pro`, `qwen3.8-omni-flash`, `mimo-v2.5-asr`).
+- **Flexible Outputs**:
+  - Direct raw text to `stdout`
+  - Output to plain text file (`.txt`)
+  - Standalone multi-page PDF export (`.pdf`) with automatic page wrapping and zero external dependencies
+- **Live Streaming**: Stream tokens directly to terminal in real-time (`--stream`).
+
+---
+
+## Installation
+
+### Via pip:
+
+```bash
+pip install s2t-py
+```
+
+### From source:
+
+```bash
+git clone https://github.com/DraxonV1/Speech2Text.git
+cd Speech2Text
+pip install -e .
+```
+
+---
+
+## Quickstart
+
+### 1. Set API Key
+
+Set your DraxonLLMs API key via environment variable:
+
+```bash
+# Linux / macOS
+export DRAXON_API_KEY="drx_your_api_key_here"
+
+# Windows PowerShell
+$env:DRAXON_API_KEY="drx_your_api_key_here"
+
+# Windows Command Prompt
+set DRAXON_API_KEY=drx_your_api_key_here
+```
+
+*(You can also pass it explicitly with `--api-key="drx_..."`)*
+
+### 2. Transcribe Audio
+
+#### Print raw text directly to terminal:
+```bash
+s2t --input=voice.opus
+```
+
+#### Output to plain text file:
+```bash
+s2t --input=meeting.mp3 --output=transcript.txt
+```
+
+#### Output to formatted PDF document:
+```bash
+s2t --input=interview.m4a --output=interview.pdf
+```
+
+#### Real-time streaming transcription:
+```bash
+s2t --input=speech.wav --stream
+```
+
+---
+
+## CLI Options
+
+```text
+usage: s2t [-h] -i INPUT [-o OUTPUT] [--api-key API_KEY] [--api-base API_BASE]
+           [--model MODEL] [--stream]
+
+options:
+  -h, --help            show this help message and exit
+  -i INPUT, --input INPUT
+                        Input audio file (.mp3, .opus, .m4a, .wav, etc.)
+  -o OUTPUT, --output OUTPUT
+                        Output file (.txt or .pdf). If omitted, prints raw text to stdout.
+  --api-key API_KEY     DraxonLLMs API key (default: env DRAXON_API_KEY)
+  --api-base API_BASE   API base URL (default: https://ai.draxon.one/api/v1)
+  --model MODEL         Model name (default: gemini-flash)
+  --stream              Stream raw text from model in real time
+```
+
+---
+
+## Supported Models
+
+Refer to `models.txt` for the current audio model roster:
+
+- `gemini-flash` *(default)*: High accuracy, low latency, multilingual (English, Hindi, Spanish, etc.)
+- `gemini-pro`: Maximum reasoning and contextual transcription
+- `qwen3.8-omni-flash`: Omni-channel audio model
+- `mimo-v2.5-asr`: Specialized Chinese speech recognition
+
+To select a different model:
+```bash
+s2t --input=audio.mp3 --model=gemini-pro
+```
+
+---
+
+## License
+
+MIT

s2t_py-0.1.0/s2t_py.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+s2t.py
+s2t_py.egg-info/PKG-INFO
+s2t_py.egg-info/SOURCES.txt
+s2t_py.egg-info/dependency_links.txt
+s2t_py.egg-info/entry_points.txt
+s2t_py.egg-info/requires.txt
+s2t_py.egg-info/top_level.txt

s2t_py-0.1.0/s2t_py.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

s2t_py-0.1.0/s2t_py.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+s2t = s2t:cli

s2t_py-0.1.0/s2t_py.egg-info/requires.txt

@@ -0,0 +1 @@
+requests>=2.28.0

s2t_py-0.1.0/s2t_py.egg-info/top_level.txt

@@ -0,0 +1 @@
+s2t

s2t_py-0.1.0/setup.cfg

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