flockspeech 0.1.0__py3-none-any.whl

flockspeech/__init__.py

@@ -0,0 +1,76 @@
+"""Flock Speech: tiny text-to-speech that runs on your own device.
+
+    from flockspeech import Junco
+    tts = Junco()
+    audio = tts("Hello there.")          # float32 numpy array, 24 kHz mono
+    tts.save("Hello there.", "hi.wav")
+    for chunk in tts.stream(long_text):  # one sentence at a time, for low latency
+        ...
+"""
+import time
+import wave
+
+import numpy as np
+
+from .engine import Engine, default_threads
+from .text import Phonemizer, split_sentences, to_ids
+
+__version__ = "0.1.0"
+__all__ = ["Junco", "write_wav", "__version__"]
+
+
+def write_wav(path, audio, sr=24000):
+    """16-bit PCM mono WAV, standard library only."""
+    pcm = (np.clip(audio, -1.0, 1.0) * 32767.0).astype("<i2")
+    with wave.open(str(path), "wb") as f:
+        f.setnchannels(1)
+        f.setsampwidth(2)
+        f.setframerate(sr)
+        f.writeframes(pcm.tobytes())
+
+
+class Junco:
+    """Junco v0.1: one English (US) voice, 24 kHz. Thread-safe for reading; create one per process and reuse it.
+
+    threads: CPU threads for ONNX Runtime (default: up to 4).
+    coreml:  run the vocoder with CoreML on Apple silicon (default off: faster on one thread, twice the memory).
+    model_dir: a folder with other exported graphs (default: the ones shipped in the package)."""
+
+    sample_rate = 24000
+
+    def __init__(self, threads=None, coreml=False, model_dir=None):
+        self.engine = Engine(model_dir, threads=threads, coreml=coreml)
+        self.version = self.engine.meta["version"]
+        self._ph = None
+
+    def _phonemes(self, sentences):
+        if self._ph is None:
+            self._ph = Phonemizer()
+        return self._ph(sentences)
+
+    def stream(self, text, speed=1.0, steps=None, seed=0, pause=0.25):
+        """Yield float32 audio sentence by sentence (a short pause after each but the last)."""
+        sents = split_sentences(text)
+        if not sents:
+            return
+        rng = np.random.default_rng(seed)
+        gap = np.zeros(int(pause * self.sample_rate), np.float32)
+        phs = self._phonemes(sents)
+        for k, ph in enumerate(phs):
+            ids = to_ids(ph)
+            if len(ids) < 3:
+                continue
+            mel, n = self.engine.mel(ids, steps=steps, speed=speed, rng=rng)
+            wav = self.engine.vocode(mel, n)
+            yield np.concatenate([wav, gap]) if k < len(phs) - 1 else wav
+
+    def __call__(self, text, speed=1.0, steps=None, seed=0, pause=0.25):
+        """Speak text; returns float32 audio at 24 kHz. speed>1 talks faster; steps (default 8) trades speed for
+        quality; seed fixes the random voice variation."""
+        parts = list(self.stream(text, speed=speed, steps=steps, seed=seed, pause=pause))
+        return np.concatenate(parts) if parts else np.zeros(0, np.float32)
+
+    def save(self, text, path, **kw):
+        audio = self(text, **kw)
+        write_wav(path, audio, self.sample_rate)
+        return audio

flockspeech/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

flockspeech/cli.py

