diff --git a/.github/workflows/build-linux.yml b/.github/workflows/build-linux.yml
deleted file mode 100644
index 0f72760..0000000
--- a/.github/workflows/build-linux.yml
+++ /dev/null
@@ -1,59 +0,0 @@
-name: Build Linux AppImage
-
-on:
- workflow_dispatch:
- push:
- tags:
- - "v*"
-
-jobs:
- appimage:
- runs-on: ubuntu-latest
-
- steps:
- - uses: actions/checkout@v5
-
- - name: Install build deps
- run: |
- sudo apt-get update
- sudo apt-get install -y \
- musl-tools \
- file \
- wget \
- desktop-file-utils \
- libfuse2
-
- - name: Build musl launcher
- run: |
- mkdir -p dist
- musl-gcc -O2 -static launcher.c -o dist/celune
- file dist/celune
-
- - name: Prepare AppDir
- run: |
- mkdir -p Celune.AppDir
- cp dist/celune Celune.AppDir/celune
- ln -sf celune Celune.AppDir/AppRun
- chmod +x Celune.AppDir/celune
-
- - name: Validate AppDir
- run: |
- test -x Celune.AppDir/celune
- test -L Celune.AppDir/AppRun
- test -f Celune.AppDir/celune.desktop
- test -f Celune.AppDir/celune.png
- file Celune.AppDir/celune
- file Celune.AppDir/AppRun
- desktop-file-validate Celune.AppDir/celune.desktop
-
- - name: Download appimagetool & Build AppImage
- run: |
- wget -O appimagetool https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
- chmod +x appimagetool
- ./appimagetool Celune.AppDir celune.appimage
-
- - name: Upload AppImage
- uses: actions/upload-artifact@v6
- with:
- name: Celune-Linux-x86_64
- path: celune.appimage
diff --git a/.github/workflows/build-windows.yml b/.github/workflows/build-windows.yml
deleted file mode 100644
index 0afcb5c..0000000
--- a/.github/workflows/build-windows.yml
+++ /dev/null
@@ -1,37 +0,0 @@
-name: Build Windows
-
-on:
- workflow_dispatch:
- push:
- tags:
- - "v*"
-
-jobs:
- windows:
- runs-on: windows-latest
-
- steps:
- - uses: actions/checkout@v5
-
- - name: Build launcher
- shell: cmd
- run: |
- if not exist dist mkdir dist
-
- for /f "tokens=*" %%i in ('"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -find VC\Auxiliary\Build\vcvars64.bat') do set "VCVARS=%%i"
-
- if "%VCVARS%"=="" (
- echo vcvars64.bat not found
- exit /b 1
- )
-
- call "%VCVARS%"
-
- where cl
- cl /nologo /O2 /MT launcher.c resources\celune.res /link /OUT:dist\celune.exe
-
- - name: Upload EXE
- uses: actions/upload-artifact@v6
- with:
- name: Celune-Windows-x86_64
- path: dist/celune.exe
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e90831e..0c7befb 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -57,8 +57,8 @@ jobs:
run: |
uv run python -c "import celune; print(dir(celune))"
- launcher-smoke-linux:
- name: Linux Launcher Build Smoke Test
+ launcher-build-linux:
+ name: Linux Launcher Build
runs-on: ubuntu-latest
steps:
@@ -68,56 +68,75 @@ jobs:
- name: Install build tools
run: |
sudo apt-get update
- sudo apt-get install -y musl-tools file
+ sudo apt-get install -y gcc wget desktop-file-utils libfuse2
- - name: Build launcher (musl static)
- run: |
- mkdir -p dist
- musl-gcc -O2 -static launcher.c -o dist/celune
+ - name: Install uv
+ uses: astral-sh/setup-uv@v7
+
+ - name: Sync dependencies
+ run: uv sync --dev
- - name: Validate launcher binary
+ - name: Install Nuitka into project environment
+ run: uv pip install --python .venv/bin/python Nuitka
+
+ - name: Install appimagetool
run: |
- test -f dist/celune
- test -x dist/celune
- file dist/celune
+ wget -O /tmp/appimagetool https://github.com/AppImage/AppImageKit/releases/download/continuous/appimagetool-x86_64.AppImage
+ chmod +x /tmp/appimagetool
+ sudo mv /tmp/appimagetool /usr/local/bin/appimagetool
- launcher-smoke-windows:
- name: Windows Launcher Build Smoke Test
+ - name: Build Linux launcher artifacts
+ run: |
+ bash ./scripts/build_nuitka.sh
+ test -x bin/celune
+ test -x bin/celune-bin
+ test -f bin/celune.AppImage
+
+ - name: Upload Linux launcher artifacts
+ uses: actions/upload-artifact@v6
+ with:
+ name: Celune-linux-x64
+ path: bin/
+
+ launcher-build-windows:
+ name: Windows Launcher Build
runs-on: windows-latest
steps:
- name: Checkout repository
uses: actions/checkout@v5
- - name: Build launcher
- shell: cmd
- run: |
- if not exist dist mkdir dist
-
- for /f "tokens=*" %%i in ('"%ProgramFiles(x86)%\Microsoft Visual Studio\Installer\vswhere.exe" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -find VC\Auxiliary\Build\vcvars64.bat') do set "VCVARS=%%i"
-
- if "%VCVARS%"=="" (
- echo vcvars64.bat not found
- exit /b 1
- )
+ - name: Install uv
+ uses: astral-sh/setup-uv@v7
- call "%VCVARS%"
+ - name: Sync dependencies
+ shell: powershell
+ run: uv sync --dev
- where cl
- cl /nologo /O2 /MT launcher.c resources\celune.res /link /OUT:dist\celune.exe
+ - name: Install Nuitka into project environment
+ shell: powershell
+ run: uv pip install --python .venv\Scripts\python.exe Nuitka
- - name: Validate EXE
- shell: cmd
+ - name: Build Windows launcher artifacts
+ shell: powershell
run: |
- if not exist dist\celune.exe exit /b 1
+ powershell -ExecutionPolicy Bypass -File .\scripts\build_nuitka.ps1
+ if (!(Test-Path .\bin\celune.exe)) { throw "bin/celune.exe not found" }
+ if (!(Test-Path .\bin\celune-bin.exe)) { throw "bin/celune-bin.exe not found" }
+
+ - name: Upload Windows launcher artifacts
+ uses: actions/upload-artifact@v6
+ with:
+ name: Celune-win-x64
+ path: bin/
notify-failure:
name: Comment on CI Failure
runs-on: ubuntu-latest
needs:
- python-checks
- - launcher-smoke-linux
- - launcher-smoke-windows
+ - launcher-build-linux
+ - launcher-build-windows
if: ${{ always() && contains(join(needs.*.result, ','), 'failure') }}
steps:
@@ -132,18 +151,18 @@ jobs:
EVENT_NAME: ${{ github.event_name }}
PR_NUMBER: ${{ github.event.pull_request.number }}
PYTHON_CHECKS_RESULT: ${{ needs.python-checks.result }}
- LINUX_SMOKE_RESULT: ${{ needs.launcher-smoke-linux.result }}
- WINDOWS_SMOKE_RESULT: ${{ needs.launcher-smoke-windows.result }}
+ LINUX_BUILD_RESULT: ${{ needs.launcher-build-linux.result }}
+ WINDOWS_BUILD_RESULT: ${{ needs.launcher-build-windows.result }}
run: |
failed_jobs=""
if [ "$PYTHON_CHECKS_RESULT" = "failure" ]; then
failed_jobs="${failed_jobs}- Anti AI Slop & Vibe Coding Checks failed"$'\n'
fi
- if [ "$LINUX_SMOKE_RESULT" = "failure" ]; then
- failed_jobs="${failed_jobs}- Linux Launcher Build Smoke Test failed"$'\n'
+ if [ "$LINUX_BUILD_RESULT" = "failure" ]; then
+ failed_jobs="${failed_jobs}- Linux Launcher Build failed"$'\n'
fi
- if [ "$WINDOWS_SMOKE_RESULT" = "failure" ]; then
- failed_jobs="${failed_jobs}- Windows Launcher Build Smoke Test failed"$'\n'
+ if [ "$WINDOWS_BUILD_RESULT" = "failure" ]; then
+ failed_jobs="${failed_jobs}- Windows Launcher Build failed"$'\n'
fi
body="$(printf "Detected potential slop in commit \`%s\`.\n\nThe following jobs have failed:\n%s\nPlease check the logs and unslop your code: %s\n" "$SHA" "$failed_jobs" "$RUN_URL")"
diff --git a/.gitignore b/.gitignore
index 4128098..34b3b35 100644
--- a/.gitignore
+++ b/.gitignore
@@ -221,7 +221,9 @@ __marimo__/
.tmp_hf_modules/
# Celune
-# Celune has an output directory that is not meant to be part of Git.
+# Celune has certain paths that are not meant to be included in the repository.
# To prevent unnecessary speech samples from being included, it has been gitignored.
# Other files that were once here have been moved to a unified data directory.
+# Executable files are meant to be downloaded separately from Actions artifacts.
outputs/
+bin/
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..a2faa1d
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,190 @@
+# AGENTS.md
+
+## Project Overview
+
+Celune is a real-time local AI TTS character engine focused on expressive voice delivery, fast buffered speech generation, and a polished user experience.
+
+Celune supports multiple voice styles, configurable voice packs, frontend/API/extension modes, long-form narration, built-in DSP/audio controls, GPU inference, character responses, a Textual TUI, a FastAPI REST API, and a Gradio-based WebUI.
+
+The project targets Windows and Linux, supports Python 3.12 and 3.13, and is designed for consumer GPU hardware with VRAM presets from roughly 6 GB to 16 GB+.
+
+## Development Principles
+
+* Keep changes focused on the requested task.
+* Avoid unrelated refactors.
+* Prefer simple, maintainable code over clever code.
+* Avoid unnecessary dependencies.
+* Do not add placeholder implementations.
+* Do not add TODO comments.
+* Do not silently disable features to make tests pass.
+* Preserve Celune's local-first, polished, anti-slop project identity.
+* Reuse existing architecture instead of creating parallel systems.
+
+## Typing Style
+
+Prefer classic unions like `Union[str, int]` or `Optional[str]`, rather than using PEP 604 unions like `str | int` or `str | None`.
+
+Other typing features from e.g. PEP 585 or PEP 695 may be used normally.
+
+Avoid using broad types like `Any`, `object` or `T`, unless the function explicitly requires a broad type.
+
+Prefer concrete, meaningful types.
+
+## Reuse Existing Code
+
+Prefer reusable variables, constants, helpers, and project abstractions already present in the repository.
+
+Do not hardcode strings, colors, ports, paths, app names, status labels, or repeated values when the repository already defines them.
+
+Only hardcode or redefine values when importing the existing value would create a circular import, break architecture, create excessive coupling, or otherwise be impractical.
+
+## CI and Validation
+
+The canonical CI command is:
+
+```bash
+python scripts/run_ci.py
+```
+
+On Windows, the path may appear as:
+
+```powershell
+python scripts\run_ci.py
+```
+
+Prefixing it with `uv run` is not required, as it runs the CI commands with it already.
+
+Always use the CI script for validation unless explicitly instructed otherwise.
+
+Do not use:
+
+```text
+- .\.venv\Scripts\python.exe
+- python -m pytest
+- pytest
+- uv cache overrides
+- UV_CACHE_DIR
+- etc.
+```
+
+If for any reason any `uv` command exits with `Access is denied.` or `Permission denied` errors, apply `--no-cache` to `uv`, and try again.
+
+Do not modify the execution environment to work around failures.
+
+Before CI, format the repository with `uv run ruff format .`.
+
+Expected CI runtime is 3-5 minutes.
+
+If CI runtime exceeds 5 minutes:
+- Assume it may have stalled.
+- Stop it from running any further.
+- Report that the CI has taken too long.
+- Do not try to extend any timeouts.
+- Do not try to work around the problem.
+- Wait for any further guidance.
+
+After each task, run `scripts/update_docstrings.py` and then replace placeholders in docstrings like:
+
+```text
+Describe this function.
+
+Args:
+ value: Value for `value`.
+
+Raises:
+ RuntimeError: If `RuntimeError` needs to be raised.
+
+Returns:
+ type: Result of this function.
+```
+
+with proper documentation, while preserving the docstring format.
+
+This process may leave some formatting inaccuracies, run `uv run ruff format .` again after completing docstrings.
+
+If CI fails or times out, report the actual failure clearly. Do not claim success.
+
+## Python and Environment
+
+* Supported Python versions are 3.12 and 3.13.
+* Use `uv` for environment management.
+* Do not use `pip` directly unless explicitly required.
+* Do not assume CPU-only mode supports all features. CPU-only execution is only supported with Celune Mini.
+* Be aware that many features require an RTX 30 series GPU or newer.
+
+## UI and WebUI
+
+Celune has a Textual terminal UI and a Gradio WebUI mounted through FastAPI.
+
+When modifying UI code:
+
+* Preserve Celune's visual identity.
+* The WebUI should feel like a high-resolution counterpart to the TUI.
+* Avoid generic Hugging Face Space-style design.
+* Do not assume Gradio examples for older versions still apply.
+* FastAPI is the application server; Gradio is mounted as the WebUI.
+* Keep mobile/touch support in mind.
+* Do not rely only on screen width for mobile behavior. Prefer pointer/hover media queries when the issue is input method.
+* Desktop keyboard shortcuts must have visible button alternatives for touch devices.
+
+## API
+
+Celune exposes a REST API for programmatic use.
+
+When modifying API code:
+
+* Preserve existing endpoint behavior where practical.
+* Reuse existing request and response models.
+* Keep API behavior consistent with the TUI/WebUI runtime behavior.
+* Do not make the WebUI depend on raw REST calls unless explicitly requested.
+
+## Audio and TTS
+
+Celune includes multiple TTS backends, voice styles, configurable voice packs, long-form narration support, built-in DSP, and native audio controls.
+
+When modifying audio code:
+
+* Prefer existing audio abstractions.
+* Avoid adding large audio/game frameworks for small playback tasks.
+* Do not bypass the existing playback, buffering, stream, or DSP infrastructure without a clear reason.
+* Keep long-form narration stability in mind.
+* Do not add markup/control tags to generated speech unless the backend explicitly supports them.
+
+## System Dependencies
+
+Celune may depend on external system tools such as SoX, Rubber Band, OpenRGB, CUDA Toolkit 12.8, symbolic link support on Windows, and C/C++ build tools for some backends.
+
+Do not remove checks, documentation, or fallback behavior for these dependencies without understanding the runtime impact.
+
+## Documentation
+
+Keep documentation concise, direct, and technically accurate.
+
+When documenting licensing, distinguish between:
+
+* Celune source code, licensed under MIT.
+* Third-party models and assets, which may use their own licenses.
+
+Do not claim third-party models are covered by Celune's MIT license.
+
+When documenting commands, use the canonical project commands from the README.
+
+## Testing Behavior
+
+* Run relevant tests when practical.
+* Prefer the full CI script for final validation.
+* Do not silently narrow validation scope after a failure.
+* If a test cannot be run, say why.
+* If a command times out, report it as a timeout, not as a pass.
+* Do not hide infrastructure failures behind vague wording.
+
+## If Unsure
+
+When unsure, prefer this order:
+
+1. Reuse existing project code.
+2. Preserve current behavior.
+3. Avoid new dependencies.
+4. Keep the TUI, WebUI, API, and runtime consistent.
+5. Run `python scripts/run_ci.py`.
+6. Report failures honestly.
diff --git a/GALLERY.md b/GALLERY.md
new file mode 100644
index 0000000..723b219
--- /dev/null
+++ b/GALLERY.md
@@ -0,0 +1,27 @@
+# Gallery
+
+These images show off Celune's user interface.
+
+## Before init
+
+[](./demos/init.png)
+
+## Ready
+
+[](./demos/ready.png)
+
+## Talking
+
+[](./demos/speaking.png)
+
+## Change voice
+
+[](./demos/change_voice.png)
+
+## Commands
+
+[](./demos/commands.png)
+
+## Extension invoke
+
+[](./demos/extensions.png)
diff --git a/README.md b/README.md
index e98bbf4..599609d 100644
--- a/README.md
+++ b/README.md
@@ -1,8 +1,10 @@
-
+
---
+   
+
Celune is a real-time AI TTS character engine focused on expressive voice delivery with a well-made user experience.
It has been designed to provide fast, high-quality voice generation, even on consumer-grade hardware.
@@ -30,11 +32,15 @@ All decisions and implementations were reviewed, validated, and approved by huma
Celune never was, and will never become an "AI slop" project.
+## License note
+
+Celune is licensed under the [MIT license](https://opensource.org/license/mit), but the software may download certain models from [Hugging Face](https://huggingface.co) that are of varying licenses, such as [Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0) (Qwen, etc.) or [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/deed.en) (Pocket TTS). Users of Celune are expected to read and comply with any applicable license terms for the models they intend to use.
+
## Voices & samples
Each voice is demonstrated using a short introduction and a longer narration sample to showcase consistency, pacing, and expressiveness.
-### Qwen
+### Qwen3-TTS
| Voice | Intro | Narration |
|---|---|---|
@@ -52,7 +58,7 @@ Each voice is demonstrated using a short introduction and a longer narration sam
| Bold | [▶️ Play](https://gabalpha.github.io/read-audio/?p=https://raw.githubusercontent.com/celunah/celune/main/demos/bold_sc_voxcpm2.wav) | [▶️ Play](https://gabalpha.github.io/read-audio/?p=https://raw.githubusercontent.com/celunah/celune/main/demos/bold_lc_voxcpm2.wav) |
| Upbeat | [▶️ Play](https://gabalpha.github.io/read-audio/?p=https://raw.githubusercontent.com/celunah/celune/main/demos/upbeat_sc_voxcpm2.wav) | [▶️ Play](https://gabalpha.github.io/read-audio/?p=https://raw.githubusercontent.com/celunah/celune/main/demos/upbeat_lc_voxcpm2.wav) |
-### Celune Mini
+### Celune Mini (Pocket TTS)
| Voice | Intro | Narration |
|---|---|---|
@@ -115,6 +121,12 @@ The terminal should support True Color, especially when using voice packs that d
Terminals not supporting True Color may look incorrect, as Textual will fall back to a lower color mode.
+If Celune looks incorrect while your terminal supports True Color, run Celune with the following command:
+
+```bash
+COLORTERM=truecolor celune
+```
+
If Rubber Band is not installed or fails to run, Celune will speak at normal speed, and speed controls will be unavailable.
## VRAM presets & requirements
@@ -161,6 +173,8 @@ Tested on: RTX 5070 (12 GB VRAM)
## Installation
+Download and extract the [latest binary artifact](https://nightly.link/celunah/celune/workflows/ci/main) prior to running the below commands.
+
```bash
# Download Celune
git clone https://github.com/celunah/celune
@@ -188,16 +202,20 @@ uv sync
# Run
# Command Prompt users
-celune
+bin\celune
# PowerShell users
-.\celune.exe
+.\bin\celune.exe
# Or on Unix systems:
-./celune.AppImage
+./bin/celune.AppImage
```
-You can also open Celune from within your desktop by running the aforementioned executables. They are usable as an entry point.
+Don't run `celune-bin` manually. The `celune` binary is Celune's main entrypoint.
+
+Both binaries are required for correct operation, `celune-bin` contains core code, while `celune` is the outer launcher.
+
+Celune can also run from other working directories, provided the main binary is installed correctly.
### SoX & Rubber Band installation
@@ -206,13 +224,13 @@ If SoX & Rubber Band are already installed, you can skip this section.
#### Windows (Scoop)
```bat
-# Install Scoop if you don't already have it
+REM Install Scoop if you don't already have it
powershell -ExecutionPolicy RemoteSigned -c "irm https://get.scoop.sh | iex"
-# Install SoX
+REM Install SoX
scoop install sox
-# Install Rubber Band
+REM Install Rubber Band
scoop install rubberband
```
@@ -250,7 +268,7 @@ To install OpenRGB, go to , download and install a package
Celune's VoxCPM2 backend may require a C/C++ compiler to compile dependencies. To install a suitable compiler, run one of the following commands:
-This is not required to use the Qwen backend, but you may need to install dependencies manually.
+This is not required to use other backends, but you may need to install dependencies manually.
```bash
# Windows
@@ -302,33 +320,10 @@ Without this, Celune may require elevated permissions or fall back to slower beh
See [API.md](./API.md) for REST API configuration, authentication, endpoints, and cURL examples.
The API allows programmatic usage of all Celune features. It can be used both as a public and local interface.
-## Screenshots
-
-The below images showcase Celune's user interface.
-
-### Before init
-
-[](./demos/init.png)
-
-### Ready
-
-[](./demos/ready.png)
-
-### Talking
-
-[](./demos/speaking.png)
-
-### Change voice
-
-[](./demos/change_voice.png)
-
-### Commands
-
-[](./demos/commands.png)
-
-### Extension invoke
+## Web UI
-[](./demos/extensions.png)
+Celune exposes a web interface for remote access to Celune. It reuses the Celune API commands to provide an interface for control.
+It can be accessed via `/ui` on Celune's exposed API URL.
> *"Your voice, your way."*
diff --git a/celune.AppImage b/celune.AppImage
deleted file mode 100755
index f0348de..0000000
Binary files a/celune.AppImage and /dev/null differ
diff --git a/celune.exe b/celune.exe
deleted file mode 100755
index 921bdce..0000000
Binary files a/celune.exe and /dev/null differ
diff --git a/celune/__init__.py b/celune/__init__.py
index 7f9b6d9..4da7c9f 100644
--- a/celune/__init__.py
+++ b/celune/__init__.py
@@ -63,9 +63,9 @@ def _caller_is_repl() -> bool:
if REVISION:
_local = REVISION.rstrip("*")
_dirty = ".dirty" if REVISION.endswith("*") else ""
- __version__ = f"4.0.1+{_local}{_dirty}"
+ __version__ = f"4.1.0+{_local}{_dirty}"
else:
- __version__ = "4.0.1+unknown"
+ __version__ = "4.1.0+unknown"
__tagline__ = '"Your voice, your way."'
__codename__ = "Personality"
diff --git a/celune/analysis.py b/celune/analysis.py
index 388096d..0d22213 100644
--- a/celune/analysis.py
+++ b/celune/analysis.py
@@ -4,96 +4,44 @@
import pathlib
import warnings
import contextlib
-from collections.abc import Mapping
-from typing import Optional, Protocol, TypedDict, Union, cast
+from pathlib import Path
+from typing import Optional, cast
import torch
import librosa
import matplotlib
import numpy as np
import numpy.typing as npt
-from matplotlib import rcParams
from matplotlib.projections import PolarAxes
-from matplotlib import pyplot as plt
-from matplotlib import colors as mcolors
+from matplotlib import rcParams, font_manager, pyplot as plt, colors as mcolors
from transformers import AutoModel, AutoProcessor
from .cevoice import ManifestValue, default_loader
from .constants import VOICE_EMBEDDING_MODEL, N_A_NUMERIC
+from .typing.analysis import (
+ EmbeddingPayload,
+ EmbeddingModel,
+ EmbeddingProcessor,
+ TextConfig,
+ TextConfigValue,
+ VoiceMatch,
+)
matplotlib.use("Agg")
# this font is included within Celune
# check resources/fonts to find the font files
+font_path = Path(__file__).resolve().parent / "resources" / "fonts"
+if font_path.exists():
+ for font in font_path.iterdir():
+ if font.suffix.lower() in {".ttf", ".otf"}:
+ font_manager.fontManager.addfont(font)
+
rcParams["font.family"] = "Outfit Thin"
warnings.filterwarnings("ignore", category=UserWarning)
warnings.filterwarnings("ignore", category=FutureWarning)
-type TextConfigValue = Union[str, dict[str, "TextConfigValue"]]
-type TextConfig = dict[str, TextConfigValue]
-type EmbeddingPayload = Union[
- torch.Tensor,
- npt.NDArray[np.float32],
- list[float],
- Mapping[str, "EmbeddingPayload"],
-]
-
-
-class EmbeddingOutput(Protocol):
- """Speaker embedding model output used by Celune analysis."""
-
- last_hidden_state: EmbeddingPayload
-
-
-class EmbeddingProcessor(Protocol):
- """Processor callable returned by the embedding model package."""
-
- def __call__(
- self,
- y: npt.NDArray[np.float32],
- *,
- sampling_rate: int,
- ) -> Mapping[str, torch.Tensor]:
- """Prepare model inputs from a waveform."""
- raise NotImplementedError("protocol not defined")
-
-
-class EmbeddingModel(Protocol):
- """Embedding model behavior used by Celune analysis."""
-
- def eval(self) -> None:
- """Switch the model into evaluation mode.
-
- Raises:
- NotImplementedError: The protocol was called directly.
- """
- raise NotImplementedError("protocol not defined")
-
- def to(self, device: torch.device) -> torch.nn.Module:
- """Move the model to a device.
-
- Args:
- device: A device to dispatch to.
-
- Raises:
- NotImplementedError: The protocol was called directly.
- """
- raise NotImplementedError("protocol not defined")
-
- def __call__(self, **inputs: torch.Tensor) -> EmbeddingOutput:
- """Run embedding inference."""
- raise NotImplementedError("protocol not defined")
-
-
-class VoiceMatch(TypedDict):
- """Similarity score for one reference voice."""
-
- voice: str
- cosine: float
- percent: float
-
-
_EMBEDDING_MODEL: Optional[EmbeddingModel] = None
_EMBEDDING_PROCESSOR: Optional[EmbeddingProcessor] = None
diff --git a/celune/api.py b/celune/api.py
index b749d15..f92eec6 100644
--- a/celune/api.py
+++ b/celune/api.py
@@ -9,12 +9,13 @@
import datetime
import textwrap
import threading
-from pathlib import Path
-from dataclasses import dataclass
from hmac import compare_digest
+from dataclasses import dataclass
+from html import escape
from collections import defaultdict, deque
from typing import Callable, Iterator, Optional, Union
+import gradio as gr
import uvicorn
import numpy as np
import numpy.typing as npt
@@ -26,20 +27,24 @@
JSONResponse,
Response,
StreamingResponse,
- HTMLResponse,
FileResponse,
+ RedirectResponse,
)
-
from . import __version__
+from . import colors
from .celune import Celune
from .utils import format_error
+from .paths import main_window_log_path, project_root
from .dsp import _resample_audio
from .pipeline import SpeechStreamQueue
from .constants import BASE_SR, APP_NAME
+from .cevoice import default_loader
+from .ui import resources as ui_resources
+from .ui.app import CeluneUI
api = FastAPI(title=f"{APP_NAME}API")
-bound_celune: Optional["Celune"] = None
+bound_celune: Optional[Celune] = None
auth_token: Optional[str] = None
rate_limit_per_minute = 60
rate_limit_lock = threading.Lock()
@@ -48,6 +53,243 @@
speech_jobs_lock = threading.Lock()
speech_jobs: dict[str, "SpeechJob"] = {}
speech_job_ttl_seconds = 15 * 60
+webui_log_lines: deque[tuple[str, str]] = deque(maxlen=240)
+webui_status_text = "Waiting for response"
+webui_status_severity = "info"
+webui_logs_seeded = False
+webui_resource_page = 0
+webui_last_resource_advance = 0.0
+webui_last_probed_state: Optional[str] = None
+webui_input_locked = True
+webui_input_placeholder = "Please wait"
+webui_voice_locked = True
+webui_theme_style = ""
+webui_status_source = "probe"
+webui_status_updated_at = 0.0
+WEBUI_RESOURCE_ROTATE_SECONDS = 2.06
+WEBUI_POLL_INTERVAL_SECONDS = WEBUI_RESOURCE_ROTATE_SECONDS / 4
+WEBUI_STATUS_PROBE_DEBOUNCE_SECONDS = 0.9
+WEBUI_HEAD = textwrap.dedent(
+ """
+
+
+ """
+)
+
+WEBUI_CSS = textwrap.dedent(
+ """
+ @import url('https://fonts.googleapis.com/css2?family=Outfit:wght@100..900&display=swap');
+ @import url('https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@100..800&display=swap');
+
+ html,
+ body,
+ gradio-app {
+ background: var(--celune-background, #1d1826) !important;
+ }
+
+ .column {
+ place-content: center;
+ }
+
+ .gradio-container {
+ background: var(--celune-background, #1d1826);
+ font-family: Outfit, sans-serif !important;
+ height: 100dvh;
+ overflow: hidden;
+ }
+
+ .gradio-container > .main,
+ .gradio-container .wrap,
+ .gradio-container .loading-container,
+ .gradio-container .loading-container > div {
+ background: var(--celune-background, #1d1826) !important;
+ }
+
+ .main {
+ flex: 1 1 auto !important;
+ min-height: 0;
+ }
+
+ body {
+ font-family: Outfit, sans-serif;
+ }
+
+ #celune-shell {
+ display: flex;
+ flex-direction: column;
+ gap: 0.75rem;
+ height: calc(100dvh - 2rem);
+ min-height: 0;
+ }
+
+ #celune-header {
+ display: flex;
+ place-items: center;
+ }
+
+ #celune-header .line {
+ width: 100%;
+ background: var(--celune-primary, #cebaff);
+ height: 2px;
+ }
+
+ #celune-header .title {
+ font-weight: bold;
+ padding: 0 2em;
+ color: var(--celune-primary, #cebaff);
+ }
+
+ button#celune-style, button#celune-send {
+ background: var(--celune-button-bg, #3a304c);
+ color: var(--celune-primary, #cebaff);
+ border-radius: 4px;
+ }
+
+ button#celune-style:hover, button#celune-send:hover {
+ background: var(--celune-button-hover, #443a56);
+ }
+
+ #celune-log-panel {
+ border: 2px solid var(--celune-primary, #cebaff);
+ padding: 1em;
+ border-radius: 8px;
+ max-height: min(75dvh, calc(100dvh - 20rem));
+ overflow: hidden;
+ flex: 1 1 auto;
+ min-height: 0;
+ }
+
+ #celune-log-panel pre {
+ font-family: "JetBrains Mono", monospace;
+ color: var(--celune-primary, #cebaff);
+ white-space: pre-wrap;
+ margin: 0;
+ max-height: min(calc(75dvh - 2em), calc(75dvh - 15rem));
+ height: 100%;
+ overflow-y: auto;
+ padding-right: 0.75em;
+ scrollbar-gutter: stable both-edges;
+ }
+
+ #celune-input textarea {
+ background: var(--celune-input-bg, #3a304c);
+ color: var(--celune-primary, #cebaff);
+ border-radius: 4px;
+ }
+
+ #celune-input textarea::placeholder {
+ color: var(--celune-placeholder, #9c88ce);
+ }
+
+ #celune-resources .footer-block {
+ text-align: right;
+ color: var(--celune-primary, #cebaff);
+ }
+
+ .webui-desktop-only {
+ display: inline !important;
+ color: inherit;
+ }
+
+ .webui-mobile-only {
+ display: none !important;
+ color: inherit;
+ }
+
+ #celune-actions {
+ gap: 0.75rem;
+ }
+
+ button#celune-style,
+ button#celune-send {
+ min-height: 2.75rem;
+ }
+
+ #celune-input-row, #celune-footer {
+ padding: 0 1em;
+ }
+
+ button#celune-send {
+ display: none;
+ }
+
+ @media (max-width: 768px), (any-pointer: coarse), (hover: none) {
+ .gradio-container {
+ height: 100dvh;
+ overflow: hidden;
+ }
+
+ #celune-shell {
+ height: calc(100dvh - 8rem);
+ min-height: 0;
+ }
+
+ #celune-input-row {
+ flex-direction: column;
+ }
+
+ #celune-actions {
+ display: flex;
+ flex-direction: row;
+ width: 100%;
+ flex-wrap: nowrap;
+ gap: 0;
+ }
+
+ #celune-actions > * {
+ flex: 1 1 0 !important;
+ min-width: 0 !important;
+ }
+
+ button#celune-style,
+ button#celune-send {
+ width: 100%;
+ }
+
+ button#celune-send {
+ display: flex;
+ }
+
+ #celune-input textarea, #celune-input textarea::placeholder {
+ text-align: center;
+ }
+
+ #celune-log-panel {
+ max-height: min(52dvh, calc(100dvh - 12rem));
+ }
+
+ #celune-log-panel pre {
+ max-height: min(calc(52dvh - 2em), calc(100dvh - 14rem));
+ }
+
+ button#celune-style {
+ border-radius: 4px 0 0 4px;
+ border-right: 1px solid color-mix(
+ in srgb,
+ var(--celune-primary, #cebaff) 50%,
+ black
+ );
+ }
+
+ button#celune-send {
+ border-radius: 0 4px 4px 0;
+ border-left: 1px solid color-mix(
+ in srgb,
+ var(--celune-primary, #cebaff) 50%,
+ black
+ );
+ }
+
+ .webui-desktop-only {
+ display: none !important;
+ }
+
+ .webui-mobile-only {
+ display: inline !important;
+ }
+ }
+ """
+)
@dataclass
@@ -60,6 +302,56 @@ class SpeechJob:
error: Optional[str] = None
+def _configure_webui_theme() -> None:
+ """Sync the browser UI palette with the active CEVOICE-derived theme."""
+ global webui_theme_style
+
+ colors.configure_theme()
+ loader = default_loader()
+ if loader is not None:
+ theme = loader.bundle.metadata.get("theme")
+ if isinstance(theme, dict):
+ background = theme.get("background")
+ accent = theme.get("accent")
+ faded_accent = theme.get("faded_accent")
+ if faded_accent is None:
+ faded_accent = theme.get("sleeping_color")
+ if (
+ isinstance(background, str)
+ and isinstance(accent, str)
+ and (faded_accent is None or isinstance(faded_accent, str))
+ ):
+ colors.configure_theme(background, accent, faded_accent)
+
+ background = colors.THEME.background or "#1d1826"
+ palette = colors.SEVERITY_COLORS["celune"]
+ primary = palette["info"]
+ foreground = colors.THEME.foreground or "#ffffff"
+ secondary = colors.THEME.secondary or primary
+ accent = colors.THEME.accent or primary
+ sleeping = palette["sleeping"]
+ button_bg = colors._blend(primary, background, 0.72)
+ button_hover = colors._blend(primary, background, 0.6)
+ input_bg = colors._blend(primary, background, 0.78)
+
+ webui_theme_style = (
+ ""
+ )
+
+
class StartedServer(uvicorn.Server):
"""Uvicorn server that reports when socket binding actually succeeds."""
@@ -148,6 +440,12 @@ def _authenticated(request: Request) -> bool:
return given is not None and compare_digest(given, auth_token)
+def _is_browser_ui_request(request: Request) -> bool:
+ """Return whether the request targets the mounted browser UI."""
+ path = request.url.path.rstrip("/")
+ return path == "/ui" or path.startswith("/ui/")
+
+
def _rate_limit_key(request: Request) -> str:
"""Return the client key used for rate limiting."""
if request.client is None:
@@ -190,6 +488,9 @@ async def api_security(
Returns:
Response: The response returned by the protected route or security layer.
"""
+ if _is_browser_ui_request(request):
+ return await call_next(request)
+
if not _authenticated(request):
return JSONResponse(
status_code=401,
@@ -227,6 +528,208 @@ def bind_celune(celune: Celune) -> None:
"""
global bound_celune
bound_celune = celune
+ global webui_resource_page, webui_last_resource_advance, webui_last_probed_state
+ global webui_input_locked, webui_input_placeholder, webui_voice_locked
+ webui_resource_page = 0
+ webui_last_resource_advance = 0.0
+ webui_last_probed_state = None
+ _configure_webui_theme()
+ webui_input_locked = celune.locked
+ webui_input_placeholder = (
+ "Currently in tutorial mode"
+ if celune.is_in_tutorial
+ else "Please wait"
+ if celune and celune.locked
+ else "Enter text to speak here"
+ )
+ webui_voice_locked = len(celune.voices) < 2 or celune.is_in_tutorial
+ _seed_webui_logs()
+ _wrap_celune_callbacks(celune)
+ if celune.current_voice:
+ _append_webui_log(f"Voice ready: {celune.current_voice}.")
+ _set_webui_status(
+ "Idle" if celune.cur_state == "idle" else celune.cur_state.title(),
+ source="probe",
+ )
+
+
+def _webui_status_color(severity: str) -> str:
+ """Return the browser UI color for a given severity."""
+ palette = colors.SEVERITY_COLORS.get("celune", colors.SEVERITY_COLORS["celune"])
+ return palette.get(severity, palette["info"])
+
+
+def _webui_log_line_html(message: str, severity: str = "info") -> str:
+ """Render one browser log line with severity-aware coloring."""
+ color = _webui_status_color(severity)
+ return f'{escape(message)}'
+
+
+def _strip_webui_log_prefix(line: str) -> str:
+ """Remove persisted timestamp and severity prefixes from one log line."""
+ stripped = line.strip()
+ if stripped.startswith("[") and "] " in stripped:
+ stripped = stripped.split("] ", 1)[1]
+ if stripped.startswith("[") and "] " in stripped:
+ stripped = stripped.split("] ", 1)[1]
+ return stripped
+
+
+def _seed_webui_logs() -> None:
+ """Populate the browser log view from the persisted desktop log when available."""
+ global webui_logs_seeded
+ if webui_logs_seeded:
+ return
+
+ webui_logs_seeded = True
+ path = main_window_log_path()
+ if not path.exists():
+ return
+
+ try:
+ lines = path.read_text(encoding="utf-8").splitlines()[-180:]
+ except OSError:
+ return
+
+ for line in lines:
+ lowered = line.lower()
+ severity = "info"
+ if "[warning]" in lowered:
+ severity = "warning"
+ elif "[error]" in lowered:
+ severity = "error"
+ webui_log_lines.append((_strip_webui_log_prefix(line), severity))
+
+
+def _append_webui_log(msg: str, severity: str = "info") -> None:
+ """Store one browser log line."""
+ webui_log_lines.append((msg, severity))
+
+
+def _set_webui_status(
+ msg: str,
+ severity: str = "info",
+ *,
+ source: str = "callback",
+ updated_at: Optional[float] = None,
+) -> None:
+ """Update the browser UI status line."""
+ global webui_status_text, webui_status_severity
+ global webui_status_source, webui_status_updated_at
+ webui_status_text = msg
+ webui_status_severity = severity
+ webui_status_source = source
+ webui_status_updated_at = time.monotonic() if updated_at is None else updated_at
+
+
+def _probed_status_text(celune: Celune) -> tuple[str, str]:
+ """Return the best-effort footer status derived from Celune's live state."""
+ state = (celune.cur_state or "").strip().lower()
+ return {
+ "idle": ("Idle", "info"),
+ "speaking": ("Speaking", "info"),
+ "thinking": ("Thinking", "info"),
+ "waking": ("Waking up", "info"),
+ "reloading": ("Reloading", "info"),
+ "sleeping": ("Sleeping", "sleeping"),
+ "init": ("Initializing", "info"),
+ "generating": ("Generating", "info"),
+ "error": (f"{APP_NAME} could not continue", "error"),
+ }.get(state, (state.title() if state else "Initializing", "info"))
+
+
+def _probe_webui_runtime() -> None:
+ """Poll the live runtime so the WebUI footer updates even without new log lines."""
+ global webui_last_probed_state, webui_resource_page, webui_last_resource_advance
+
+ celune = bound_celune
+ if celune is None:
+ return
+
+ now = time.monotonic()
+ current_state = (celune.cur_state or "").strip().lower()
+ if current_state != webui_last_probed_state:
+ if current_state == "sleeping":
+ _append_webui_log(
+ f"{APP_NAME} is currently sleeping. Type anything to wake up.",
+ "sleeping",
+ )
+ status_text, severity = _probed_status_text(celune)
+ should_override_status = (
+ webui_last_probed_state is None
+ or webui_status_text == "Starting up"
+ or webui_status_source != "callback"
+ or now - webui_status_updated_at >= WEBUI_STATUS_PROBE_DEBOUNCE_SECONDS
+ or current_state in {"idle", "sleeping", "error"}
+ )
+ if should_override_status:
+ _set_webui_status(
+ status_text,
+ severity,
+ source="probe",
+ updated_at=now,
+ )
+ webui_last_probed_state = current_state
+
+ pages = ui_resources.resource_pages(celune, "celune")
+ if not pages:
+ return
+
+ if webui_last_resource_advance <= 0:
+ webui_last_resource_advance = now
+ return
+
+ if now - webui_last_resource_advance >= WEBUI_RESOURCE_ROTATE_SECONDS:
+ webui_resource_page = (webui_resource_page + 1) % len(pages)
+ webui_last_resource_advance = now
+
+
+def _wrap_celune_callbacks(celune: Celune) -> None:
+ """Mirror Celune callbacks into browser UI state without replacing existing handlers."""
+ if getattr(celune, "_webui_callbacks_wrapped", False):
+ return
+
+ original_log = celune.log_callback
+ original_status = celune.status_callback
+ original_voice_changed = celune.voice_changed_callback
+ original_input_state = celune.change_input_state_callback
+ original_voice_lock_state = celune.change_voice_lock_state_callback
+
+ def wrapped_log(msg: str, severity: str = "info") -> None:
+ _append_webui_log(msg, severity)
+ original_log(msg, severity)
+
+ def wrapped_status(msg: str, severity: str = "info") -> None:
+ _set_webui_status(msg, severity, source="callback")
+ original_status(msg, severity)
+
+ def wrapped_voice_changed(name: str) -> None:
+ _append_webui_log(f"Voice changed to {name}.")
+ original_voice_changed(name)
+
+ def wrapped_input_state(locked: bool) -> None:
+ global webui_input_locked, webui_input_placeholder
+ webui_input_locked = locked
+ webui_input_placeholder = (
+ "Currently in tutorial mode"
+ if celune.is_in_tutorial
+ else "Please wait"
+ if celune and locked
+ else "Enter text to speak here"
+ )
+ original_input_state(locked)
+
+ def wrapped_voice_lock_state(locked: bool) -> None:
+ global webui_voice_locked
+ webui_voice_locked = locked
+ original_voice_lock_state(locked)
+
+ celune.log_callback = wrapped_log
+ celune.status_callback = wrapped_status
+ celune.voice_changed_callback = wrapped_voice_changed
+ celune.change_input_state_callback = wrapped_input_state
+ celune.change_voice_lock_state_callback = wrapped_voice_lock_state
+ setattr(celune, "_webui_callbacks_wrapped", True)
def require_celune() -> Celune:
@@ -258,7 +761,12 @@ def api_log(action: str, content: str, suffix: str = "") -> None:
preview = content.replace("\n", "\\n").replace("\r", "\\r")[:64]
if len(content) > 64:
preview += "..."
- print(f"[{timestamp}] {action} {preview!r}{suffix}", flush=True)
+ _append_webui_log(f"{action} {preview!r}{suffix}")
+ try:
+ print(f"[{timestamp}] {action} {preview!r}{suffix}", flush=True)
+ except ValueError:
+ # Some embedded launch paths can close stdout while the WebUI stays alive.
+ pass
def _normalized_audio(audio: npt.NDArray[np.float32]) -> npt.NDArray[np.float32]:
@@ -311,6 +819,23 @@ def audio_bytes(chunks: SpeechStreamQueue) -> Iterator[bytes]:
yield _flac_bytes(np.empty((0, 2), dtype=np.float32))
+def _webui_audio_array(chunks: SpeechStreamQueue) -> npt.NDArray[np.float32]:
+ """Collect queued audio into a frame-major float32 array for Gradio playback."""
+ audio_chunks: list[npt.NDArray[np.float32]] = []
+ while True:
+ item = chunks.get()
+ if item is None:
+ break
+ if isinstance(item, Exception):
+ raise item
+ audio_chunks.append(_normalized_audio(item))
+
+ if not audio_chunks:
+ return np.empty((0, 2), dtype=np.float32)
+
+ return np.concatenate(audio_chunks)
+
+
def stream_headers() -> dict[str, str]:
"""Return headers describing the FLAC response.
@@ -386,6 +911,424 @@ def _collect_speech_job(job_id: str, chunks: SpeechStreamQueue) -> None:
_update_speech_job(job_id, status="completed", audio=audio)
+def _webui_logs_html() -> str:
+ """Render the mirrored log buffer as terminal-like HTML."""
+ if not webui_log_lines:
+ content = _webui_log_line_html("Waiting for response...")
+ else:
+ content = "\n".join(
+ _webui_log_line_html(line, severity) for line, severity in webui_log_lines
+ )
+ return f''
+
+
+def _webui_status_html() -> str:
+ """Render the footer status cell."""
+ color = _webui_status_color(webui_status_severity)
+ return (
+ ''
+ )
+
+
+def _webui_resources_html() -> str:
+ """Render the footer resource cell."""
+ celune = bound_celune
+ resource = ""
+ if celune is not None:
+ pages = ui_resources.resource_pages(celune, "celune")
+ if pages:
+ resource = pages[webui_resource_page % len(pages)]
+ if "CTRL+" in resource:
+ return (
+ '"
+ )
+ return f''
+
+
+def _voice_button_update() -> dict[str, object]:
+ """Return the current browser voice-button state."""
+ celune = bound_celune
+ if celune is None:
+ return gr.update(value="Loading", interactive=False)
+
+ voice_name = celune.current_voice or (
+ celune.voices[0] if celune.voices else "Voice"
+ )
+ interactive = (
+ not webui_voice_locked
+ if getattr(celune, "_webui_callbacks_wrapped", False)
+ else len(celune.voices) >= 2 and not celune.is_in_tutorial
+ )
+ return gr.update(
+ value=voice_name.capitalize(),
+ interactive=interactive,
+ )
+
+
+_WEBUI_UNSET = object()
+
+
+def _input_update(value: object = _WEBUI_UNSET) -> dict[str, object]:
+ """Return the current browser input state."""
+ has_value = value is not _WEBUI_UNSET
+ celune = bound_celune
+ if celune is None:
+ if has_value:
+ return gr.update(
+ value=value,
+ interactive=False,
+ placeholder="Please wait",
+ )
+ return gr.update(
+ interactive=False,
+ placeholder="Please wait",
+ )
+ if celune.is_in_tutorial:
+ if has_value:
+ return gr.update(
+ value=value,
+ interactive=False,
+ placeholder="Currently in tutorial mode",
+ )
+ return gr.update(
+ interactive=False,
+ placeholder="Currently in tutorial mode",
+ )
+ if getattr(celune, "_webui_callbacks_wrapped", False):
+ interactive = not webui_input_locked
+ placeholder = webui_input_placeholder
+ else:
+ interactive = not celune.locked
+ placeholder = (
+ "Please wait" if celune and celune.locked else "Enter text to speak here"
+ )
+ if has_value:
+ return gr.update(
+ value=value,
+ interactive=interactive,
+ placeholder=placeholder,
+ )
+ return gr.update(
+ interactive=interactive,
+ placeholder=placeholder,
+ )
+
+
+def _send_button_update() -> dict[str, object]:
+ """Return the current browser send-button state."""
+ celune = bound_celune
+ if celune is None:
+ return gr.update(interactive=False)
+ interactive = (
+ not webui_input_locked
+ if getattr(celune, "_webui_callbacks_wrapped", False)
+ else not celune.is_in_tutorial and not celune.locked
+ )
+ return gr.update(interactive=interactive)
+
+
+def _webui_snapshot() -> tuple[
+ str,
+ str,
+ str,
+ dict[str, object],
+ dict[str, object],
+ dict[str, object],
+]:
+ """Return the current browser UI snapshot."""
+ _seed_webui_logs()
+ _probe_webui_runtime()
+ return (
+ _webui_logs_html(),
+ _webui_status_html(),
+ _webui_resources_html(),
+ _voice_button_update(),
+ _send_button_update(),
+ _input_update(),
+ )
+
+
+def _webui_submit_snapshot(
+ input_value: Optional[str],
+) -> tuple[
+ dict[str, object],
+ str,
+ str,
+ str,
+ dict[str, object],
+ dict[str, object],
+]:
+ """Return a browser snapshot shaped for submit/click handlers."""
+ logs_html, status_html, resources_html, voice_update, send_update, _input = (
+ _webui_snapshot()
+ )
+ return (
+ _input_update(input_value),
+ logs_html,
+ status_html,
+ resources_html,
+ voice_update,
+ send_update,
+ )
+
+
+def _webui_run_command(text: str) -> bool:
+ """Run one slash command through the main UI command path when available."""
+ ui = CeluneUI._instance
+ if ui is None:
+ _append_webui_log(
+ f"{APP_NAME} must be running to run commands.",
+ "warning",
+ )
+ return False
+
+ try:
+ parts = CeluneUI._split_command_input(text[1:])
+ except ValueError as e:
+ _append_webui_log(f"Command parsing error: {e}", "error")
+ return False
+
+ if not parts:
+ return False
+
+ command = parts[0].lower()
+ command_args = parts[1:]
+ ui.call_from_thread(ui.process_command, command, command_args)
+ return True
+
+
+def _webui_speak(
+ content: str,
+) -> Iterator[
+ tuple[
+ dict[str, object],
+ object,
+ str,
+ str,
+ str,
+ dict[str, object],
+ dict[str, object],
+ ]
+]:
+ """Speak text through the browser UI and return browser audio playback."""
+ text = content.strip()
+ if not text:
+ snapshot = _webui_submit_snapshot("")
+ yield snapshot[0], None, *snapshot[1:]
+ return
+
+ if text.startswith("/"):
+ _webui_run_command(text)
+ snapshot = _webui_submit_snapshot("")
+ yield snapshot[0], None, *snapshot[1:]
+ return
+
+ celune = require_celune()
+ api_log("SPEAK(WEBUI)", text)
+
+ current_state = (celune.cur_state or "").strip().lower()
+ if current_state == "waking":
+ _append_webui_log(
+ f"{APP_NAME} has not yet returned from sleep mode.", "warning"
+ )
+ snapshot = _webui_submit_snapshot(text)
+ yield snapshot[0], None, *snapshot[1:]
+ return
+
+ if getattr(celune, "sleeping", False):
+ _set_webui_status("Waking up")
+ snapshot = _webui_submit_snapshot(text)
+ yield snapshot[0], None, *snapshot[1:]
+ if not celune.wake_from_sleep():
+ snapshot = _webui_submit_snapshot(text)
+ yield snapshot[0], None, *snapshot[1:]
+ return
+
+ chunks = celune.say_stream(text, save=True)
+ if chunks is None:
+ _append_webui_log("I'm currently busy. Try again later.", "warning")
+ snapshot = _webui_submit_snapshot(text)
+ yield snapshot[0], None, *snapshot[1:]
+ return
+
+ snapshot = _webui_submit_snapshot("")
+ yield snapshot[0], None, *snapshot[1:]
+
+ audio_chunks: list[npt.NDArray[np.float32]] = []
+
+ try:
+ while True:
+ item = chunks.get()
+ if item is None:
+ break
+ if isinstance(item, Exception):
+ raise item
+
+ audio_chunks.append(_normalized_audio(item))
+ audio_value: object
+ if audio_chunks:
+ audio_value = (BASE_SR, np.concatenate(audio_chunks))
+ else:
+ audio_value = None
+ snapshot = _webui_submit_snapshot("")
+ yield snapshot[0], audio_value, *snapshot[1:]
+ except Exception as e:
+ _append_webui_log(
+ f"[WEBUI ERROR] {format_error(e, celune.dev)}",
+ "error",
+ )
+ snapshot = _webui_submit_snapshot("")
+ yield snapshot[0], None, *snapshot[1:]
+
+
+def _webui_cycle_voice() -> tuple[
+ str,
+ str,
+ str,
+ dict[str, object],
+ dict[str, object],
+ dict[str, object],
+]:
+ """Cycle to the next available Celune voice from the browser UI."""
+ celune = require_celune()
+ if len(celune.voices) < 2:
+ return _webui_snapshot()
+
+ current_voice = celune.current_voice or celune.voices[0]
+ current_index = (
+ celune.voices.index(current_voice) if current_voice in celune.voices else -1
+ )
+ next_voice = celune.voices[(current_index + 1) % len(celune.voices)]
+ api_log("VOICE(WEBUI)", next_voice)
+
+ if not celune.set_voice_and_wait(next_voice):
+ _append_webui_log("I can't change my voice right now.", "error")
+
+ return _webui_snapshot()
+
+
+def _build_webui() -> gr.Blocks:
+ """Create the browser UI mounted by the API."""
+ _configure_webui_theme()
+ with gr.Blocks(
+ title=APP_NAME,
+ fill_height=True,
+ ) as demo:
+ gr.HTML(webui_theme_style)
+ with gr.Column(elem_id="celune-shell"):
+ gr.HTML(
+ textwrap.dedent(
+ f"""
+
+ """
+ )
+ )
+ logs = gr.HTML(_webui_logs_html())
+ with gr.Row(elem_id="celune-input-row"):
+ input_box = gr.Textbox(
+ value="",
+ lines=1,
+ max_lines=4,
+ show_label=False,
+ placeholder="Please wait",
+ container=False,
+ elem_id="celune-input",
+ scale=8,
+ interactive=False,
+ )
+ with gr.Row(elem_id="celune-actions", scale=2):
+ voice_button = gr.Button(
+ value="Balanced",
+ elem_id="celune-style",
+ scale=1,
+ min_width=0,
+ interactive=False,
+ )
+ send_button = gr.Button(
+ value="Send",
+ elem_id="celune-send",
+ scale=1,
+ min_width=0,
+ interactive=False,
+ )
+ with gr.Row(elem_id="celune-footer"):
+ status = gr.HTML(_webui_status_html(), elem_id="celune-status")
+ resources = gr.HTML(
+ _webui_resources_html(),
+ elem_id="celune-resources",
+ )
+ gr.HTML(
+ textwrap.dedent(f"""
+
+ Usage may differ. Some {APP_NAME} features may not be available.
+
+ """)
+ )
+ audio = gr.Audio(
+ value=None,
+ type="numpy",
+ autoplay=True,
+ show_label=False,
+ interactive=False,
+ visible="hidden",
+ elem_id="celune-audio",
+ )
+ timer = gr.Timer(value=WEBUI_POLL_INTERVAL_SECONDS)
+ timer.tick( # pylint: disable=E1101
+ _webui_snapshot,
+ outputs=[logs, status, resources, voice_button, send_button, input_box],
+ show_progress="hidden",
+ )
+ demo.load( # pylint: disable=E1101
+ _webui_snapshot,
+ outputs=[logs, status, resources, voice_button, send_button, input_box],
+ show_progress="hidden",
+ )
+ input_box.submit( # pylint: disable=E1101
+ _webui_speak,
+ inputs=[input_box],
+ outputs=[
+ input_box,
+ audio,
+ logs,
+ status,
+ resources,
+ voice_button,
+ send_button,
+ ],
+ show_progress="hidden",
+ )
+ send_button.click( # pylint: disable=E1101
+ _webui_speak,
+ inputs=[input_box],
+ outputs=[
+ input_box,
+ audio,
+ logs,
+ status,
+ resources,
+ voice_button,
+ send_button,
+ ],
+ show_progress="hidden",
+ )
+ voice_button.click( # pylint: disable=E1101
+ _webui_cycle_voice,
+ outputs=[logs, status, resources, voice_button, send_button, input_box],
+ show_progress="hidden",
+ )
+
+ return demo
+
+
class RootResponse(BaseModel):
"""Response returned by the API root endpoint."""
@@ -432,70 +1375,19 @@ def favicon() -> FileResponse:
"""
return FileResponse(
- # this is a symbolic link to the in Celune.AppDir/
- Path(__file__).parents[1] / "resources" / "branding" / "celune.png",
- media_type="image/png",
+ project_root() / "resources" / "celune.ico",
+ media_type="image/x-icon",
)
-@api.get("/")
-def root() -> HTMLResponse:
- """Root page.
+@api.get("/", include_in_schema=False)
+def root() -> RedirectResponse:
+ """Redirect the API root to Celune's browser UI.
Returns:
- HTMLResponse: The app root page as HTML.
+ RedirectResponse: Redirect response pointing at the mounted WebUI.
"""
-
- return HTMLResponse(
- textwrap.dedent(
- f"""
-
-
-
- {APP_NAME}
-
-
-
-
-
-
Nothing Usable
-
The API is functioning correctly. Please return to the app to talk to me.
-