wfloat 0.0.1__tar.gz → 1.0.0__tar.gz

wfloat-1.0.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include README.md
+recursive-include python *.py

wfloat-1.0.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: wfloat
+Version: 1.0.0
+Summary: High-level Python wrapper for Wfloat TTS
+Home-page: https://github.com/wfloat/wfloat-python
+Author: wfloat
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: wfloat-sherpa-onnx==1.12.23
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# wfloat
+
+`wfloat` is a high-level Python wrapper around `sherpa-onnx` for loading
+Wfloat-compatible speech models and generating audio files.
+
+## Install
+
+Install `wfloat` normally:
+
+```bash
+pip install wfloat
+```
+
+That will also install the matching `wfloat-sherpa-onnx` dependency from PyPI.
+
+When installing from this repo locally:
+
+```bash
+pip install ./packages/wfloat-python
+```
+
+## Usage
+
+```python
+import wfloat
+
+model = wfloat.load("wfloat/wfloat-tts")
+
+result = model.generate(
+    text="The signal is clean. Start the recording.",
+    voice_id="narrator_woman",
+    emotion="neutral",
+    intensity=0.5,
+    speed=1.0,
+)
+
+result.audio.save("out.wav")
+```
+
+## Notes
+
+- `wfloat` does not build or bundle native libraries.
+- Low-level bindings come from the installed `wfloat-sherpa-onnx` dependency,
+  which provides `import sherpa_onnx`.
+- The public API is intentionally high-level; low-level native config objects
+  are re-exported only for advanced use.

wfloat-1.0.0/README.md

@@ -0,0 +1,46 @@
+# wfloat
+
+`wfloat` is a high-level Python wrapper around `sherpa-onnx` for loading
+Wfloat-compatible speech models and generating audio files.
+
+## Install
+
+Install `wfloat` normally:
+
+```bash
+pip install wfloat
+```
+
+That will also install the matching `wfloat-sherpa-onnx` dependency from PyPI.
+
+When installing from this repo locally:
+
+```bash
+pip install ./packages/wfloat-python
+```
+
+## Usage
+
+```python
+import wfloat
+
+model = wfloat.load("wfloat/wfloat-tts")
+
+result = model.generate(
+    text="The signal is clean. Start the recording.",
+    voice_id="narrator_woman",
+    emotion="neutral",
+    intensity=0.5,
+    speed=1.0,
+)
+
+result.audio.save("out.wav")
+```
+
+## Notes
+
+- `wfloat` does not build or bundle native libraries.
+- Low-level bindings come from the installed `wfloat-sherpa-onnx` dependency,
+  which provides `import sherpa_onnx`.
+- The public API is intentionally high-level; low-level native config objects
+  are re-exported only for advanced use.

wfloat-1.0.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"

wfloat-1.0.0/python/wfloat/__init__.py

@@ -0,0 +1,47 @@
+from ._constants import SPEAKER_IDS, VALID_EMOTIONS, VALID_SIDS
+from ._model import Model, load
+from ._results import Audio, GenerationResult, Timeline, TimelineChunk
+from ._version import __version__
+
+_LOW_LEVEL_EXPORTS = {
+    "GenerationConfig",
+    "OfflineTts",
+    "OfflineTtsConfig",
+    "OfflineTtsModelConfig",
+    "OfflineTtsWfloatModelConfig",
+    "WfloatPreparedText",
+    "git_date",
+    "git_sha1",
+    "prepare_wfloat_text",
+    "version",
+    "write_wave",
+}
+
+
+__all__ = [
+    "Audio",
+    "GenerationResult",
+    "Model",
+    "SPEAKER_IDS",
+    "Timeline",
+    "TimelineChunk",
+    "VALID_EMOTIONS",
+    "VALID_SIDS",
+    "load",
+]
+__all__.extend(sorted(_LOW_LEVEL_EXPORTS))
+
+
+def __getattr__(name):
+    if name not in _LOW_LEVEL_EXPORTS:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+    from . import _bindings
+
+    value = getattr(_bindings, name)
+    globals()[name] = value
+    return value
+
+
+def __dir__():
+    return sorted(set(globals()) | _LOW_LEVEL_EXPORTS)

