Pull pre-built sherpa-onnx instead of building it here

Author: mitchsayre

.github/workflows/wheels.yml

@@ -1,4 +1,4 @@
-name: Wheels
+name: Python
 
 on:
   workflow_dispatch:
@@ -12,11 +12,35 @@ on:
 permissions:
   contents: read
 
-env:
-  SHERPA_ONNX_REF: cc9366cb03e06ebcc19a7f3cdfe4c23bf219ee0b
-
 jobs:
   build:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+
+      - name: Set up Python
+        uses: actions/setup-python@v6
+        with:
+          python-version: "3.13"
+
+      - name: Install build tools
+        run: python -m pip install --upgrade pip build
+
+      - name: Build artifacts
+        run: python -m build
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/*
+
+  unit-tests:
+    needs: build
     name: ${{ matrix.name }}
     runs-on: ${{ matrix.os }}
     strategy:
@@ -25,44 +49,50 @@ jobs:
         include:
           - name: linux-x86_64
             os: ubuntu-latest
+            python-version: "3.9"
+            sherpa-onnx-url: https://github.com/wfloat/sherpa-onnx/releases/download/v1.12.23/sherpa_onnx-1.12.23-cp39-cp39-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
           - name: windows-x86_64
             os: windows-latest
+            python-version: "3.10"
+            sherpa-onnx-url: https://github.com/wfloat/sherpa-onnx/releases/download/v1.12.23/sherpa_onnx-1.12.23-cp310-cp310-win_amd64.whl
           - name: macos-x86_64
             os: macos-15-intel
+            python-version: "3.12"
+            sherpa-onnx-url: https://github.com/wfloat/sherpa-onnx/releases/download/v1.12.23/sherpa_onnx-1.12.23-cp312-cp312-macosx_10_15_x86_64.whl
           - name: macos-arm64
             os: macos-15
+            python-version: "3.13"
+            sherpa-onnx-url: https://github.com/wfloat/sherpa-onnx/releases/download/v1.12.23/sherpa_onnx-1.12.23-cp313-cp313-macosx_11_0_arm64.whl
 
     steps:
-      - name: Check out wfloat-python
+      - name: Check out repository
         uses: actions/checkout@v6
         with:
           persist-credentials: false
 
-      - name: Check out sherpa-onnx
-        uses: actions/checkout@v6
+      - name: Download artifacts
+        uses: actions/download-artifact@v4
         with:
-          repository: wfloat/sherpa-onnx
-          ref: ${{ env.SHERPA_ONNX_REF }}
-          path: sherpa-onnx
-          persist-credentials: false
+          name: dist
+          path: dist
 
       - name: Set up Python
         uses: actions/setup-python@v6
         with:
-          python-version: "3.13"
+          python-version: ${{ matrix.python-version }}
 
-      - name: Install cibuildwheel
-        run: python -m pip install --upgrade pip cibuildwheel==3.4.1
+      - name: Install sherpa-onnx release wheel
+        shell: bash
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install "${{ matrix.sherpa-onnx-url }}"
 
-      - name: Build wheels
-        env:
-          CIBW_ENVIRONMENT_PASS_LINUX: WFLOAT_SHERPA_ONNX_SOURCE_DIR MACOSX_DEPLOYMENT_TARGET
-          MACOSX_DEPLOYMENT_TARGET: "13.4"
-          WFLOAT_SHERPA_ONNX_SOURCE_DIR: ${{ runner.os == 'Linux' && '/project/sherpa-onnx' || format('{0}/sherpa-onnx', github.workspace) }}
-        run: python -m cibuildwheel --output-dir wheelhouse
+      - name: Install wfloat artifact
+        shell: bash
+        run: python -m pip install --no-deps dist/*.whl
 
-      - name: Upload wheels
-        uses: actions/upload-artifact@v4
-        with:
-          name: wheels-${{ matrix.name }}
-          path: wheelhouse/*.whl
+      - name: Run unit tests
+        run: python -m unittest discover -s tests -v
+
+      - name: Run integration smoke test
+        run: python -c "import sherpa_onnx, wfloat; import wfloat._bindings as bindings; print(wfloat.__version__); print(sherpa_onnx.__version__); print(bindings.OfflineTts)"

CONTRIBUTING.md

@@ -1,156 +1,69 @@
 # Contributing
 
-This package wraps a native `sherpa-onnx` build, so building and publishing it
-is a little different from a pure-Python package.
+`wfloat` is now a pure Python package. Native code comes from a separately
+installed `sherpa-onnx` wheel.
 
 ## Prerequisites
 
-You will need:
+- Python 3.9+
+- a compatible `sherpa-onnx` wheel available from GitHub Releases or another
+  package source
 
-- Python 3.8+
-- `cmake`
-- a working C/C++ toolchain
-- the `sherpa-onnx` source tree available locally
-
-By default, `setup.py` expects the source tree to live at:
-
-```text
-../../sherpa-onnx
-```
-
-If your checkout lives somewhere else, set:
-
-```bash
-export WFLOAT_SHERPA_ONNX_SOURCE_DIR=/absolute/path/to/sherpa-onnx
-```
-
-## Local Setup
-
-Create a virtualenv and install the packaging tools:
+## Local setup
 
 ```bash
 python3 -m venv .venv
 source .venv/bin/activate
 python -m pip install --upgrade pip
-python -m pip install setuptools wheel build twine ninja
+python -m pip install setuptools wheel build twine
 ```
 
-`ninja` is recommended for faster native builds, but it is not required.
-
-## Build For Local Development
-
-If you just want to compile the native extension locally, run:
+Install `sherpa-onnx` first if you want to exercise the low-level bindings:
 
 ```bash
-python setup.py build_ext --build-lib ./build-out --build-temp ./build-temp
+pip install https://github.com/wfloat/sherpa-onnx/releases/download/<tag>/<wheel>.whl
 ```
 
-This produces a local install tree under `build-out/` and temporary native build
-files under `build-temp/`.
-
-These directories are generated artifacts and should not be committed.
-
-## Build Release Artifacts
-
-For release builds, set `WFLOAT_SHERPA_ONNX_SOURCE_DIR` to an absolute path.
-This package's wheel build compiles native code from the sibling
-`sherpa-onnx` checkout, and build tools may run parts of the build from a
-temporary directory where the default relative path no longer works.
+Then install `wfloat`:
 
 ```bash
-export WFLOAT_SHERPA_ONNX_SOURCE_DIR=/absolute/path/to/sherpa-onnx
+pip install -e .
 ```
 
-To build a release wheel:
+## Build release artifacts
 
 ```bash
 rm -rf build dist
-python -m build --wheel --no-isolation
+python -m build
 ```
 
-That should produce:
+That produces:
 
 - `dist/*.whl`
+- `dist/*.tar.gz`
 
-The package version comes from:
-
-```text
-python/wfloat/_version.py
-```
-
-Update that file before cutting a new PyPI release.
-
-## CI Wheels
-
-Multi-platform wheels are built in GitHub Actions with `cibuildwheel` via:
+## Tests
 
-```text
-.github/workflows/wheels.yml
-```
-
-That workflow checks out `wfloat-python`, checks out `wfloat/sherpa-onnx` as a
-workspace sibling, and builds wheel artifacts for:
-
-- Linux x86_64
-- Windows x86_64
-- macOS x86_64
-- macOS arm64
-
-The `sherpa-onnx` ref is currently controlled in the workflow file with the
-`SHERPA_ONNX_REF` environment variable. It is pinned to a specific commit so CI
-rebuilds against a stable native dependency.
-
-The CI workflow intentionally builds wheels only. We should not publish an
-sdist until the source-distribution story no longer depends on an external
-`sherpa-onnx` checkout.
-
-## Publish To PyPI
-
-1. Build a fresh wheel:
+Unit tests do not require `sherpa-onnx`:
 
 ```bash
-rm -rf build dist
-python -m build --wheel --no-isolation
+python -m unittest discover -s tests -v
 ```
 
-2. Check the generated wheel:
+If you have installed a compatible `sherpa-onnx` wheel, you can also run a
+simple smoke check:
 
 ```bash
-python -m twine check dist/*
+python -c "import sherpa_onnx, wfloat; print(wfloat.__version__)"
 ```
 
-3. Upload to PyPI:
+## CI
 
-```bash
-python -m twine upload dist/*
-```
+CI now:
 
-If you want to dry-run the process first, upload to TestPyPI:
+- builds pure Python artifacts once
+- installs those artifacts on each target platform
+- runs the unit test suite
 
-```bash
-python -m twine upload --repository testpypi dist/*
-```
-
-## Notes
-
-- The package publishes as `wfloat` on PyPI.
-- The CLI entrypoint is also `wfloat`.
-- Native builds may download third-party dependencies during the CMake step if
-  they are not already available locally.
-- `python -m build` without `WFLOAT_SHERPA_ONNX_SOURCE_DIR` may fail because
-  the wheel build can run from a temporary unpacked source tree.
-- CI wheel builds use normal PEP 517 build isolation through `cibuildwheel`.
-- We currently publish wheels, not a self-contained source distribution. The
-  source distribution path should only be documented after it no longer depends
-  on an external sibling `sherpa-onnx` checkout.
-- Release artifacts should be built from a clean tree so generated files do not
-  get mixed into the package contents.
-
-## Sanity Checks
-
-Before publishing, it is worth running:
-
-```bash
-PYTHONPATH=python python3 -m unittest discover -s tests -v
-python -m wfloat --help
-```
+After `sherpa-onnx` release assets are published, CI can add a platform-specific
+install step that pulls those wheel URLs before running integration smoke tests.

MANIFEST.in

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

README.md

@@ -1,9 +1,18 @@
 # wfloat
 
-`wfloat` is the Python package for loading Wfloat-compatible speech models and
-generating audio files with `sherpa-onnx` under the hood.
+`wfloat` is a high-level Python wrapper around `sherpa-onnx` for loading
+Wfloat-compatible speech models and generating audio files.
 
-The intended high-level flow is:
+## Install
+
+Install a compatible `sherpa-onnx` wheel first, then install `wfloat`:
+
+```bash
+pip install https://github.com/wfloat/sherpa-onnx/releases/download/<tag>/<wheel>.whl
+pip install ./packages/wfloat-python
+```
+
+## Usage
 
 ```python
 import wfloat
@@ -19,38 +28,11 @@ result = model.generate(
 )
 
 result.audio.save("out.wav")
-
-print(result.audio.sample_rate)
-print(result.timeline.chunks[0].start_sec)
-```
-
-## Status
-
-The package now contains the high-level Python API shape:
-
-- `wfloat.load(...)`
-- `model.generate(...)`
-- `model.generate_dialogue(...)`
-- `result.audio.save(...)`
-- timing metadata via `result.timeline`
-
-The Python model asset endpoint still needs to return Python-compatible asset
-metadata for live downloads to work end to end.
-
-## CLI
-
-The package also exposes a `wfloat` CLI:
-
-```bash
-wfloat synth --text "Hello world." --out out.wav
 ```
 
 ## Notes
 
-- The package is designed to cache model assets locally.
-- Voice IDs can be passed as strings such as `narrator_woman` or as numeric
-  speaker IDs.
+- `wfloat` does not build or bundle native libraries.
+- Low-level bindings come from the installed `sherpa-onnx` wheel.
 - The public API is intentionally high-level; low-level native config objects
-  are not the primary integration surface.
-
-More implementation detail lives in [DESIGN.md](./DESIGN.md).
+  are re-exported only for advanced use.