Initial commit

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,181 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+model/
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/latest/usage/project/#working-with-version-control
+.pdm.toml
+.pdm-python
+.pdm-build/
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor  
+#  Cursor is an AI-powered code editor.`.cursorignore` specifies files/directories to 
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore

LICENSE

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

README.md

@@ -0,0 +1,2 @@
+# pocket-tts-openai_streaming_server
+OpenAI-compatible TTS Server for PocketTTS

pocket-tts-generate-docs.md

@@ -0,0 +1,83 @@
+# 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

@@ -0,0 +1,223 @@
+# 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).

pocket_tts_openai_server.py

@@ -0,0 +1,250 @@
+import os
+import argparse
+import sys
+import logging
+import io
+import time
+import json
+import glob
+from pathlib import Path
+from flask import Flask, request, jsonify, send_file, render_template, Response, stream_with_context
+import torch
+import torchaudio
+
+# Import pocket-tts
+try:
+    from pocket_tts import TTSModel
+except ImportError:
+    print("Error: pocket-tts not found. Please install it using 'pip install pocket-tts'.")
+    sys.exit(1)
+
+from utils import validate_format, convert_audio, write_wav_header
+
+# Configure Logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger("PocketTTS-Server")
+
+app = Flask(__name__)
+
+# Global Variables
+model = None
+voice_cache = {} # Cache for voice states
+VOICES_DIR = None
+
+# --- Helpers ---
+
+def get_voice_state(voice_id_or_path):
+    """
+    Resolve voice ID to a model state with caching.
+    """
+    global voice_cache
+    
+    # Check cache first
+    if voice_id_or_path in voice_cache:
+        # logger.info(f"Using cached voice state for {voice_id_or_path}")
+        return voice_cache[voice_id_or_path]
+    
+    # If path is relative to VOICES_DIR and exists there, resolve it
+    if VOICES_DIR:
+        possible_path = os.path.join(VOICES_DIR, voice_id_or_path)
+        if os.path.exists(possible_path):
+            voice_id_or_path = possible_path
+
+    # Check existence if local path
+    if os.path.exists(voice_id_or_path):
+        # It's a local file
+        logger.info(f"Loading new voice state from file: {voice_id_or_path}")
+        state = model.get_state_for_audio_prompt(voice_id_or_path)
+        voice_cache[voice_id_or_path] = state
+        return state
+    
+    # URL or ID
+    try:
+        logger.info(f"Loading new voice state from ID/URL: {voice_id_or_path}")
+        state = model.get_state_for_audio_prompt(voice_id_or_path)
+        voice_cache[voice_id_or_path] = state
+        return state
+    except Exception as e:
+        logger.error(f"Failed to load voice {voice_id_or_path}: {e}")
+        raise ValueError(f"Voice '{voice_id_or_path}' could not be loaded.")
+
+# --- Routes ---
+
+@app.route('/')
+def home():
+    """Serve the simple web interface."""
+    return render_template('index.html')
+
+@app.route('/v1/voices', methods=['GET'])
+def list_voices():
+    """List available voices: Built-ins + Scanned Directory."""
+    
+    # 1. Built-in defaults
+    # User requested specific voices: alba, marius, javert, jean, fantine, cosette, eponine, azelma
+    # We map them to potential IDs. Since we don't have exact URLs for all, we assume they are either
+    # resolved by pocket-tts or the user has these files/IDs.
+    
+    builtin_map = {
+       "alba": "alba",
+       "marius": "marius", 
+       "javert": "javert",
+       "jean": "jean",
+       "fantine": "fantine",
+       "cosette": "cosette",
+       "eponine": "eponine",
+       "azelma": "azelma"
+    }
+
+    voices = []
+    for name_id in ["alba", "marius", "javert", "jean", "fantine", "cosette", "eponine", "azelma"]:
+        # If we have a known mapping (like for alba), use it as ID? 
+        # Or just use the name as ID and let get_voice_state handle it?
+        # Specifying ID as the lookup key.
+        voices.append({
+            "id": builtin_map.get(name_id, name_id),
+            "name": name_id.capitalize()
+        })
+    
+    # 2. Scan Directory if configured
+    if VOICES_DIR and os.path.isdir(VOICES_DIR):
+        # Scan for .wav files
+        wav_files = glob.glob(os.path.join(VOICES_DIR, "*.wav"))
+        for f in wav_files:
+            name = os.path.basename(f)
+            # ID is the full path so the server can access it, or just filename if we handle resolution
+            # Let's use full absolute path for robustness or relative if clean.
+            # Using filename is nicer for UI, but 'voice' parameter needs to be resolvable.
+            # get_voice_state logic handles checking VOICES_DIR.
+            voices.append({
+                "id": name, # client sends this, get_voice_state resolves via VOICES_DIR
+                "name": f"Local: {name}"
+            })
+
+    return jsonify({
+        "object": "list",
+        "data": [{"id": v["id"], "name": v["name"], "object": "voice"} for v in voices]
+    })
+
+@app.route('/v1/audio/speech', methods=['POST'])
+def generate_speech():
+    """OpenAI-compatible speech generation endpoint."""
+    data = request.json
+    
+    if not data:
+        return jsonify({"error": "Missing JSON body"}), 400
+        
+    text = data.get('input')
+    voice = data.get('voice', 'hf://kyutai/tts-voices/alba-mackenna/casual.wav')
+    response_format = data.get('response_format', 'wav')
+    
+    # Check stream flag
+    stream_request = data.get('stream', False)
+
+    if not text:
+        return jsonify({"error": "Missing 'input' text"}), 400
+
+    target_format = validate_format(response_format)
+    
+    try:
+        # Load Voice (with cache)
+        voice_state = get_voice_state(voice)
+        
+        # Determine Generation Mode
+        if stream_request or app.config.get('CLI_STREAM_DEFAULT'):
+            return stream_audio(voice_state, text, target_format)
+        else:
+            return generate_file(voice_state, text, target_format)
+            
+    except Exception as e:
+        logger.exception("Generation failed")
+        return jsonify({"error": str(e)}), 500
+
+def generate_file(voice_state, text, fmt):
+    """Generate full audio and return as file."""
+    t0 = time.time()
+    audio_tensor = model.generate_audio(voice_state, text)
+    generation_time = time.time() - t0
+    logger.info(f"Generated {len(text)} chars in {generation_time:.2f}s")
+    
+    # Convert
+    audio_buffer = convert_audio(audio_tensor, model.sample_rate, fmt)
+    
+    mimetype = f"audio/{fmt}"
+    if fmt == 'wav': mimetype = 'audio/wav'
+    elif fmt == 'mp3': mimetype = 'audio/mpeg'
+    
+    return send_file(
+        audio_buffer,
+        mimetype=mimetype,
+        as_attachment=True,
+        download_name=f"speech.{fmt}"
+    )
+
+def stream_audio(voice_state, text, fmt):
+    """Stream audio chunks."""
+    
+    def generate():
+        stream = model.generate_audio_stream(voice_state, text)
+        
+        for chunk_tensor in stream:
+            # Convert to int16 PCM bytes
+            # Ensure CPU/correct shape
+            if chunk_tensor.is_cuda: chunk_tensor = chunk_tensor.cpu()
+            if chunk_tensor.dim() == 1: chunk_tensor = chunk_tensor.unsqueeze(0)
+            
+            # Simple PCM conversion
+            c = (chunk_tensor * 32767).clamp(-32768, 32767).to(torch.int16)
+            data_bytes = c.numpy().tobytes()
+            yield data_bytes
+
+    def stream_with_header():
+        # Valid WAV Header for streaming
+        if fmt == 'wav':
+             # We assume standard 24kHz mono based on model
+             # If model rate varies, we should use model.sample_rate
+             yield write_wav_header(model.sample_rate, num_channels=1, bits_per_sample=16, num_frames=0)
+             
+        yield from generate()
+
+    mimetype = f"audio/{fmt}"
+    if fmt == 'wav': mimetype = 'audio/wav'
+    
+    return Response(stream_with_context(stream_with_header()), mimetype=mimetype)
+
+
+# --- startup ---
+def main():
+    parser = argparse.ArgumentParser(description="Pocket TTS OpenAI Compatible Server")
+    parser.add_argument("--model_path", type=str, default=None, help="Path to model file or variant name")
+    parser.add_argument("--host", type=str, default="0.0.0.0", help="Host to run server")
+    parser.add_argument("--port", type=int, default=5002, help="Port to run server")
+    parser.add_argument("--stream", action="store_true", help="Enable streaming by default")
+    parser.add_argument("--voices_dir", type=str, default=None, help="Directory containing local voice .wav files")
+    
+    args = parser.parse_args()
+    
+    # Config
+    app.config['CLI_STREAM_DEFAULT'] = args.stream
+    global VOICES_DIR
+    VOICES_DIR = args.voices_dir
+    
+    global model
+    logger.info("Loading Pocket TTS Model...")
+    
+    # Use model_path as variant if provided, otherwise default
+    if args.model_path:
+        logger.info(f"Using custom model variant/path: {args.model_path}")
+        model = TTSModel.load_model(variant=args.model_path)
+    else:
+        model = TTSModel.load_model()
+        
+    logger.info(f"Model loaded. Device: {model.device}, Sample Rate: {model.sample_rate}")
+    
+    if VOICES_DIR:
+        logger.info(f"Scanning voices from: {VOICES_DIR}")
+        
+    logger.info(f"Starting server on {args.host}:{args.port}")
+    app.run(host=args.host, port=args.port, debug=False, threaded=True)
+
+if __name__ == "__main__":
+    main()