wfloat-1.0.0/python/wfloat/__main__.py

@@ -0,0 +1,5 @@
+from ._cli import main
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

wfloat-1.0.0/python/wfloat/_assets.py

@@ -0,0 +1,124 @@
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Optional
+from urllib.parse import urlencode, urlparse
+from urllib.request import Request, urlopen
+
+from ._version import __version__ as PACKAGE_VERSION
+
+
+DEFAULT_MODEL_ASSET_HOST = "https://wfloat.com"
+DEFAULT_MODEL_ASSET_PATH = "/api/model-assets"
+
+
+@dataclass(frozen=True)
+class ModelAssets:
+    model_onnx: str
+    model_onnx_checksum: str
+    model_tokens: str
+    model_tokens_checksum: str
+    espeak_data: str
+    espeak_checksum: str
+    persistent_id: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, object]) -> "ModelAssets":
+        required_fields = (
+            "model_onnx",
+            "model_onnx_checksum",
+            "model_tokens",
+            "model_tokens_checksum",
+            "espeak_data",
+            "espeak_checksum",
+        )
+
+        missing = [
+            field_name
+            for field_name in required_fields
+            if not isinstance(data.get(field_name), str) or not str(data.get(field_name)).strip()
+        ]
+        if missing:
+            raise ValueError(
+                "Model asset response is missing required fields: %s"
+                % ", ".join(missing)
+            )
+
+        return cls(
+            model_onnx=str(data["model_onnx"]),
+            model_onnx_checksum=str(data["model_onnx_checksum"]),
+            model_tokens=str(data["model_tokens"]),
+            model_tokens_checksum=str(data["model_tokens_checksum"]),
+            espeak_data=str(data["espeak_data"]),
+            espeak_checksum=str(data["espeak_checksum"]),
+            persistent_id=str(data["persistent_id"]).strip()
+            if isinstance(data.get("persistent_id"), str) and str(data.get("persistent_id")).strip()
+            else None,
+        )
+
+    def to_dict(self) -> Dict[str, str]:
+        return {
+            "model_onnx": self.model_onnx,
+            "model_onnx_checksum": self.model_onnx_checksum,
+            "model_tokens": self.model_tokens,
+            "model_tokens_checksum": self.model_tokens_checksum,
+            "espeak_data": self.espeak_data,
+            "espeak_checksum": self.espeak_checksum,
+            **({"persistent_id": self.persistent_id} if self.persistent_id else {}),
+        }
+
+
+def get_package_version(default: str = "0.0.0") -> str:
+    return PACKAGE_VERSION or default
+
+
+def get_model_asset_host() -> str:
+    return os.environ.get("WFLOAT_MODEL_ASSET_HOST", DEFAULT_MODEL_ASSET_HOST).rstrip("/")
+
+
+def filename_from_url(url: str, fallback: str) -> str:
+    parsed = urlparse(url)
+    filename = Path(parsed.path).name
+    return filename or fallback
+
+
+def fetch_model_assets(
+    model_name: str,
+    *,
+    persistent_id: Optional[str] = None,
+    package_version_override: Optional[str] = None,
+    timeout: float = 60.0,
+) -> ModelAssets:
+    version = package_version_override or get_package_version()
+    query = {
+        "platform": "python",
+        "version": version,
+        "model_name": model_name,
+    }
+    if persistent_id:
+        query["persistent_id"] = persistent_id
+
+    params = urlencode(query)
+    url = "%s%s?%s" % (get_model_asset_host(), DEFAULT_MODEL_ASSET_PATH, params)
+    request = Request(
+        url,
+        headers={
+            "Accept": "application/json",
+            "User-Agent": "wfloat-python/%s" % version,
+        },
+        method="GET",
+    )
+
+    with urlopen(request, timeout=timeout) as response:
+        payload = response.read().decode("utf-8")
+
+    try:
+        data = json.loads(payload)
+    except json.JSONDecodeError as exc:
+        raise RuntimeError("Failed to decode model asset response JSON.") from exc
+
+    if not isinstance(data, dict):
+        raise RuntimeError("Model asset response must be a JSON object.")
+
+    return ModelAssets.from_dict(data)