@@ -0,0 +1,65 @@
+"""flockspeech "Hello there." -o hello.wav [--speed 1.0] [--steps 8] [--seed 0] [--threads N] [--play]
+Text can also come from a file (-f) or standard input (-)."""
+import argparse
+import os
+import platform
+import shutil
+import subprocess
+import sys
+import time
+
+
+def _play(path):
+    for cmd in (["afplay"], ["aplay", "-q"], ["paplay"], ["ffplay", "-nodisp", "-autoexit", "-loglevel", "quiet"]):
+        if shutil.which(cmd[0]):
+            subprocess.run(cmd + [path])
+            return
+    if platform.system() == "Windows":
+        import winsound
+        winsound.PlaySound(path, winsound.SND_FILENAME)
+        return
+    print("no audio player found; open", path, file=sys.stderr)
+
+
+def main(argv=None):
+    from . import Junco, __version__, write_wav
+
+    ap = argparse.ArgumentParser(prog="flockspeech", description="Tiny on-device text to speech (Junco voice).")
+    ap.add_argument("text", nargs="?", help='text to speak, or "-" to read standard input')
+    ap.add_argument("-f", "--file", help="read the text from a file")
+    ap.add_argument("-o", "--out", default="out.wav", help="output WAV (24 kHz, 16-bit); default out.wav")
+    ap.add_argument("--speed", type=float, default=1.0, help="1.2 talks 20%% faster")
+    ap.add_argument("--steps", type=int, default=None, help="flow steps (default 8; 4 is faster, a little rougher)")
+    ap.add_argument("--seed", type=int, default=0)
+    ap.add_argument("--threads", type=int, default=None, help="CPU threads (default: up to 4)")
+    ap.add_argument("--coreml", action="store_true", help="Apple silicon: run the vocoder with CoreML")
+    ap.add_argument("--play", action="store_true", help="play the result")
+    ap.add_argument("-q", "--quiet", action="store_true")
+    ap.add_argument("--version", action="version", version=f"flockspeech {__version__}")
+    a = ap.parse_args(argv)
+    if a.file:
+        with open(a.file, encoding="utf-8") as f:
+            text = f.read()
+    elif a.text == "-" or (a.text is None and not sys.stdin.isatty()):
+        text = sys.stdin.read()
+    else:
+        text = a.text
+    if not text or not text.strip():
+        ap.error('give some text, e.g. flockspeech "Hello there." --play')
+    t = time.perf_counter()
+    tts = Junco(threads=a.threads, coreml=a.coreml)
+    t_load = time.perf_counter() - t
+    t = time.perf_counter()
+    audio = tts(text, speed=a.speed, steps=a.steps, seed=a.seed)
+    t_gen = time.perf_counter() - t
+    write_wav(a.out, audio, tts.sample_rate)
+    if not a.quiet:
+        dur = len(audio) / tts.sample_rate
+        print(f"Junco {tts.version}: {dur:.1f} s of audio in {t_gen:.2f} s ({dur / max(t_gen, 1e-9):.1f}x real time, "
+              f"load {t_load:.2f} s) -> {os.path.abspath(a.out)}", file=sys.stderr)
+    if a.play:
+        _play(a.out)
+
+
+if __name__ == "__main__":
+    main()

flockspeech/engine.py