project specifications.txt

@@ -0,0 +1,62 @@
+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

requirements.txt

@@ -0,0 +1,6 @@
+flask
+torch
+torchaudio
+pocket-tts
+scipy
+numpy

run_pocket_tts_server.bat

@@ -0,0 +1,84 @@
+@echo off
+setlocal EnableDelayedExpansion
+
+title Pocket TTS Server Launcher
+
+echo.
+echo ========================================================
+echo        Pocket TTS OpenAI Streaming Server Launcher
+echo ========================================================
+echo.
+:: 0. Hugging Face Authentication
+set "HF_TOKEN=your_token_here_if_you_want_to_hardcode_it"
+if "%HF_TOKEN%"=="your_token_here_if_you_want_to_hardcode_it" (
+    set /p "HF_TOKEN=Enter Hugging Face Token (leave blank if already logged in): "
+)
+
+if not "%HF_TOKEN%"=="" (
+    echo [INFO] Setting Hugging Face Token...
+    set "HF_TOKEN=%HF_TOKEN%"
+)
+
+:: 1. Activate Virtual Environment
+if exist "venv\Scripts\activate.bat" (
+    echo [INFO] Activating virtual environment...
+    call venv\Scripts\activate.bat
+) else (
+    echo [WARNING] venv not found at .\venv. Attempting to run with system python...
+)
+
+echo.
+echo Please configure the server (Press ENTER to use defaults):
+echo.
+
+:: 2. Host
+set "HOST=0.0.0.0"
+set /p "INPUT_HOST=Host IP [%HOST%]: "
+if not "%INPUT_HOST%"=="" set "HOST=%INPUT_HOST%"
+
+:: 3. Port
+set "PORT=5002"
+set /p "INPUT_PORT=Port [%PORT%]: "
+if not "%INPUT_PORT%"=="" set "PORT=%INPUT_PORT%"
+
+:: 4. Model Path
+set "MODEL_PATH="
+set /p "INPUT_MODEL=Model Path/Variant (Optional, default=built-in): "
+if not "%INPUT_MODEL%"=="" set "MODEL_PATH=--model_path ^"%INPUT_MODEL%^""
+
+:: 5. Voices Directory
+set "DEFAULT_VOICES=%~dp0voices"
+set /p "INPUT_VOICES=Voices Directory [%DEFAULT_VOICES%]: "
+
+if "%INPUT_VOICES%"=="" (
+    :: If user hits ENTER, use the local folder path
+    set "VOICES_DIR=--voices_dir ^"!DEFAULT_VOICES!^""
+) else (
+    :: If user types a path, use that instead
+    set "VOICES_DIR=--voices_dir ^"%INPUT_VOICES%^""
+)
+
+:: 6. Streaming Default
+set "STREAM_ARG="
+set /p "INPUT_STREAM=Enable Streaming by default? (Y/N) [N]: "
+if /i "%INPUT_STREAM%"=="Y" set "STREAM_ARG=--stream"
+
+echo.
+echo ========================================================
+echo Starting Pocket TTS Server...
+echo Host: %HOST%
+echo Port: %PORT%
+if defined MODEL_PATH echo Model: %MODEL_PATH%
+if defined VOICES_DIR echo Voices: %VOICES_DIR%
+if defined STREAM_ARG echo Streaming: Enabled
+echo ========================================================
+echo.
+
+:: 7. Run Command
+python pocket_tts_openai_server.py --host %HOST% --port %PORT% %MODEL_PATH% %VOICES_DIR% %STREAM_ARG%
+
+if %ERRORLEVEL% NEQ 0 (
+    echo.
+    echo [ERROR] Server exited with error code %ERRORLEVEL%.
+    pause
+)