wfloat-1.0.0/python/wfloat/_bindings.py

@@ -0,0 +1,58 @@
+try:
+    import sherpa_onnx
+except ImportError as exc:
+    raise ImportError(
+        "Failed to import sherpa_onnx. "
+        "Reinstall wfloat so pip can install the matching wfloat-sherpa-onnx dependency."
+    ) from exc
+
+
+_REQUIRED_EXPORTS = (
+    "GenerationConfig",
+    "OfflineTts",
+    "OfflineTtsConfig",
+    "OfflineTtsModelConfig",
+    "OfflineTtsWfloatModelConfig",
+    "WfloatPreparedText",
+    "git_date",
+    "git_sha1",
+    "prepare_wfloat_text",
+    "version",
+    "write_wave",
+)
+
+missing_exports = [name for name in _REQUIRED_EXPORTS if not hasattr(sherpa_onnx, name)]
+if missing_exports:
+    raise ImportError(
+        "Installed sherpa_onnx is missing required exports: "
+        f"{', '.join(missing_exports)}. "
+        "Reinstall wfloat so pip can install a compatible wfloat-sherpa-onnx build."
+    )
+
+
+GenerationConfig = sherpa_onnx.GenerationConfig
+OfflineTts = sherpa_onnx.OfflineTts
+OfflineTtsConfig = sherpa_onnx.OfflineTtsConfig
+OfflineTtsModelConfig = sherpa_onnx.OfflineTtsModelConfig
+OfflineTtsWfloatModelConfig = sherpa_onnx.OfflineTtsWfloatModelConfig
+WfloatPreparedText = sherpa_onnx.WfloatPreparedText
+git_date = sherpa_onnx.git_date
+git_sha1 = sherpa_onnx.git_sha1
+prepare_wfloat_text = sherpa_onnx.prepare_wfloat_text
+version = sherpa_onnx.version
+write_wave = sherpa_onnx.write_wave
+
+
+__all__ = [
+    "GenerationConfig",
+    "OfflineTts",
+    "OfflineTtsConfig",
+    "OfflineTtsModelConfig",
+    "OfflineTtsWfloatModelConfig",
+    "WfloatPreparedText",
+    "git_date",
+    "git_sha1",
+    "prepare_wfloat_text",
+    "version",
+    "write_wave",
+]

wfloat-1.0.0/python/wfloat/_cache.py

