Eliminate unnecessary dev files

pocket-tts-generate-docs.md

@@ -1,83 +0,0 @@
-# Generate Command Documentation
-
-The `generate` command allows you to generate speech from text directly from the command line using Kyutai Pocket TTS.
-
-## Basic Usage
-
-```bash
-uvx pocket-tts generate
-# or if installed manually:
-pocket-tts generate
-```
-
-This will generate a WAV file `./tts_output.wav` with the default text and voice.
-
-## Command Options
-
-### Core Options
-
-- `--text TEXT`: Text to generate (default: "Hello world! I am Kyutai Pocket TTS. I'm fast enough to run on small CPUs. I hope you'll like me.")
-- `--voice VOICE`: Path to audio conditioning file (voice to clone) (default: "hf://kyutai/tts-voices/alba-mackenna/casual.wav"). Urls and local paths are supported.
-- `--output-path OUTPUT_PATH`: Output path for generated audio (default: "./tts_output.wav")
-
-### Generation Parameters
-
-- `--variant VARIANT`: Model signature (default: "b6369a24")
-- `--lsd-decode-steps LSD_DECODE_STEPS`: Number of generation steps (default: 1)
-- `--temperature TEMPERATURE`: Temperature for generation (default: 0.7)
-- `--noise-clamp NOISE_CLAMP`: Noise clamp value (default: None)
-- `--eos-threshold EOS_THRESHOLD`: EOS threshold (default: -4.0)
-- `--frames-after-eos FRAMES_AFTER_EOS`: Number of frames to generate after EOS (default: None, auto-calculated based on the text length). Each frame is 80ms.
-
-### Performance Options
-
-- `--device DEVICE`: Device to use (default: "cpu", you may not get a speedup by using a gpu since it's a small model)
-- `--quiet`, `-q`: Disable logging output
-
-## Examples
-
-### Basic Generation
-
-```bash
-# Generate with default settings
-pocket-tts generate
-
-# Custom text
-pocket-tts generate --text "Hello, this is a custom message."
-
-# Custom output path
-pocket-tts generate --output-path "./my_audio.wav"
-```
-
-### Voice Selection
-
-```bash
-# Use different voice from HuggingFace
-pocket-tts generate --voice "hf://kyutai/tts-voices/jessica-jian/casual.wav"
-
-# Use local voice file
-pocket-tts generate --voice "./my_voice.wav"
-```
-
-### Quality Tuning
-
-```bash
-# Higher quality (more steps)
-pocket-tts generate --lsd-decode-steps 5 --temperature 0.5
-
-# More expressive (higher temperature)
-pocket-tts generate --temperature 1.0
-
-# Adjust EOS threshold, smaller means finishing earlier.
-pocket-tts generate --eos-threshold -3.0
-```
-
-## Output Format
-
-The generate command always outputs WAV files in the following format:
-- **Sample Rate**: 24kHz
-- **Channels**: Mono
-- **Bit Depth**: 16-bit PCM
-- **Format**: Standard WAV file
-
-For more advanced usage, see the [Python API documentation](python-api.md) or consider using the [serve command](serve.md) for web-based generation and quick iteration.

pocket-tts-python-api.md

@@ -1,223 +0,0 @@
-# Python API Documentation
-
-Kyutai Pocket TTS provides a Python API for integrating text-to-speech capabilities into your applications.
-
-## Installation
-
-```bash
-pip install pocket-tts
-```
-
-## Quick Start
-
-```python
-from pocket_tts import TTSModel
-import scipy.io.wavfile
-
-# Load the model
-tts_model = TTSModel.load_model()
-
-# Get voice state from an audio file
-voice_state = tts_model.get_state_for_audio_prompt(
-    "hf://kyutai/tts-voices/alba-mackenna/casual.wav"
-)
-
-# Generate audio
-audio = tts_model.generate_audio(voice_state, "Hello world, this is a test.")
-
-# Save to file
-scipy.io.wavfile.write("output.wav", tts_model.sample_rate, audio.numpy())
-```
-
-## Core Classes
-
-### TTSModel
-
-The main class for text-to-speech generation.
-
-#### Class Methods
-
-##### `load_model(variant="b6369a24", temp=0.7, lsd_decode_steps=1, noise_clamp=None, eos_threshold=-4.0)`
-
-Load and return a TTSModel instance with pre-trained weights.
-
-**Parameters:**
-- `variant` (str): Model variant identifier (default: "b6369a24")
-- `temp` (float): Sampling temperature for generation (default: 0.7)
-- `lsd_decode_steps` (int): Number of generation steps (default: 1)
-- `noise_clamp` (float | None): Maximum value for noise sampling (default: None)
-- `eos_threshold` (float): Threshold for end-of-sequence detection (default: -4.0)
-
-**Returns:**
-- `TTSModel`: Loaded model instance on CPU
-
-**Example:**
-```python
-from pocket_tts import TTSModel
-
-# Load with default settings
-model = TTSModel.load_model()
-
-# Load with custom parameters
-model = TTSModel.load_model(variant="b6369a24", temp=0.5, lsd_decode_steps=5, eos_threshold=-3.0)
-```
-
-#### Properties
-
-##### `device` (str)
-
-Returns the device type where the model is running ("cpu" or "cuda").
-By default, the model runs on CPU.
-
-```python
-from pocket_tts import TTSModel
-
-model = TTSModel.load_model()
-print(f"Model running on: {model.device}")
-```
-
-##### `sample_rate` (int)
-
-Returns the generated audio sample rate (typically 24000 Hz).
-
-```python
-from pocket_tts import TTSModel
-
-model = TTSModel.load_model()
-print(f"Sample rate: {model.sample_rate} Hz")
-```
-
-#### Methods
-
-##### `get_state_for_audio_prompt(audio_conditioning, truncate=False)`
-
-Extract model state for a given audio file or URL (voice cloning).
-
-**Parameters:**
-- `audio_conditioning` (Path | str | torch.Tensor): Audio file path, URL, or tensor
-- `truncate` (bool): Whether to truncate the audio (default: False)
-
-**Returns:**
-- `dict`: Model state dictionary containing hidden states and positional information
-
-**Example:**
-```python
-from pocket_tts import TTSModel
-
-model = TTSModel.load_model()
-# From HuggingFace URL
-voice_state = model.get_state_for_audio_prompt("hf://kyutai/tts-voices/alba-mackenna/casual.wav")
-
-# From local file
-voice_state = model.get_state_for_audio_prompt("./my_voice.wav")
-
-# From HTTP URL
-voice_state = model.get_state_for_audio_prompt(
-    "https://huggingface.co/kyutai/tts-voices/resolve"
-    "/main/expresso/ex01-ex02_default_001_channel1_168s.wav"
-)
-```
-
-##### `generate_audio(model_state, text_to_generate, frames_after_eos=None, copy_state=True)`
-
-Generate complete audio tensor from text input.
-
-**Parameters:**
-- `model_state` (dict): Model state from `get_state_for_audio_prompt()`
-- `text_to_generate` (str): Text to convert to speech
-- `frames_after_eos` (int | None): Frames to generate after EOS detection (default: None)
-- `copy_state` (bool): Whether to copy the state (default: True)
-
-**Returns:**
-- `torch.Tensor`: Audio 1D tensor with shape [samples]
-
-**Example:**
-```python
-from pocket_tts import TTSModel
-
-model = TTSModel.load_model()
-
-voice_state = model.get_state_for_audio_prompt("hf://kyutai/tts-voices/alba-mackenna/casual.wav")
-
-# Generate audio
-audio = model.generate_audio(voice_state, "Hello world!", frames_after_eos=2, copy_state=True)
-
-print(f"Generated audio shape: {audio.shape}")
-print(f"Audio duration: {audio.shape[-1] / model.sample_rate:.2f} seconds")
-```
-
-##### `generate_audio_stream(model_state, text_to_generate, frames_after_eos=None, copy_state=True)`
-
-Generate audio streaming chunks from text input.
-
-**Parameters:** Same as `generate_audio()`
-
-**Yields:**
-- `torch.Tensor`: Audio chunks with shape [samples]
-
-**Example:**
-```python
-from pocket_tts import TTSModel
-
-model = TTSModel.load_model()
-
-voice_state = model.get_state_for_audio_prompt("hf://kyutai/tts-voices/alba-mackenna/casual.wav")
-# Stream generation
-for chunk in model.generate_audio_stream(voice_state, "Long text content..."):
-    # Process each chunk as it's generated
-    print(f"Generated chunk: {chunk.shape[0]} samples")
-    # Could save chunks to file or play in real-time
-```
-
-## Advanced Usage
-
-### Voice Management
-
-```python
-from pocket_tts import TTSModel
-
-model = TTSModel.load_model()
-# Preload multiple voices
-voices = {
-    "casual": model.get_state_for_audio_prompt("hf://kyutai/tts-voices/alba-mackenna/casual.wav"),
-    "funny": model.get_state_for_audio_prompt(
-        "https://huggingface.co/kyutai/tts-voices/resolve/main/expresso/ex01-ex02_default_001_channel1_168s.wav"
-    ),
-}
-
-# Generate with different voices
-casual_audio = model.generate_audio(voices["casual"], "Hey there!")
-funny_audio = model.generate_audio(voices["funny"], "Good morning.")
-```
-
-### Batch Processing
-
-```python
-from pocket_tts import TTSModel
-import scipy.io.wavfile
-import torch
-
-model = TTSModel.load_model()
-
-voice_state = model.get_state_for_audio_prompt("hf://kyutai/tts-voices/alba-mackenna/casual.wav")
-# Process multiple texts efficiently by re-using the same voice state
-texts = [
-    "First sentence to generate.",
-    "Second sentence to generate.",
-    "Third sentence to generate.",
-]
-
-audios = []
-for text in texts:
-    audio = model.generate_audio(voice_state, text)
-    audios.append(audio)
-
-# Concatenate all audio
-full_audio = torch.cat(audios, dim=0)
-scipy.io.wavfile.write("batch_output.wav", model.sample_rate, full_audio.numpy())
-```
-
-### Streaming to File
-You can refer to our CLI implementation which can stream audio to a wav file.
-
-For more information about the command-line interface, see the [Generate Documentation](generate.md) or [Serve Documentation](serve.md).

project specifications.txt

@@ -1,62 +0,0 @@
-Project Specification: Universal TTS API Wrapper
-1. Project Objective
-Develop a production-ready Flask wrapper for pocket-tts that supports synthesis, voice cloning, and streaming audio, compatible with standard industry API TTS schemas (OpenAI) and includes a simple but elegant preview website that runs on the same host/post as the TTS server endpoint .
-
-2. Phase 1: Infrastructure & Configuration
-Implement a robust CLI-driven configuration layer to handle model loading and hardware orchestration.
-
-CLI Argument Parser: Support arguments for --model_path, --host (host to run server on), --port (post to run server on), and --stresm (if added, use streaming TTS)
-
-3. Phase 2: Core Synthesis Logic
-Develop necessary functions to bridge the API and the model to allow for streaming and non-streaming voice TTS generation.
-
-Text Pre-processing: Integrate a text cleaner/tokenizer to handle language-specific normalization.
-
-Audio Post-processing:
-
-Function to convert raw model output (tensors) into a BytesIO buffer.
-
-Use torchaudio to convert raw audio into various formats: mp3, wav, opus, aac, and flac.
-
-Voice Cloning/Conditioning: Support accepting a path to a reference audio file for zero-shot cloning.  If supported by model, cache latents to avoid having to reprocess wav files for cloning each generarion.
-
-4. Phase 3: API Surface Implementation
-Expose the model to the user in two ways:
-
-A. Simple web page at root of host/port used for server
-Use pocket-tts-logo.png and develop a simple localhost html and or css web page that is run automatically when running the server and allows the user to test and play output from the built in voices or select a wav file from their file system to clone and provides from default text prompts as well as a free text input field the user can utilize to test the model, and download output wavs through a file selection dislog to a location of their choice.
-
-B. OpenAI Compatibility Layer endpoint (/v1/audio/speech)
-Endpoint: Follow OpenAI’s JSON payload schema: { "model": "...", "input": "...", "voice": "...", "response_format": "mp3", "speed": 1.0 }.
-The response format should support the formats noted above
-Speed should be passed to the model if supported by pocket-tts to control how fast the TTS plays
-The "voice" parameter should accept one of the model's built in voice names or the absolute path to a .wav file specified by the user
-Model should always be defaulted to "pocket-tts" if not specified and should have no i,pact on the actual voice generation as this server is only for use with the pocket-tts model
-Logic: Map "voice" strings to internal speaker IDs (for voices supported natively by the model) or paths to cloning .wav files.
-Non-streaming response: If not using streaming via command line argument when running server, generate a non-streaming file response  supporting all the audio formats specified above
-Streaming: Implement steaming audio response option at user's discretion using Response(generate_chunks(), mimetype=...).
-
-Voices endooint: also include a voices endpoint that will return built in voices and the wav files in a directory for cloning wav files specified by the user as a command line argument when running the server:
-Voices endpoint sample to adapt:
-
-@app.route("/v1/voices", methods=["GET"])
-def openai_list_voices():
-    """JSON list of available built-in voice names.
-    Not an official OpenAI endpoint; provided for convenience for clients.
-    """
-    voices = _get_builtin_voice_names()
-    return jsonify(
-        {
-            "object": "list",
-            "data": [{"id": v, "object": "voice"} for v in voices],
-        }
-    )
-
-5. Phase 4: Error Handling: Implement try-except blocks around relevant logic to return 500-level JSON errors instead of crashing the Flask thread.
-
-6. Technical Requirements
-Language: Python 3.11
-
-Framework: Flask
-
-Core Libraries: torch, torchaudio, numpy, whatever else needed

test_server.py

@@ -1,79 +0,0 @@
-import subprocess
-import time
-import requests
-import sys
-import os
-
-def test_server():
-    print("Starting server for testing...")
-    # Start server as a subprocess
-    process = subprocess.Popen(
-        [sys.executable, "pocket_tts_openai_server.py", "--port", "5001"],
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        text=True
-    )
-    
-    try:
-        # Wait for valid startup
-        print("Waiting for server to start...")
-        time.sleep(15) # Give it time to load model
-        
-        base_url = "http://localhost:5001"
-        
-        # 1. Test Home
-        try:
-            r = requests.get(base_url + "/")
-            print(f"GET /: {r.status_code}")
-            if r.status_code == 200 and "Pocket TTS" in r.text:
-                print("SUCCESS: Home page loaded.")
-            else:
-                print("FAILURE: Home page check failed.")
-        except Exception as e:
-            print(f"FAILURE: Could not connect to home page: {e}")
-
-        # 2. Test Voices List
-        try:
-            r = requests.get(base_url + "/v1/voices")
-            print(f"GET /v1/voices: {r.status_code}")
-            if r.status_code == 200:
-                data = r.json()
-                if data.get("object") == "list" and len(data.get("data", [])) > 0:
-                    print(f"SUCCESS: Voices list returned {len(data['data'])} voices.")
-                else:
-                    print("FAILURE: Voices list format incorrect.")
-            else:
-                print("FAILURE: Voices endpoint returned error.")
-        except Exception as e:
-            print(f"FAILURE: Voices test failed: {e}")
-
-        # 3. Test Generation (Mock or Real)
-        payload = {
-            "model": "pocket-tts",
-            "input": "Hi",
-            "voice": "hf://kyutai/tts-voices/alba-mackenna/casual.wav", 
-            "response_format": "wav"
-        }
-        try:
-            t0 = time.time()
-            r = requests.post(base_url + "/v1/audio/speech", json=payload, timeout=60)
-            print(f"POST /v1/audio/speech: {r.status_code} (took {time.time()-t0:.2f}s)")
-            if r.status_code == 200:
-                print(f"SUCCESS: Audio generated ({len(r.content)} bytes).")
-            else:
-                print(f"FAILURE: Generation failed: {r.text}")
-        except Exception as e:
-            print(f"FAILURE: Generation test failed: {e}")
-
-    finally:
-        print("Terminating server...")
-        process.terminate()
-        try:
-            outs, errs = process.communicate(timeout=5)
-            # print("Server Output:", outs)
-            # print("Server Errors:", errs)
-        except:
-            process.kill()
-
-if __name__ == "__main__":
-    test_server()