@@ -0,0 +1,120 @@
+"""ONNX Runtime engine for Junco: phoneme ids -> encoder -> durations -> guided flow steps -> Vocos -> 24 kHz audio.
+Needs only numpy and onnxruntime; no PyTorch.
+
+Shipped graphs (made by tools/export_onnx.py in the training repo):
+  encoder       ids (1, T) int64 -> mu (1, 100, T), logw (1, 1, T)          fp16 weights, fp32 compute
+  decoder-int8  x, cond (1, 100, F), mask (1, 1, F), t (1,), w (1,) -> v     int8 weights (dynamic quantisation)
+  vocoder       mel (1, 100, F) -> real, imag (1, 513, F); ISTFT in numpy     fp16 weights, fp32 compute
+"""
+import json
+import os
+
+import numpy as np
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+MODELS = os.path.join(HERE, "models")
+
+
+def default_threads():
+    return max(1, min(4, os.cpu_count() or 1))
+
+
+def _hann(n):
+    return (0.5 - 0.5 * np.cos(2 * np.pi * np.arange(n) / n)).astype(np.float32)  # periodic, as torch.hann_window
+
+
+_ENV = {}
+
+
+def istft(real, imag, n_fft=1024, hop=256):
+    """torch.istft(center=True, periodic Hann) for one (n_fft//2+1, F) spectrogram -> (F-1)*hop samples."""
+    frames = np.fft.irfft(real + 1j * imag, n_fft, axis=0).astype(np.float32)  # (n_fft, F)
+    win = _hann(n_fft)
+    F_ = frames.shape[1]
+    frames *= win[:, None]
+    r = n_fft // hop  # overlap factor: add r strided slabs instead of looping over frames
+    n = n_fft + hop * (F_ - 1)
+    y = np.zeros(n + n_fft, np.float32)
+    f = frames.T.reshape(F_, r, hop)
+    for j in range(r):
+        y[j * hop:j * hop + F_ * hop] += f[:, j].reshape(-1)
+    y = y[:n]
+    key = (n_fft, hop, F_)
+    env = _ENV.get(key)
+    if env is None:
+        w2 = np.tile((win * win).reshape(1, r, hop), (F_, 1, 1))
+        env = np.zeros(n + n_fft, np.float32)
+        for j in range(r):
+            env[j * hop:j * hop + F_ * hop] += w2[:, j].reshape(-1)
+        env = env[:n]
+        if len(_ENV) > 64:
+            _ENV.clear()
+        _ENV[key] = env
+    p = n_fft // 2
+    return y[p:n - p] / np.maximum(env[p:n - p], 1e-11)
+
+
+def _providers(kind, use_coreml):
+    """Optional CoreML for the vocoder on Apple silicon (same output; faster on one thread, but twice the memory).
+    The decoder always stays on the CPU: CoreML gives wrong values for it, and its int8 graph is CPU-only."""
+    if kind == "vocoder" and use_coreml:
+        import onnxruntime as ort
+        if "CoreMLExecutionProvider" in ort.get_available_providers():
+            return [("CoreMLExecutionProvider", {"ModelFormat": "MLProgram", "MLComputeUnits": "CPUOnly"}),
+                    "CPUExecutionProvider"]
+    return ["CPUExecutionProvider"]
+
+
+class Engine:
+    def __init__(self, model_dir=None, threads=None, coreml=None):
+        import onnxruntime as ort
+        d = model_dir or MODELS
+        with open(os.path.join(d, "junco.json")) as f:
+            self.meta = json.load(f)
+        self.sr, self.hop = self.meta["sample_rate"], self.meta["hop"]
+        self.mean = np.float32(self.meta["mean"])
+        self.std = np.float32(self.meta["std"])
+        coreml = bool(coreml)  # off by default: on an M1 it gains little and doubles memory
+        so = ort.SessionOptions()
+        so.intra_op_num_threads = threads or default_threads()
+        so.inter_op_num_threads = 1
+        so.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
+        so.log_severity_level = 3
+        files = self.meta.get("files", {"encoder": "encoder.onnx", "decoder": "decoder.onnx",
+                                        "vocoder": "vocoder.onnx"})
+        self.enc, self.dec, self.voc = (
+            ort.InferenceSession(os.path.join(d, files[k]), so, providers=_providers(k, coreml))
+            for k in ("encoder", "decoder", "vocoder"))
+
+    def mel(self, ids, steps=None, cfg=None, temp=None, sway=None, speed=1.0, rng=None):
+        """Phoneme ids -> (normalised mel (100, F) padded to a multiple of 4, n frames of speech)."""
+        dflt = self.meta["defaults"]
+        steps = dflt["n_steps"] if steps is None else int(steps)
+        cfg = dflt["cfg_w"] if cfg is None else cfg
+        temp = dflt["temp"] if temp is None else temp
+        sway = dflt["sway"] if sway is None else sway
+        rng = np.random.default_rng(0) if rng is None else rng
+        mu, logw = self.enc.run(None, {"ids": np.asarray(ids, np.int64)[None]})
+        w = np.ceil(np.exp(logw[0, 0]) / speed).astype(np.int64)
+        tot = int(w.sum())
+        n = max(tot, 4)
+        F_ = (n + 3) // 4 * 4  # the decoder halves the frame rate inside: keep the length a multiple of 4
+        cond = np.zeros((1, 100, F_), np.float32)
+        cond[0, :, :tot] = np.repeat(mu[0], w, axis=1)
+        mask = np.zeros((1, 1, F_), np.float32)
+        mask[..., :n] = 1.0
+        x = rng.standard_normal((1, 100, F_)).astype(np.float32) * np.float32(temp)
+        ts = np.linspace(0, 1, steps + 1).astype(np.float32)
+        if sway:
+            ts = (ts + sway * (np.cos(np.pi / 2 * ts) - 1 + ts)).astype(np.float32)
+        wv = np.array([cfg], np.float32)
+        for i in range(steps):
+            v = self.dec.run(None, {"x": x, "cond": cond, "mask": mask, "t": ts[i:i + 1], "w": wv})[0]
+            x = x + (ts[i + 1] - ts[i]) * v
+        return (x * mask)[0], n
+
+    def vocode(self, mel, n=None):
+        """Normalised mel (100, F) -> float32 audio, trimmed to n * hop samples (n: frames of speech)."""
+        n = mel.shape[1] if n is None else n
+        real, imag = self.voc.run(None, {"mel": (mel * self.std + self.mean)[None].astype(np.float32)})
+        return istft(real[0], imag[0], self.meta["n_fft"], self.hop)[:n * self.hop]