@@ -0,0 +1,235 @@
+import json
+import os
+import shutil
+import tempfile
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from ._assets import ModelAssets, filename_from_url
+from ._download import (
+    download_file,
+    extract_archive,
+    normalize_checksum,
+    resolve_extracted_data_directory,
+    verify_checksum,
+)
+
+
+@dataclass(frozen=True)
+class CachedModelAssets:
+    model_name: str
+    cache_dir: Path
+    model_path: Path
+    tokens_path: Path
+    espeak_data_dir: Path
+    manifest_path: Path
+
+
+def get_default_cache_dir() -> Path:
+    if os.name == "nt":
+        local_appdata = os.environ.get("LOCALAPPDATA")
+        if local_appdata:
+            return Path(local_appdata) / "wfloat" / "Cache"
+        return Path.home() / "AppData" / "Local" / "wfloat" / "Cache"
+
+    if sys_platform_startswith("darwin"):
+        return Path.home() / "Library" / "Caches" / "wfloat"
+
+    xdg_cache_home = os.environ.get("XDG_CACHE_HOME")
+    if xdg_cache_home:
+        return Path(xdg_cache_home) / "wfloat"
+
+    return Path.home() / ".cache" / "wfloat"
+
+
+def sys_platform_startswith(prefix: str) -> bool:
+    import sys
+
+    return sys.platform.startswith(prefix)
+
+
+def normalize_model_name(model_name: str) -> str:
+    normalized = model_name.strip().replace("\\", "/")
+    normalized = normalized.replace("/", "--")
+    normalized = normalized.replace(" ", "-")
+    return normalized
+
+
+def _ensure_directory(path: Path) -> None:
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def get_persistent_id_path(cache_dir: Optional[Path] = None) -> Path:
+    cache_root = Path(cache_dir) if cache_dir is not None else get_default_cache_dir()
+    return cache_root / "persistent_id"
+
+
+def load_persistent_id(cache_dir: Optional[Path] = None) -> Optional[str]:
+    path = get_persistent_id_path(cache_dir)
+    if not path.is_file():
+        return None
+
+    try:
+        value = path.read_text(encoding="utf-8").strip()
+    except OSError:
+        return None
+
+    return value or None
+
+
+def save_persistent_id(persistent_id: Optional[str], cache_dir: Optional[Path] = None) -> None:
+    if not persistent_id:
+        return
+
+    path = get_persistent_id_path(cache_dir)
+    _ensure_directory(path.parent)
+    path.write_text(persistent_id.strip() + "\n", encoding="utf-8")
+
+
+def _cleanup_stale_model_files(model_dir: Path, active_names) -> None:
+    if not model_dir.exists():
+        return
+
+    for child in model_dir.iterdir():
+        if child.name in active_names:
+            continue
+        if child.is_file():
+            child.unlink()
+
+
+def _write_manifest(manifest_path: Path, model_name: str, assets: ModelAssets) -> None:
+    manifest_payload = {
+        "model_name": model_name,
+        "assets": assets.to_dict(),
+    }
+    manifest_path.write_text(json.dumps(manifest_payload, indent=2, sort_keys=True) + "\n")
+
+
+def _ensure_cached_file(
+    source_url: str,
+    checksum: str,
+    destination: Path,
+    downloads_dir: Path,
+    *,
+    force_download: bool,
+) -> Path:
+    if not force_download and verify_checksum(destination, checksum):
+        return destination
+
+    suffix = destination.suffix or ".bin"
+    temp_download = downloads_dir / (uuid.uuid4().hex + suffix)
+    download_file(source_url, temp_download, expected_checksum=checksum)
+    _ensure_directory(destination.parent)
+    os.replace(str(temp_download), str(destination))
+    return destination
+
+
+def _install_espeak_data(
+    assets: ModelAssets,
+    cache_root: Path,
+    downloads_dir: Path,
+    *,
+    force_download: bool,
+) -> Path:
+    checksum = normalize_checksum(assets.espeak_checksum)
+    espeak_root = cache_root / "espeak" / checksum
+    data_dir = espeak_root / "espeak-ng-data"
+    ready_marker = espeak_root / ".ready"
+
+    if (
+        not force_download
+        and ready_marker.is_file()
+        and data_dir.is_dir()
+    ):
+        return data_dir
+
+    if espeak_root.exists():
+        shutil.rmtree(espeak_root)
+
+    _ensure_directory(espeak_root)
+    archive_name = filename_from_url(assets.espeak_data, checksum + ".zip")
+    temp_archive = downloads_dir / (uuid.uuid4().hex + "-" + archive_name)
+    download_file(
+        assets.espeak_data,
+        temp_archive,
+        expected_checksum=assets.espeak_checksum,
+    )
+
+    extraction_root = Path(
+        tempfile.mkdtemp(prefix="wfloat-espeak-", dir=str(downloads_dir))
+    )
+    try:
+        extract_archive(temp_archive, extraction_root)
+        resolved_data_dir = resolve_extracted_data_directory(extraction_root)
+        if data_dir.exists():
+            shutil.rmtree(data_dir)
+        shutil.copytree(str(resolved_data_dir), str(data_dir))
+        ready_marker.write_text("ready\n")
+    finally:
+        if temp_archive.exists():
+            temp_archive.unlink()
+        if extraction_root.exists():
+            shutil.rmtree(extraction_root)
+
+    return data_dir
+
+
+def cache_model_assets(
+    model_name: str,
+    assets: ModelAssets,
+    *,
+    cache_dir: Optional[Path] = None,
+    force_download: bool = False,
+) -> CachedModelAssets:
+    cache_root = Path(cache_dir) if cache_dir is not None else get_default_cache_dir()
+    models_dir = cache_root / "models"
+    downloads_dir = cache_root / "downloads"
+
+    _ensure_directory(models_dir)
+    _ensure_directory(downloads_dir)
+
+    model_dir = models_dir / normalize_model_name(model_name)
+    _ensure_directory(model_dir)
+
+    model_filename = filename_from_url(assets.model_onnx, "model.onnx")
+    tokens_filename = filename_from_url(assets.model_tokens, "tokens.txt")
+    manifest_path = model_dir / "manifest.json"
+
+    _cleanup_stale_model_files(
+        model_dir,
+        active_names={model_filename, tokens_filename, "manifest.json"},
+    )
+
+    model_path = _ensure_cached_file(
+        assets.model_onnx,
+        assets.model_onnx_checksum,
+        model_dir / model_filename,
+        downloads_dir,
+        force_download=force_download,
+    )
+    tokens_path = _ensure_cached_file(
+        assets.model_tokens,
+        assets.model_tokens_checksum,
+        model_dir / tokens_filename,
+        downloads_dir,
+        force_download=force_download,
+    )
+    espeak_data_dir = _install_espeak_data(
+        assets,
+        cache_root,
+        downloads_dir,
+        force_download=force_download,
+    )
+
+    _write_manifest(manifest_path, model_name, assets)
+
+    return CachedModelAssets(
+        model_name=model_name,
+        cache_dir=cache_root,
+        model_path=model_path,
+        tokens_path=tokens_path,
+        espeak_data_dir=espeak_data_dir,
+        manifest_path=manifest_path,
+    )