static/css/style.css

@@ -0,0 +1,221 @@
+:root {
+  --bg-color: #0d1117;
+  --card-bg: #161b22;
+  --accent-color: #58a6ff;
+  --accent-hover: #1f6feb;
+  --text-primary: #c9d1d9;
+  --text-secondary: #8b949e;
+  --border-color: #30363d;
+  --input-bg: #0d1117;
+  --font-family: 'Inter', -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+  --glass-bg: rgba(22, 27, 34, 0.7);
+  --glass-border: rgba(48, 54, 61, 0.5);
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+body {
+  font-family: var(--font-family);
+  background-color: var(--bg-color);
+  color: var(--text-primary);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  min-height: 100vh;
+  background-image: radial-gradient(circle at 50% 0%, #1f2530 0%, #0d1117 100%);
+}
+
+.container {
+  width: 100%;
+  max-width: 800px;
+  padding: 2rem;
+  background: var(--glass-bg);
+  backdrop-filter: blur(12px);
+  border: 1px solid var(--glass-border);
+  border-radius: 16px;
+  box-shadow: 0 8px 32px rgba(0, 0, 0, 0.4);
+  animation: fadeIn 0.5s ease-out;
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; transform: translateY(20px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+header {
+  text-align: center;
+  margin-bottom: 2rem;
+}
+
+.logo {
+  max-width: 120px;
+  margin-bottom: 1rem;
+  filter: drop-shadow(0 0 10px rgba(88, 166, 255, 0.3));
+}
+
+h1 {
+  font-size: 2rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin-bottom: 0.5rem;
+  background: linear-gradient(90deg, #58a6ff, #a371f7);
+  -webkit-background-clip: text;
+  -webkit-text-fill-color: transparent;
+}
+
+.subtitle {
+  color: var(--text-secondary);
+  font-size: 0.95rem;
+}
+
+.control-group {
+  margin-bottom: 1.5rem;
+}
+
+label {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 500;
+  color: var(--text-secondary);
+  font-size: 0.9rem;
+}
+
+input[type="text"],
+textarea,
+select {
+  width: 100%;
+  padding: 0.75rem 1rem;
+  background-color: var(--input-bg);
+  border: 1px solid var(--border-color);
+  border-radius: 8px;
+  color: var(--text-primary);
+  font-family: inherit;
+  font-size: 1rem;
+  transition: border-color 0.2s, box-shadow 0.2s;
+}
+
+input[type="file"] {
+  width: 100%;
+  padding: 0.5rem;
+  background-color: var(--input-bg);
+  border: 1px dashed var(--border-color);
+  border-radius: 8px;
+  color: var(--text-secondary);
+  cursor: pointer;
+}
+
+input:focus,
+textarea:focus,
+select:focus {
+  outline: none;
+  border-color: var(--accent-color);
+  box-shadow: 0 0 0 3px rgba(88, 166, 255, 0.1);
+}
+
+textarea {
+  min-height: 120px;
+  resize: vertical;
+}
+
+.btn-primary {
+  display: block;
+  width: 100%;
+  padding: 1rem;
+  border: none;
+  border-radius: 8px;
+  background: linear-gradient(135deg, var(--accent-color), var(--accent-hover));
+  color: white;
+  font-weight: 600;
+  font-size: 1.1rem;
+  cursor: pointer;
+  transition: transform 0.1s, opacity 0.2s;
+  box-shadow: 0 4px 12px rgba(31, 111, 235, 0.3);
+}
+
+.btn-primary:hover {
+  opacity: 0.9;
+}
+
+.btn-primary:active {
+  transform: scale(0.98);
+}
+
+.btn-primary:disabled {
+  background: var(--border-color);
+  cursor: not-allowed;
+  opacity: 0.7;
+  box-shadow: none;
+}
+
+.output-section {
+  margin-top: 2rem;
+  padding-top: 2rem;
+  border-top: 1px solid var(--border-color);
+  text-align: center;
+  display: none; /* Hidden by default */
+}
+
+.output-section.active {
+  display: block;
+  animation: slideDown 0.3s ease-out;
+}
+
+@keyframes slideDown {
+  from { opacity: 0; transform: translateY(-10px); }
+  to { opacity: 1; transform: translateY(0); }
+}
+
+audio {
+  width: 100%;
+  margin-bottom: 1rem;
+  border-radius: 8px;
+}
+
+.download-link {
+  display: inline-block;
+  padding: 0.5rem 1rem;
+  color: var(--accent-color);
+  text-decoration: none;
+  border: 1px solid var(--accent-color);
+  border-radius: 6px;
+  font-size: 0.9rem;
+  transition: all 0.2s;
+}
+
+.download-link:hover {
+  background: rgba(88, 166, 255, 0.1);
+}
+
+/* Spinner */
+.spinner {
+  display: inline-block;
+  width: 1.5rem;
+  height: 1.5rem;
+  border: 3px solid rgba(255,255,255,0.3);
+  border-radius: 50%;
+  border-top-color: #fff;
+  animation: spin 1s ease-in-out infinite;
+  margin-left: 0.5rem;
+  vertical-align: middle;
+  display: none;
+}
+
+.btn-primary.loading .spinner {
+  display: inline-block;
+}
+
+.btn-primary.loading span {
+  display: none;
+}
+
+@keyframes spin {
+  to { transform: rotate(360deg); }
+}
+
+.hidden {
+    display: none;
+}

static/js/app.js

@@ -0,0 +1,106 @@
+document.addEventListener('DOMContentLoaded', async () => {
+    const voiceSelect = document.getElementById('voice-select');
+    const customVoiceGroup = document.getElementById('custom-voice-group');
+    const generateBtn = document.getElementById('generate-btn');
+    const textInput = document.getElementById('text-input');
+    const voiceFile = document.getElementById('voice-file');
+    const outputSection = document.getElementById('output-section');
+    const audioPlayer = document.getElementById('audio-player');
+    const downloadBtn = document.getElementById('download-btn');
+    const streamToggle = document.getElementById('stream-toggle');
+
+    // 1. Load Voices
+    async function loadVoices() {
+        try {
+            const res = await fetch('/v1/voices');
+            const data = await res.json();
+
+            // Clear existing except custom
+            voiceSelect.innerHTML = '<option value="custom">Custom (Upload .wav)...</option>';
+
+            if (data.data) {
+                // Add built-ins first
+                data.data.forEach(voice => {
+                    const opt = document.createElement('option');
+                    opt.value = voice.id;
+                    opt.textContent = voice.name || voice.id;
+                    voiceSelect.insertBefore(opt, voiceSelect.firstChild); // Prepend
+                });
+
+                // Select first by default
+                if (voiceSelect.options.length > 0) {
+                    voiceSelect.selectedIndex = 0;
+                }
+            }
+        } catch (e) {
+            console.error("Failed to list voices:", e);
+        }
+    }
+
+    await loadVoices();
+
+    // 2. Handle Voice Selection Change
+    voiceSelect.addEventListener('change', (e) => {
+        if (e.target.value === 'custom') {
+            // Setup for Custom Path
+            document.querySelector('#custom-voice-group label').textContent = "Absolute Path to WAV File:";
+            voiceFile.type = 'text';
+            voiceFile.placeholder = "C:\\path\\to\\voice.wav";
+            customVoiceGroup.classList.remove('hidden');
+        } else {
+            customVoiceGroup.classList.add('hidden');
+        }
+    });
+
+    // 3. Generate Logic
+    generateBtn.addEventListener('click', async () => {
+        const text = textInput.value.trim();
+        if (!text) return alert("Please enter text");
+
+        const stream = streamToggle.checked;
+
+        let voice = voiceSelect.value;
+        if (voice === 'custom') {
+            voice = voiceFile.value.trim();
+            if (!voice) return alert("Please enter the path to the wave file.");
+        }
+
+        generateBtn.classList.add('loading');
+        generateBtn.disabled = true;
+        outputSection.classList.remove('active');
+
+        try {
+            const response = await fetch('/v1/audio/speech', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    model: 'pocket-tts',
+                    input: text,
+                    voice: voice,
+                    response_format: 'wav',
+                    stream: stream
+                })
+            });
+
+            if (!response.ok) {
+                const err = await response.json();
+                throw new Error(err.error || response.statusText);
+            }
+
+            const blob = await response.blob();
+            const url = URL.createObjectURL(blob);
+            audioPlayer.src = url;
+            downloadBtn.href = url;
+            downloadBtn.download = "generated_speech.wav";
+
+            audioPlayer.play();
+            outputSection.classList.add('active');
+
+        } catch (e) {
+            alert("Error generating speech: " + e.message);
+        } finally {
+            generateBtn.classList.remove('loading');
+            generateBtn.disabled = false;
+        }
+    });
+});

templates/index.html

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Pocket TTS - Local Streaming</title>
+    <link rel="stylesheet" href="/static/css/style.css">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap" rel="stylesheet">
+</head>
+<body>
+
+<div class="container">
+    <header>
+        <img src="/static/images/pocket-tts-logo.png" alt="Pocket TTS Logo" class="logo">
+        <h1>Pocket TTS</h1>
+        <p class="subtitle">Real-time local speech synthesis & voice cloning</p>
+    </header>
+
+    <div class="content">
+        <div class="control-group">
+            <label for="text-input">Text Prompt</label>
+            <textarea id="text-input" placeholder="Enter text to generate speech...">Hello! I am Pocket TTS, running locally on your machine. I can clone voices and stream audio in real-time.</textarea>
+        </div>
+
+        <div class="control-group">
+            <label for="voice-select">Voice Selection</label>
+            <select id="voice-select">
+                <!-- Populated by JS -->
+                <option value="custom">Custom (Upload .wav)...</option>
+            </select>
+        </div>
+
+        <div class="control-group hidden" id="custom-voice-group">
+             <label for="voice-file">Upload Reference Audio (WAV)</label>
+             <input type="file" id="voice-file" accept=".wav">
+        </div>
+
+        <div class="control-group">
+             <label for="stream-toggle" style="display:inline-flex; align-items:center; cursor:pointer;">
+                 <input type="checkbox" id="stream-toggle" style="width:auto; margin-right:8px;"> Enable Streaming Response
+             </label>
+        </div>
+
+        <button id="generate-btn" class="btn-primary">
+            <span>Generate Speech</span>
+            <div class="spinner"></div>
+        </button>
+
+        <div class="output-section" id="output-section">
+            <audio id="audio-player" controls></audio>
+            <br>
+            <a href="#" id="download-btn" class="download-link">Download Audio</a>
+        </div>
+    </div>
+</div>
+
+<script src="/static/js/app.js"></script>
+</body>
+</html>

test_server.py

@@ -0,0 +1,79 @@
+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()

utils.py

@@ -0,0 +1,88 @@
+import io
+import torch
+import torchaudio
+import logging
+
+logger = logging.getLogger(__name__)
+
+def convert_audio(audio_tensor: torch.Tensor, sample_rate: int, target_format: str = 'wav') -> io.BytesIO:
+    """
+    Convert a raw audio tensor to a byte buffer in the specified format.
+    
+    Args:
+        audio_tensor (torch.Tensor): The audio waveform (1D or 2D).
+        sample_rate (int): The sample rate of the audio.
+        target_format (str): The target audio format (mp3, wav, opus, aac, flac).
+        
+    Returns:
+        io.BytesIO: Buffer containing the encoded audio data.
+    """
+    buffer = io.BytesIO()
+    
+    # Ensure tensor is CPU
+    if audio_tensor.is_cuda:
+        audio_tensor = audio_tensor.cpu()
+        
+    # Ensure 2D (channels, time)
+    if audio_tensor.dim() == 1:
+        audio_tensor = audio_tensor.unsqueeze(0)
+        
+    # Validation/Normalization if needed
+    # torchaudio.save expects data in range [-1, 1] usually, confirm if normalization needed?
+    # PocketTTS output range is typically fine, but clipping is good practice.
+    # audio_tensor = torch.clamp(audio_tensor, -1.0, 1.0)
+
+    try:
+        torchaudio.save(buffer, audio_tensor, sample_rate, format=target_format)
+        buffer.seek(0)
+        return buffer
+    except Exception as e:
+        logger.error(f"Error converting audio to {target_format}: {e}")
+        # Fallback to wav if conversion fails? Or re-raise?
+        # For now, let's try to handle common issues or re-raise
+        raise e
+
+def validate_format(fmt: str) -> str:
+    """Normalize and validate the requested audio format."""
+    fmt = fmt.lower()
+    valid_formats = {'mp3', 'wav', 'opus', 'aac', 'flac'}
+    
+    if fmt == 'mpeg': # OpenAI sometimes sends 'mpeg' aka mp3
+        return 'mp3'
+        
+    if fmt not in valid_formats:
+        return 'wav' # Default fallback
+    return fmt
+
+def write_wav_header(sample_rate: int, num_channels: int = 1, bits_per_sample: int = 16, num_frames: int = 0) -> bytes:
+    """
+    Generate a WAV header. If num_frames is 0, set to 0xFFFFFFFF (unknown/large).
+    """
+    import struct
+    
+    byte_rate = sample_rate * num_channels * bits_per_sample // 8
+    block_align = num_channels * bits_per_sample // 8
+    
+    # Data size: if unknown, max uint32 approximately
+    data_size = num_frames * block_align
+    if num_frames == 0:
+        data_size = 0xFFFFFFFF - 36 # Max possible size remaining
+        
+    chunk_size = 36 + data_size
+    
+    header = io.BytesIO()
+    header.write(b'RIFF')
+    header.write(struct.pack('<I', chunk_size))
+    header.write(b'WAVE')
+    header.write(b'fmt ')
+    header.write(struct.pack('<I', 16)) # Subchunk1Size (16 for PCM)
+    header.write(struct.pack('<H', 1))  # AudioFormat (1 for PCM)
+    header.write(struct.pack('<H', num_channels))
+    header.write(struct.pack('<I', sample_rate))
+    header.write(struct.pack('<I', byte_rate))
+    header.write(struct.pack('<H', block_align))
+    header.write(struct.pack('<H', bits_per_sample))
+    header.write(b'data')
+    header.write(struct.pack('<I', data_size))
+    
+    return header.getvalue()