flockspeech/models/LICENSE-vocos

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

flockspeech/models/junco.json

@@ -0,0 +1,20 @@
+{
+ "name": "junco",
+ "version": "v0.1",
+ "sample_rate": 24000,
+ "hop": 256,
+ "n_fft": 1024,
+ "mean": -1.49140640330624,
+ "std": 2.024339073543612,
+ "defaults": {
+  "n_steps": 8,
+  "cfg_w": 1.0,
+  "temp": 0.667,
+  "sway": -1.0
+ },
+ "files": {
+  "encoder": "encoder.onnx",
+  "decoder": "decoder-int8.onnx",
+  "vocoder": "vocoder.onnx"
+ }
+}

flockspeech/text.py

@@ -0,0 +1,56 @@
+"""Text -> phoneme ids. Phonemes come from espeak-ng (the copy bundled by espeakng-loader) through phonemizer."""
+import re
+
+_pad = "_"
+_punct = ';:,.!?¡¿—…"«»“” '
+_letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+_ipa = "ɑɐɒæɓʙβɔɕçɗɖðʤəɘɚɛɜɝɞɟʄɡɠɢʛɦɧħɥʜɨɪʝɭɬɫɮʟɱɯɰŋɳɲɴøɵɸθœɶʘɹɺɾɻʀʁɽʂʃʈʧʉʊʋⱱʌɣɤʍχʎʏʑʐʒʔʡʕʢǀǁǂǃˈˌːˑʼʴʰʱʲʷˠˤ˞↓↑→↗↘'̩ᵻ"
+
+SYMBOLS = list(dict.fromkeys([_pad] + list(_punct) + list(_letters) + list(_ipa)))
+SYM2ID = {s: i for i, s in enumerate(SYMBOLS)}
+
+
+def to_ids(phonemes):
+    """Phoneme string -> ids with a blank (0) between every symbol, as the model was trained."""
+    ids = [SYM2ID[c] for c in phonemes if c in SYM2ID]
+    out = [0] * (2 * len(ids) + 1)
+    out[1::2] = ids
+    return out
+
+
+def split_sentences(text, max_chars=300):
+    """Sentences (on . ! ? ;), and over-long ones split again at commas so no chunk runs away."""
+    out = []
+    for s in re.split(r"(?<=[.!?;])\s+", text.strip()):
+        if not re.search(r"\w", s):
+            continue
+        while len(s) > max_chars:
+            cut = max((s.rfind(c, 0, max_chars) for c in ",:—"), default=-1)
+            if cut < max_chars // 3:
+                cut = s.rfind(" ", 0, max_chars)
+            if cut <= 0:
+                break
+            out.append(s[:cut + 1].strip())
+            s = s[cut + 1:].strip()
+        if s:
+            out.append(s)
+    return out
+
+
+class Phonemizer:
+    """espeak-ng en-us IPA with stress marks and punctuation kept. Created once: the backend costs ~200 ms."""
+
+    def __init__(self):
+        try:
+            import espeakng_loader
+            from phonemizer.backend.espeak.wrapper import EspeakWrapper
+            EspeakWrapper.set_library(espeakng_loader.get_library_path())
+            EspeakWrapper.set_data_path(espeakng_loader.get_data_path())
+        except ImportError:  # fall back to a system espeak-ng
+            pass
+        from phonemizer.backend import EspeakBackend
+        self.backend = EspeakBackend("en-us", preserve_punctuation=True, with_stress=True,
+                                     language_switch="remove-flags")
+
+    def __call__(self, sentences):
+        return self.backend.phonemize(list(sentences), strip=True, njobs=1)