wfloat-1.0.0/python/wfloat/_cli.py

@@ -0,0 +1,74 @@
+import argparse
+
+from ._model import load
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="wfloat")
+    subparsers = parser.add_subparsers(dest="command")
+
+    synth = subparsers.add_parser("synth", help="Generate speech and write a WAV file.")
+    synth.add_argument("--model", default="wfloat/wfloat-tts", help="Model name to load.")
+    synth.add_argument("--text", required=True, help="Text to synthesize.")
+    synth.add_argument("--out", required=True, help="Output WAV path.")
+    synth.add_argument("--voice-id", default=None, help="Voice ID name or numeric SID.")
+    synth.add_argument("--emotion", default=None, help="Emotion name.")
+    synth.add_argument("--intensity", type=float, default=None, help="Emotion intensity.")
+    synth.add_argument("--speed", type=float, default=None, help="Speech speed.")
+    synth.add_argument(
+        "--silence-padding-sec",
+        type=float,
+        default=None,
+        help="Silence padding between generated sentence chunks.",
+    )
+    synth.add_argument(
+        "--cache-dir",
+        default=None,
+        help="Optional override for the cache directory.",
+    )
+    synth.add_argument(
+        "--force-download",
+        action="store_true",
+        help="Redownload model assets even if cached copies are present.",
+    )
+
+    return parser
+
+
+def _maybe_parse_voice_id(value):
+    if value is None:
+        return None
+
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return value
+
+
+def main(argv=None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command != "synth":
+        parser.print_help()
+        return 1
+
+    model = load(
+        args.model,
+        cache_dir=args.cache_dir,
+        force_download=args.force_download,
+    )
+    result = model.generate(
+        text=args.text,
+        voice_id=_maybe_parse_voice_id(args.voice_id),
+        emotion=args.emotion,
+        intensity=args.intensity,
+        speed=args.speed,
+        silence_padding_sec=args.silence_padding_sec,
+    )
+    result.audio.save(args.out)
+    print(
+        "Saved %s (duration=%.2fs, sample_rate=%d)"
+        % (args.out, result.audio.duration_sec, result.audio.sample_rate)
+    )
+    return 0