flockspeech-0.1.0.dist-info/METADATA

@@ -0,0 +1,110 @@
+Metadata-Version: 2.5
+Name: flockspeech
+Version: 0.1.0
+Summary: Tiny on-device text to speech: the Junco voice, 44 MB, runs faster than real time on one CPU thread.
+Project-URL: Homepage, https://huggingface.co/flockspeech/junco
+Author: Flock Speech
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+License-File: src/flockspeech/models/LICENSE-vocos
+Keywords: edge,offline,on-device,onnx,speech-synthesis,text-to-speech,tts
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio :: Speech
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: espeakng-loader>=0.2.4
+Requires-Dist: numpy>=1.22
+Requires-Dist: onnxruntime>=1.17
+Requires-Dist: phonemizer>=3.2
+Description-Content-Type: text/markdown
+
+# flockspeech
+
+Tiny text to speech that runs on your own device. No GPU, no cloud and no PyTorch: just ONNX Runtime and numpy.
+
+This first release ships **Junco v0.1**, one English (US) voice at 24 kHz.
+
+```sh
+pip install flockspeech
+flockspeech "Hello! I'm Junco, and I run on your own computer." -o hello.wav --play
+```
+
+```python
+from flockspeech import Junco
+
+tts = Junco()                          # loads in under a second
+audio = tts("Hello there.")            # float32 numpy array, 24 kHz mono
+tts.save("Hello there.", "hello.wav")
+
+for chunk in tts.stream(long_text):    # sentence by sentence: the first audio arrives fast
+    play(chunk)
+```
+
+## Why it suits small devices
+
+| | |
+|---|---|
+| Model files | 44 MB, bundled in the package; nothing is downloaded at run time |
+| Runtime | onnxruntime + numpy; works offline |
+| Memory | about 265 MB peak |
+| Start-up | about 0.7 s |
+| Speed on an Apple M1 | 8.7× real time on 1 thread, 19× on 4 threads |
+| First audio when streaming | about 0.25 s on 4 threads |
+
+Speed was measured on typical one-sentence replies, vocoder included. Add `steps=4` (CLI `--steps 4`) for 1.5× more
+speed with slightly rougher audio.
+
+## Quality
+
+Quality was measured on 40 unseen LibriTTS-R sentences with UTMOS (a predictor of listener ratings from 1 to 5):
+
+| Version | UTMOS |
+|---|---|
+| Original model (PyTorch, fp32) | 4.21 |
+| **This package** (int8 decoder, fp16 storage) | **4.18** (difference not significant) |
+| This package with `steps=4` | 4.12 |
+
+In our wider benchmark of 150 sentences, Junco scored a word error rate of 1.71% with Whisper. Real recordings of the same
+sentences scored 2.30%.
+
+## Options
+
+| Option | CLI | Default | Effect |
+|---|---|---|---|
+| `speed` | `--speed` | 1.0 | 1.2 talks 20% faster |
+| `steps` | `--steps` | 8 | flow-matching steps: fewer is faster |
+| `seed` | `--seed` | 0 | fixes the small random variation in delivery |
+| `threads` | `--threads` | up to 4 | CPU threads for ONNX Runtime |
+| `coreml` | `--coreml` | off | Apple silicon only: runs the vocoder with CoreML. Faster on 1 thread, but uses twice the memory |
+
+The CLI also reads text from a file (`-f story.txt`) or from standard input (`echo hi | flockspeech -`).
+
+## Limits
+
+- One voice, English (US) only, in a read-aloud style.
+- No text normalisation yet. Write numbers, money and abbreviations out in words ("five dollars", not "$5"; "Doctor",
+  not "Dr.").
+- Long text is split into sentences, and very long sentences are split at commas.
+- Platforms: macOS (Apple silicon and Intel), Linux (x86-64 and ARM64, which includes a 64-bit Raspberry Pi OS) and
+  Windows, wherever onnxruntime and espeakng-loader have wheels.
+
+## How it works
+
+1. espeak-ng turns the text into phonemes.
+2. A transformer encoder and a duration predictor read the phonemes.
+3. A flow-matching decoder draws a mel spectrogram in 8 guided steps.
+4. The Vocos vocoder turns the spectrogram into sound.
+
+The acoustic model has 11.4M parameters and was trained from scratch on LJ Speech.
+
+## Licence
+
+The code and the Junco weights are Apache-2.0. The bundled Vocos vocoder weights are MIT (Charactr Inc.). Phonemes come
+from `phonemizer` and espeak-ng (through `espeakng-loader`). Both are GPL-3.0 and are installed as separate dependencies,
+not included in this package. See `NOTICE`.

flockspeech-0.1.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+flockspeech/__init__.py,sha256=PlMnV4Op-InU03AIka1QF-LhnSUwP_HvYn41oP3dOAk,2902
+flockspeech/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+flockspeech/cli.py,sha256=JHgRLbI0KV-5DdZ1cJxTHo_LCzoIePItEYU8OedQNyQ,2819
+flockspeech/engine.py,sha256=MLGmUgF8bfvjiP-fB-L6PnilR1FHNNrhkV3ALw272aQ,5545
+flockspeech/text.py,sha256=4Oppv6VWqHG2lbfS-yRtg7HH1zHqtXijatOEDKQVpRs,2328
+flockspeech/models/LICENSE-vocos,sha256=jza6DCFNT0h__X7guFKNqbZ7RZvvLRFd6c0AExZYn0Y,1069
+flockspeech/models/decoder-int8.onnx,sha256=yUD93Ot7Iv6i0cOLS5ZvwVd04JMVLIwxnH0P-_pAnNY,9936441
+flockspeech/models/encoder.onnx,sha256=-uem1iew0zlhp47DAtZCsdYJ_mi1MfghZKVbJ3oV5T0,7174680
+flockspeech/models/junco.json,sha256=sP96-6JDeh_3IklJtigo7KwT1yOkaLBVTmQ34ANa-I0,337
+flockspeech/models/vocoder.onnx,sha256=F4GrkDiw7Hx7RNwE0Ayo_mDd4OkhXvc741NigIWhiHM,27099450
+flockspeech-0.1.0.dist-info/METADATA,sha256=-dT8IxlsIH65VpyZ8ir2UWEKP2-zgjCy6WgRMYgKon8,4364
+flockspeech-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+flockspeech-0.1.0.dist-info/entry_points.txt,sha256=eXGjKlyi7Yrv0zcBBEKQJG6EPCZeVQJ7R4UwIGh1pY0,53
+flockspeech-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+flockspeech-0.1.0.dist-info/licenses/NOTICE,sha256=4Fiu4eM3K0fNjnu-SZYkkJxPh_AupONznA43q0pVOZg,746
+flockspeech-0.1.0.dist-info/licenses/src/flockspeech/models/LICENSE-vocos,sha256=jza6DCFNT0h__X7guFKNqbZ7RZvvLRFd6c0AExZYn0Y,1069
+flockspeech-0.1.0.dist-info/RECORD,,

flockspeech-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

flockspeech-0.1.0.dist-info/entry_points.txt

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

flockspeech-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

flockspeech-0.1.0.dist-info/licenses/NOTICE

@@ -0,0 +1,16 @@
+Flock Speech (flockspeech)
+Copyright 2026 Flock Speech
+
+Licensed under the Apache License, Version 2.0 (see LICENSE). This covers the package code and the Junco
+acoustic model weights (src/flockspeech/models/encoder.onnx, decoder-int8.onnx).
+
+Third-party components:
+
+- Vocos vocoder (src/flockspeech/models/vocoder.onnx): converted from charactr/vocos-mel-24khz,
+  Copyright (c) 2023 Charactr Inc., MIT License (see src/flockspeech/models/LICENSE-vocos).
+- Training data: LJ Speech Dataset (Keith Ito and Linda Johnson), public domain.
+
+Dependencies installed by pip, not included in this package:
+
+- phonemizer (GPL-3.0) and espeak-ng (GPL-3.0, shipped by espeakng-loader) turn text into phonemes.
+- onnxruntime (MIT) and numpy (BSD-3-Clause).

flockspeech-0.1.0.dist-info/licenses/src/flockspeech/models/LICENSE-vocos

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