thaloco/aman
1
Fork 0
Code Pull requests Releases Packages Activity Actions

Normalize native dependency ownership and split config UI
Some checks failed
ci / Unit Matrix (3.10) (push) Has been cancelled
Details
ci / Unit Matrix (3.11) (push) Has been cancelled
Details
ci / Unit Matrix (3.12) (push) Has been cancelled
Details
ci / Portable Ubuntu Smoke (push) Has been cancelled
Details
ci / Package Artifacts (push) Has been cancelled
Details

Browse source 
Make distro packages the single source of truth for GTK/X11 Python bindings instead of advertising them as wheel-managed runtime dependencies. Update the uv, CI, and packaging workflows to use system site packages, regenerate uv.lock, and keep portable and Arch metadata aligned with that contract.

Pull runtime policy, audio probing, and page builders out of config_ui.py so the settings window becomes a coordinator instead of a single large mixed-concern module. Rename the config serialization and logging helpers, and stop startup logging from exposing raw vocabulary entries or custom model paths.

Remove stale helper aliases and add regression coverage for safe startup logging, packaging metadata and module drift, portable requirements, and the extracted audio helper behavior.

Validated with uv lock, python3 -m compileall -q src tests, python3 -m unittest discover -s tests -p 'test_*.py', make build, and make package-arch.
This commit is contained in:
Thales Maciel 2026-03-15 11:27:54 -03:00
parent f779b71e1b
commit c6fc61c885
No known key found for this signature in database
GPG key ID: 33112E6833C34679
23 changed files with 617 additions and 437 deletions
Download patch file Download diff file Expand all files Collapse all files

6
.github/workflows/ci.yml vendored
View file

@ -33,7 +33,7 @@ jobs:
libayatana-appindicator3-1 libayatana-appindicator3-1
- name: Create project environment - name: Create project environment
run: | run: |
python -m venv .venv python -m venv --system-site-packages .venv
. .venv/bin/activate . .venv/bin/activate
python -m pip install --upgrade pip python -m pip install --upgrade pip
python -m pip install uv build python -m pip install uv build
@ -69,7 +69,7 @@ jobs:
xvfb xvfb
- name: Create project environment - name: Create project environment
run: | run: |
python -m venv .venv python -m venv --system-site-packages .venv
. .venv/bin/activate . .venv/bin/activate
python -m pip install --upgrade pip python -m pip install --upgrade pip
python -m pip install uv build python -m pip install uv build
@ -113,7 +113,7 @@ jobs:
libayatana-appindicator3-1 libayatana-appindicator3-1
- name: Create project environment - name: Create project environment
run: | run: |
python -m venv .venv python -m venv --system-site-packages .venv
. .venv/bin/activate . .venv/bin/activate
python -m pip install --upgrade pip python -m pip install --upgrade pip
python -m pip install uv build python -m pip install uv build

3
AGENTS.md
View file

@ -15,12 +15,13 @@
## Build, Test, and Development Commands ## Build, Test, and Development Commands
- Install deps (X11): `uv sync`. - Install deps (X11): `python3 -m venv --system-site-packages .venv && . .venv/bin/activate && uv sync --active`.
- Run daemon: `uv run aman run --config ~/.config/aman/config.json`. - Run daemon: `uv run aman run --config ~/.config/aman/config.json`.
System packages (example names): System packages (example names):
- Core: `portaudio`/`libportaudio2`. - Core: `portaudio`/`libportaudio2`.
- GTK/X11 Python bindings: distro packages such as `python3-gi` / `python3-xlib`.
- X11 tray: `libayatana-appindicator3`. - X11 tray: `libayatana-appindicator3`.
## Coding Style & Naming Conventions ## Coding Style & Naming Conventions

6
Makefile
View file

@ -47,7 +47,11 @@ check-default-model:
uv run aman-maint sync-default-model --check --report $(EVAL_OUTPUT) --artifacts $(MODEL_ARTIFACTS) --constants $(CONSTANTS_FILE) uv run aman-maint sync-default-model --check --report $(EVAL_OUTPUT) --artifacts $(MODEL_ARTIFACTS) --constants $(CONSTANTS_FILE)
sync: sync:
uv sync @if [ ! -f .venv/pyvenv.cfg ] || ! grep -q '^include-system-site-packages = true' .venv/pyvenv.cfg; then \
rm -rf .venv; \
$(PYTHON) -m venv --system-site-packages .venv; \
fi
UV_PROJECT_ENVIRONMENT=$(CURDIR)/.venv uv sync
test: test:
$(PYTHON) -m unittest discover -s tests -p 'test_*.py' $(PYTHON) -m unittest discover -s tests -p 'test_*.py'

7
docs/developer-workflows.md
View file

@ -36,10 +36,15 @@ For `1.0.0`, the manual publication target is the forge release page at
`uv` workflow: `uv` workflow:
```bash ```bash
uv sync python3 -m venv --system-site-packages .venv
. .venv/bin/activate
uv sync --active
uv run aman run --config ~/.config/aman/config.json uv run aman run --config ~/.config/aman/config.json
``` ```
Install the documented distro runtime dependencies first so the active virtualenv
can see GTK/AppIndicator/X11 bindings from the system Python.
`pip` workflow: `pip` workflow:
```bash ```bash

20
packaging/arch/PKGBUILD.in
View file

@ -15,22 +15,16 @@ prepare() {
cd "${srcdir}/aman-${pkgver}" cd "${srcdir}/aman-${pkgver}"
python -m build --wheel python -m build --wheel
python - <<'PY' python - <<'PY'
import ast
from pathlib import Path from pathlib import Path
import re import re
import tomllib
project = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8")) text = Path("pyproject.toml").read_text(encoding="utf-8")
exclude = {"pygobject", "python-xlib"} match = re.search(r"(?ms)^\s*dependencies\s*=\s*\[(.*?)^\s*\]", text)
dependencies = project.get("project", {}).get("dependencies", []) if not match:
filtered = [] raise SystemExit("project dependencies not found in pyproject.toml")
for dependency in dependencies: dependencies = ast.literal_eval("[" + match.group(1) + "]")
match = re.match(r"\s*([A-Za-z0-9_.-]+)", dependency) filtered = [dependency.strip() for dependency in dependencies]
if not match:
continue
name = match.group(1).lower().replace("_", "-")
if name in exclude:
continue
filtered.append(dependency.strip())
Path("dist/runtime-requirements.txt").write_text("\n".join(filtered) + "\n", encoding="utf-8") Path("dist/runtime-requirements.txt").write_text("\n".join(filtered) + "\n", encoding="utf-8")
PY PY
} }

5
pyproject.toml
View file

@ -28,8 +28,6 @@ dependencies = [
"faster-whisper", "faster-whisper",
"llama-cpp-python", "llama-cpp-python",
"numpy", "numpy",
"PyGObject",
"python-xlib",
"sounddevice", "sounddevice",
] ]
@ -58,6 +56,9 @@ py-modules = [
"aman_runtime", "aman_runtime",
"config", "config",
"config_ui", "config_ui",
"config_ui_audio",
"config_ui_pages",
"config_ui_runtime",
"constants", "constants",
"desktop", "desktop",
"desktop_x11", "desktop_x11",

20
scripts/package_common.sh
View file

@ -93,24 +93,18 @@ write_runtime_requirements() {
local output_path="$1" local output_path="$1"
require_command python3 require_command python3
python3 - "${output_path}" <<'PY' python3 - "${output_path}" <<'PY'
import ast
from pathlib import Path from pathlib import Path
import re import re
import sys import sys
import tomllib
output_path = Path(sys.argv[1]) output_path = Path(sys.argv[1])
exclude = {"pygobject", "python-xlib"} text = Path("pyproject.toml").read_text(encoding="utf-8")
project = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8")) match = re.search(r"(?ms)^\s*dependencies\s*=\s*\[(.*?)^\s*\]", text)
dependencies = project.get("project", {}).get("dependencies", []) if not match:
filtered = [] raise SystemExit("project dependencies not found in pyproject.toml")
for dependency in dependencies: dependencies = ast.literal_eval("[" + match.group(1) + "]")
match = re.match(r"\s*([A-Za-z0-9_.-]+)", dependency) filtered = [dependency.strip() for dependency in dependencies]
if not match:
continue
name = match.group(1).lower().replace("_", "-")
if name in exclude:
continue
filtered.append(dependency.strip())
output_path.parent.mkdir(parents=True, exist_ok=True) output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text("\n".join(filtered) + "\n", encoding="utf-8") output_path.write_text("\n".join(filtered) + "\n", encoding="utf-8")
PY PY

5
scripts/package_portable.sh
View file

@ -49,21 +49,16 @@ export_requirements() {
--python "${python_version}" >"${raw_path}" --python "${python_version}" >"${raw_path}"
python3 - "${raw_path}" "${output_path}" <<'PY' python3 - "${raw_path}" "${output_path}" <<'PY'
from pathlib import Path from pathlib import Path
import re
import sys import sys
raw_path = Path(sys.argv[1]) raw_path = Path(sys.argv[1])
output_path = Path(sys.argv[2]) output_path = Path(sys.argv[2])
lines = raw_path.read_text(encoding="utf-8").splitlines() lines = raw_path.read_text(encoding="utf-8").splitlines()
exclude = {"pygobject", "python-xlib"}
filtered = [] filtered = []
for line in lines: for line in lines:
stripped = line.strip() stripped = line.strip()
if not stripped or stripped == ".": if not stripped or stripped == ".":
continue continue
match = re.match(r"([A-Za-z0-9_.-]+)", stripped)
if match and match.group(1).lower().replace("_", "-") in exclude:
continue
filtered.append(line) filtered.append(line)
output_path.write_text("\n".join(filtered) + "\n", encoding="utf-8") output_path.write_text("\n".join(filtered) + "\n", encoding="utf-8")
raw_path.unlink() raw_path.unlink()

11
src/aman_run.py
View file

@ -8,7 +8,14 @@ import signal
import threading import threading
from pathlib import Path from pathlib import Path
from config import Config, ConfigValidationError, load, redacted_dict, save, validate from config import (
Config,
ConfigValidationError,
config_log_payload,
load,
save,
validate,
)
from constants import DEFAULT_CONFIG_PATH, MODEL_PATH from constants import DEFAULT_CONFIG_PATH, MODEL_PATH
from desktop import get_desktop_adapter from desktop import get_desktop_adapter
from diagnostics import ( from diagnostics import (
@ -232,7 +239,7 @@ def run_command(args) -> int:
logging.info( logging.info(
"config (%s):\n%s", "config (%s):\n%s",
str(config_path), str(config_path),
json.dumps(redacted_dict(cfg), indent=2), json.dumps(config_log_payload(cfg), indent=2),
) )
if not config_existed_before_start: if not config_existed_before_start:
logging.info("first launch settings completed") logging.info("first launch settings completed")

26
src/config.py
View file

@ -152,13 +152,35 @@ def save(path: str | Path | None, cfg: Config) -> Path:
return target return target
def redacted_dict(cfg: Config) -> dict[str, Any]: def config_as_dict(cfg: Config) -> dict[str, Any]:
return asdict(cfg) return asdict(cfg)
def config_log_payload(cfg: Config) -> dict[str, Any]:
return {
"daemon_hotkey": cfg.daemon.hotkey,
"recording_input": cfg.recording.input,
"stt_provider": cfg.stt.provider,
"stt_model": cfg.stt.model,
"stt_device": cfg.stt.device,
"stt_language": cfg.stt.language,
"custom_whisper_path_configured": bool(
cfg.models.whisper_model_path.strip()
),
"injection_backend": cfg.injection.backend,
"remove_transcription_from_clipboard": (
cfg.injection.remove_transcription_from_clipboard
),
"safety_enabled": cfg.safety.enabled,
"safety_strict": cfg.safety.strict,
"ux_profile": cfg.ux.profile,
"strict_startup": cfg.advanced.strict_startup,
}
def _write_default_config(path: Path, cfg: Config) -> None: def _write_default_config(path: Path, cfg: Config) -> None:
path.parent.mkdir(parents=True, exist_ok=True) path.parent.mkdir(parents=True, exist_ok=True)
path.write_text(f"{json.dumps(redacted_dict(cfg), indent=2)}\n", encoding="utf-8") path.write_text(f"{json.dumps(config_as_dict(cfg), indent=2)}\n", encoding="utf-8")
def validate(cfg: Config) -> None: def validate(cfg: Config) -> None:

322
src/config_ui.py
View file

@ -3,29 +3,34 @@ from __future__ import annotations
import copy import copy
import importlib.metadata import importlib.metadata
import logging import logging
import time
from dataclasses import dataclass from dataclasses import dataclass
from pathlib import Path from pathlib import Path
import gi import gi
from config import ( from config import Config, DEFAULT_STT_PROVIDER
Config, from config_ui_audio import AudioSettingsService
DEFAULT_STT_PROVIDER, from config_ui_pages import (
build_about_page,
build_advanced_page,
build_audio_page,
build_general_page,
build_help_page,
)
from config_ui_runtime import (
RUNTIME_MODE_EXPERT,
RUNTIME_MODE_MANAGED,
apply_canonical_runtime_defaults,
infer_runtime_mode,
) )
from constants import DEFAULT_CONFIG_PATH from constants import DEFAULT_CONFIG_PATH
from languages import COMMON_STT_LANGUAGE_OPTIONS, stt_language_label from languages import stt_language_label
from recorder import list_input_devices, resolve_input_device, start_recording, stop_recording
gi.require_version("Gdk", "3.0") gi.require_version("Gdk", "3.0")
gi.require_version("Gtk", "3.0") gi.require_version("Gtk", "3.0")
from gi.repository import Gdk, Gtk # type: ignore[import-not-found] from gi.repository import Gdk, Gtk # type: ignore[import-not-found]
RUNTIME_MODE_MANAGED = "aman_managed"
RUNTIME_MODE_EXPERT = "expert_custom"
@dataclass @dataclass
class ConfigUiResult: class ConfigUiResult:
saved: bool saved: bool
@ -33,21 +38,6 @@ class ConfigUiResult:
closed_reason: str | None = None closed_reason: str | None = None
def infer_runtime_mode(cfg: Config) -> str:
is_canonical = (
cfg.stt.provider.strip().lower() == DEFAULT_STT_PROVIDER
and not bool(cfg.models.allow_custom_models)
and not cfg.models.whisper_model_path.strip()
)
return RUNTIME_MODE_MANAGED if is_canonical else RUNTIME_MODE_EXPERT
def apply_canonical_runtime_defaults(cfg: Config) -> None:
cfg.stt.provider = DEFAULT_STT_PROVIDER
cfg.models.allow_custom_models = False
cfg.models.whisper_model_path = ""
class ConfigWindow: class ConfigWindow:
def __init__( def __init__(
self, self,
@ -61,7 +51,8 @@ class ConfigWindow:
self._config = copy.deepcopy(initial_cfg) self._config = copy.deepcopy(initial_cfg)
self._required = required self._required = required
self._config_path = Path(config_path) if config_path else DEFAULT_CONFIG_PATH self._config_path = Path(config_path) if config_path else DEFAULT_CONFIG_PATH
self._devices = list_input_devices() self._audio_settings = AudioSettingsService()
self._devices = self._audio_settings.list_input_devices()
self._device_by_id = {str(device["index"]): device for device in self._devices} self._device_by_id = {str(device["index"]): device for device in self._devices}
self._row_to_section: dict[Gtk.ListBoxRow, str] = {} self._row_to_section: dict[Gtk.ListBoxRow, str] = {}
self._runtime_mode = infer_runtime_mode(self._config) self._runtime_mode = infer_runtime_mode(self._config)
@ -115,11 +106,11 @@ class ConfigWindow:
self._stack.set_transition_duration(120) self._stack.set_transition_duration(120)
body.pack_start(self._stack, True, True, 0) body.pack_start(self._stack, True, True, 0)
self._general_page = self._build_general_page() self._general_page = build_general_page(self)
self._audio_page = self._build_audio_page() self._audio_page = build_audio_page(self)
self._advanced_page = self._build_advanced_page() self._advanced_page = build_advanced_page(self)
self._help_page = self._build_help_page() self._help_page = build_help_page(self, present_about_dialog=_present_about_dialog)
self._about_page = self._build_about_page() self._about_page = build_about_page(self, present_about_dialog=_present_about_dialog)
self._add_section("general", "General", self._general_page) self._add_section("general", "General", self._general_page)
self._add_section("audio", "Audio", self._audio_page) self._add_section("audio", "Audio", self._audio_page)
@ -169,261 +160,6 @@ class ConfigWindow:
if section: if section:
self._stack.set_visible_child_name(section) self._stack.set_visible_child_name(section)
def _build_general_page(self) -> Gtk.Widget:
grid = Gtk.Grid(column_spacing=12, row_spacing=10)
grid.set_margin_start(14)
grid.set_margin_end(14)
grid.set_margin_top(14)
grid.set_margin_bottom(14)
hotkey_label = Gtk.Label(label="Trigger hotkey")
hotkey_label.set_xalign(0.0)
self._hotkey_entry = Gtk.Entry()
self._hotkey_entry.set_placeholder_text("Super+m")
self._hotkey_entry.connect("changed", lambda *_: self._validate_hotkey())
grid.attach(hotkey_label, 0, 0, 1, 1)
grid.attach(self._hotkey_entry, 1, 0, 1, 1)
self._hotkey_error = Gtk.Label(label="")
self._hotkey_error.set_xalign(0.0)
self._hotkey_error.set_line_wrap(True)
grid.attach(self._hotkey_error, 1, 1, 1, 1)
backend_label = Gtk.Label(label="Text injection")
backend_label.set_xalign(0.0)
self._backend_combo = Gtk.ComboBoxText()
self._backend_combo.append("clipboard", "Clipboard paste (recommended)")
self._backend_combo.append("injection", "Simulated typing")
grid.attach(backend_label, 0, 2, 1, 1)
grid.attach(self._backend_combo, 1, 2, 1, 1)
self._remove_clipboard_check = Gtk.CheckButton(
label="Remove transcription from clipboard after paste"
)
self._remove_clipboard_check.set_hexpand(True)
grid.attach(self._remove_clipboard_check, 1, 3, 1, 1)
language_label = Gtk.Label(label="Transcription language")
language_label.set_xalign(0.0)
self._language_combo = Gtk.ComboBoxText()
for code, label in COMMON_STT_LANGUAGE_OPTIONS:
self._language_combo.append(code, label)
grid.attach(language_label, 0, 4, 1, 1)
grid.attach(self._language_combo, 1, 4, 1, 1)
profile_label = Gtk.Label(label="Profile")
profile_label.set_xalign(0.0)
self._profile_combo = Gtk.ComboBoxText()
self._profile_combo.append("default", "Default")
self._profile_combo.append("fast", "Fast (lower latency)")
self._profile_combo.append("polished", "Polished")
grid.attach(profile_label, 0, 5, 1, 1)
grid.attach(self._profile_combo, 1, 5, 1, 1)
return grid
def _build_audio_page(self) -> Gtk.Widget:
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.set_margin_start(14)
box.set_margin_end(14)
box.set_margin_top(14)
box.set_margin_bottom(14)
input_label = Gtk.Label(label="Input device")
input_label.set_xalign(0.0)
box.pack_start(input_label, False, False, 0)
self._mic_combo = Gtk.ComboBoxText()
self._mic_combo.append("", "System default")
for device in self._devices:
self._mic_combo.append(str(device["index"]), f"{device['index']}: {device['name']}")
box.pack_start(self._mic_combo, False, False, 0)
test_button = Gtk.Button(label="Test microphone")
test_button.connect("clicked", lambda *_: self._on_test_microphone())
box.pack_start(test_button, False, False, 0)
self._mic_status = Gtk.Label(label="")
self._mic_status.set_xalign(0.0)
self._mic_status.set_line_wrap(True)
box.pack_start(self._mic_status, False, False, 0)
return box
def _build_advanced_page(self) -> Gtk.Widget:
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.set_margin_start(14)
box.set_margin_end(14)
box.set_margin_top(14)
box.set_margin_bottom(14)
self._strict_startup_check = Gtk.CheckButton(label="Fail fast on startup validation errors")
box.pack_start(self._strict_startup_check, False, False, 0)
safety_title = Gtk.Label()
safety_title.set_markup("<span weight='bold'>Output safety</span>")
safety_title.set_xalign(0.0)
box.pack_start(safety_title, False, False, 0)
self._safety_enabled_check = Gtk.CheckButton(
label="Enable fact-preservation guard (recommended)"
)
self._safety_enabled_check.connect("toggled", lambda *_: self._on_safety_guard_toggled())
box.pack_start(self._safety_enabled_check, False, False, 0)
self._safety_strict_check = Gtk.CheckButton(
label="Strict mode: reject output when facts are changed"
)
box.pack_start(self._safety_strict_check, False, False, 0)
runtime_title = Gtk.Label()
runtime_title.set_markup("<span weight='bold'>Runtime management</span>")
runtime_title.set_xalign(0.0)
box.pack_start(runtime_title, False, False, 0)
runtime_copy = Gtk.Label(
label=(
"Aman-managed mode handles the canonical editor model lifecycle for you. "
"Expert mode keeps Aman open-source friendly by letting you use custom Whisper paths."
)
)
runtime_copy.set_xalign(0.0)
runtime_copy.set_line_wrap(True)
box.pack_start(runtime_copy, False, False, 0)
mode_label = Gtk.Label(label="Runtime mode")
mode_label.set_xalign(0.0)
box.pack_start(mode_label, False, False, 0)
self._runtime_mode_combo = Gtk.ComboBoxText()
self._runtime_mode_combo.append(RUNTIME_MODE_MANAGED, "Aman-managed (recommended)")
self._runtime_mode_combo.append(RUNTIME_MODE_EXPERT, "Expert mode (custom Whisper path)")
self._runtime_mode_combo.connect("changed", lambda *_: self._on_runtime_mode_changed(user_initiated=True))
box.pack_start(self._runtime_mode_combo, False, False, 0)
self._runtime_status_label = Gtk.Label(label="")
self._runtime_status_label.set_xalign(0.0)
self._runtime_status_label.set_line_wrap(True)
box.pack_start(self._runtime_status_label, False, False, 0)
self._expert_expander = Gtk.Expander(label="Expert options")
self._expert_expander.set_expanded(False)
box.pack_start(self._expert_expander, False, False, 0)
expert_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
expert_box.set_margin_start(10)
expert_box.set_margin_end(10)
expert_box.set_margin_top(8)
expert_box.set_margin_bottom(8)
self._expert_expander.add(expert_box)
expert_warning = Gtk.InfoBar()
expert_warning.set_show_close_button(False)
expert_warning.set_message_type(Gtk.MessageType.WARNING)
warning_label = Gtk.Label(
label=(
"Expert mode is best-effort and may require manual troubleshooting. "
"Aman-managed mode is the canonical supported path."
)
)
warning_label.set_xalign(0.0)
warning_label.set_line_wrap(True)
expert_warning.get_content_area().pack_start(warning_label, True, True, 0)
expert_box.pack_start(expert_warning, False, False, 0)
self._allow_custom_models_check = Gtk.CheckButton(
label="Allow custom local model paths"
)
self._allow_custom_models_check.connect("toggled", lambda *_: self._on_runtime_widgets_changed())
expert_box.pack_start(self._allow_custom_models_check, False, False, 0)
whisper_model_path_label = Gtk.Label(label="Custom Whisper model path")
whisper_model_path_label.set_xalign(0.0)
expert_box.pack_start(whisper_model_path_label, False, False, 0)
self._whisper_model_path_entry = Gtk.Entry()
self._whisper_model_path_entry.connect("changed", lambda *_: self._on_runtime_widgets_changed())
expert_box.pack_start(self._whisper_model_path_entry, False, False, 0)
self._runtime_error = Gtk.Label(label="")
self._runtime_error.set_xalign(0.0)
self._runtime_error.set_line_wrap(True)
expert_box.pack_start(self._runtime_error, False, False, 0)
path_label = Gtk.Label(label="Config path")
path_label.set_xalign(0.0)
box.pack_start(path_label, False, False, 0)
path_entry = Gtk.Entry()
path_entry.set_editable(False)
path_entry.set_text(str(self._config_path))
box.pack_start(path_entry, False, False, 0)
note = Gtk.Label(
label=(
"Tip: after editing the file directly, use Reload Config from the tray to apply changes."
)
)
note.set_xalign(0.0)
note.set_line_wrap(True)
box.pack_start(note, False, False, 0)
return box
def _build_help_page(self) -> Gtk.Widget:
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.set_margin_start(14)
box.set_margin_end(14)
box.set_margin_top(14)
box.set_margin_bottom(14)
help_text = Gtk.Label(
label=(
"Usage:\n"
"- Press your hotkey to start recording.\n"
"- Press the hotkey again to stop and process.\n"
"- Press Esc while recording to cancel.\n\n"
"Supported path:\n"
"- Daily use runs through the tray and user service.\n"
"- Aman-managed mode (recommended) handles model lifecycle for you.\n"
"- Expert mode keeps custom Whisper paths available for advanced users.\n\n"
"Recovery:\n"
"- Use Run Diagnostics from the tray for a deeper self-check.\n"
"- If that is not enough, run aman doctor, then aman self-check.\n"
"- Next escalations are journalctl --user -u aman and aman run --verbose.\n\n"
"Safety tips:\n"
"- Keep fact guard enabled to prevent accidental name/number changes.\n"
"- Strict safety blocks output on fact violations."
)
)
help_text.set_xalign(0.0)
help_text.set_line_wrap(True)
box.pack_start(help_text, False, False, 0)
about_button = Gtk.Button(label="Open About Dialog")
about_button.connect("clicked", lambda *_: _present_about_dialog(self._dialog))
box.pack_start(about_button, False, False, 0)
return box
def _build_about_page(self) -> Gtk.Widget:
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.set_margin_start(14)
box.set_margin_end(14)
box.set_margin_top(14)
box.set_margin_bottom(14)
title = Gtk.Label()
title.set_markup("<span size='x-large' weight='bold'>Aman</span>")
title.set_xalign(0.0)
box.pack_start(title, False, False, 0)
subtitle = Gtk.Label(label="Local amanuensis for X11 desktop dictation and rewriting.")
subtitle.set_xalign(0.0)
subtitle.set_line_wrap(True)
box.pack_start(subtitle, False, False, 0)
about_button = Gtk.Button(label="About Aman")
about_button.connect("clicked", lambda *_: _present_about_dialog(self._dialog))
box.pack_start(about_button, False, False, 0)
return box
def _initialize_widget_values(self) -> None: def _initialize_widget_values(self) -> None:
hotkey = self._config.daemon.hotkey.strip() or "Super+m" hotkey = self._config.daemon.hotkey.strip() or "Super+m"
self._hotkey_entry.set_text(hotkey) self._hotkey_entry.set_text(hotkey)
@ -457,7 +193,7 @@ class ConfigWindow:
self._sync_runtime_mode_ui(user_initiated=False) self._sync_runtime_mode_ui(user_initiated=False)
self._validate_runtime_settings() self._validate_runtime_settings()
resolved = resolve_input_device(self._config.recording.input) resolved = self._audio_settings.resolve_input_device(self._config.recording.input)
if resolved is None: if resolved is None:
self._mic_combo.set_active_id("") self._mic_combo.set_active_id("")
return return
@ -536,16 +272,8 @@ class ConfigWindow:
self._mic_status.set_text("Testing microphone...") self._mic_status.set_text("Testing microphone...")
while Gtk.events_pending(): while Gtk.events_pending():
Gtk.main_iteration() Gtk.main_iteration()
try: result = self._audio_settings.test_microphone(input_spec)
stream, record = start_recording(input_spec) self._mic_status.set_text(result.message)
time.sleep(0.35)
audio = stop_recording(stream, record)
if getattr(audio, "size", 0) > 0:
self._mic_status.set_text("Microphone test successful.")
return
self._mic_status.set_text("No audio captured. Try another device.")
except Exception as exc:
self._mic_status.set_text(f"Microphone test failed: {exc}")
def _validate_hotkey(self) -> bool: def _validate_hotkey(self) -> bool:
hotkey = self._hotkey_entry.get_text().strip() hotkey = self._hotkey_entry.get_text().strip()

52
src/config_ui_audio.py Normal file
View file

@ -0,0 +1,52 @@
from __future__ import annotations
import time
from dataclasses import dataclass
from typing import Any
from recorder import (
list_input_devices,
resolve_input_device,
start_recording,
stop_recording,
)
@dataclass(frozen=True)
class MicrophoneTestResult:
ok: bool
message: str
class AudioSettingsService:
def list_input_devices(self) -> list[dict[str, Any]]:
return list_input_devices()
def resolve_input_device(self, input_spec: str | int | None) -> int | None:
return resolve_input_device(input_spec)
def test_microphone(
self,
input_spec: str | int | None,
*,
duration_sec: float = 0.35,
) -> MicrophoneTestResult:
try:
stream, record = start_recording(input_spec)
time.sleep(duration_sec)
audio = stop_recording(stream, record)
except Exception as exc:
return MicrophoneTestResult(
ok=False,
message=f"Microphone test failed: {exc}",
)
if getattr(audio, "size", 0) > 0:
return MicrophoneTestResult(
ok=True,
message="Microphone test successful.",
)
return MicrophoneTestResult(
ok=False,
message="No audio captured. Try another device.",
)

293
src/config_ui_pages.py Normal file
View file

@ -0,0 +1,293 @@
from __future__ import annotations
import gi
from config_ui_runtime import RUNTIME_MODE_EXPERT, RUNTIME_MODE_MANAGED
from languages import COMMON_STT_LANGUAGE_OPTIONS
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk # type: ignore[import-not-found]
def _page_box() -> Gtk.Box:
box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=10)
box.set_margin_start(14)
box.set_margin_end(14)
box.set_margin_top(14)
box.set_margin_bottom(14)
return box
def build_general_page(window) -> Gtk.Widget:
grid = Gtk.Grid(column_spacing=12, row_spacing=10)
grid.set_margin_start(14)
grid.set_margin_end(14)
grid.set_margin_top(14)
grid.set_margin_bottom(14)
hotkey_label = Gtk.Label(label="Trigger hotkey")
hotkey_label.set_xalign(0.0)
window._hotkey_entry = Gtk.Entry()
window._hotkey_entry.set_placeholder_text("Super+m")
window._hotkey_entry.connect("changed", lambda *_: window._validate_hotkey())
grid.attach(hotkey_label, 0, 0, 1, 1)
grid.attach(window._hotkey_entry, 1, 0, 1, 1)
window._hotkey_error = Gtk.Label(label="")
window._hotkey_error.set_xalign(0.0)
window._hotkey_error.set_line_wrap(True)
grid.attach(window._hotkey_error, 1, 1, 1, 1)
backend_label = Gtk.Label(label="Text injection")
backend_label.set_xalign(0.0)
window._backend_combo = Gtk.ComboBoxText()
window._backend_combo.append("clipboard", "Clipboard paste (recommended)")
window._backend_combo.append("injection", "Simulated typing")
grid.attach(backend_label, 0, 2, 1, 1)
grid.attach(window._backend_combo, 1, 2, 1, 1)
window._remove_clipboard_check = Gtk.CheckButton(
label="Remove transcription from clipboard after paste"
)
window._remove_clipboard_check.set_hexpand(True)
grid.attach(window._remove_clipboard_check, 1, 3, 1, 1)
language_label = Gtk.Label(label="Transcription language")
language_label.set_xalign(0.0)
window._language_combo = Gtk.ComboBoxText()
for code, label in COMMON_STT_LANGUAGE_OPTIONS:
window._language_combo.append(code, label)
grid.attach(language_label, 0, 4, 1, 1)
grid.attach(window._language_combo, 1, 4, 1, 1)
profile_label = Gtk.Label(label="Profile")
profile_label.set_xalign(0.0)
window._profile_combo = Gtk.ComboBoxText()
window._profile_combo.append("default", "Default")
window._profile_combo.append("fast", "Fast (lower latency)")
window._profile_combo.append("polished", "Polished")
grid.attach(profile_label, 0, 5, 1, 1)
grid.attach(window._profile_combo, 1, 5, 1, 1)
return grid
def build_audio_page(window) -> Gtk.Widget:
box = _page_box()
input_label = Gtk.Label(label="Input device")
input_label.set_xalign(0.0)
box.pack_start(input_label, False, False, 0)
window._mic_combo = Gtk.ComboBoxText()
window._mic_combo.append("", "System default")
for device in window._devices:
window._mic_combo.append(
str(device["index"]),
f"{device['index']}: {device['name']}",
)
box.pack_start(window._mic_combo, False, False, 0)
test_button = Gtk.Button(label="Test microphone")
test_button.connect("clicked", lambda *_: window._on_test_microphone())
box.pack_start(test_button, False, False, 0)
window._mic_status = Gtk.Label(label="")
window._mic_status.set_xalign(0.0)
window._mic_status.set_line_wrap(True)
box.pack_start(window._mic_status, False, False, 0)
return box
def build_advanced_page(window) -> Gtk.Widget:
box = _page_box()
window._strict_startup_check = Gtk.CheckButton(
label="Fail fast on startup validation errors"
)
box.pack_start(window._strict_startup_check, False, False, 0)
safety_title = Gtk.Label()
safety_title.set_markup("<span weight='bold'>Output safety</span>")
safety_title.set_xalign(0.0)
box.pack_start(safety_title, False, False, 0)
window._safety_enabled_check = Gtk.CheckButton(
label="Enable fact-preservation guard (recommended)"
)
window._safety_enabled_check.connect(
"toggled",
lambda *_: window._on_safety_guard_toggled(),
)
box.pack_start(window._safety_enabled_check, False, False, 0)
window._safety_strict_check = Gtk.CheckButton(
label="Strict mode: reject output when facts are changed"
)
box.pack_start(window._safety_strict_check, False, False, 0)
runtime_title = Gtk.Label()
runtime_title.set_markup("<span weight='bold'>Runtime management</span>")
runtime_title.set_xalign(0.0)
box.pack_start(runtime_title, False, False, 0)
runtime_copy = Gtk.Label(
label=(
"Aman-managed mode handles the canonical editor model lifecycle for you. "
"Expert mode keeps Aman open-source friendly by letting you use custom Whisper paths."
)
)
runtime_copy.set_xalign(0.0)
runtime_copy.set_line_wrap(True)
box.pack_start(runtime_copy, False, False, 0)
mode_label = Gtk.Label(label="Runtime mode")
mode_label.set_xalign(0.0)
box.pack_start(mode_label, False, False, 0)
window._runtime_mode_combo = Gtk.ComboBoxText()
window._runtime_mode_combo.append(
RUNTIME_MODE_MANAGED,
"Aman-managed (recommended)",
)
window._runtime_mode_combo.append(
RUNTIME_MODE_EXPERT,
"Expert mode (custom Whisper path)",
)
window._runtime_mode_combo.connect(
"changed",
lambda *_: window._on_runtime_mode_changed(user_initiated=True),
)
box.pack_start(window._runtime_mode_combo, False, False, 0)
window._runtime_status_label = Gtk.Label(label="")
window._runtime_status_label.set_xalign(0.0)
window._runtime_status_label.set_line_wrap(True)
box.pack_start(window._runtime_status_label, False, False, 0)
window._expert_expander = Gtk.Expander(label="Expert options")
window._expert_expander.set_expanded(False)
box.pack_start(window._expert_expander, False, False, 0)
expert_box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=8)
expert_box.set_margin_start(10)
expert_box.set_margin_end(10)
expert_box.set_margin_top(8)
expert_box.set_margin_bottom(8)
window._expert_expander.add(expert_box)
expert_warning = Gtk.InfoBar()
expert_warning.set_show_close_button(False)
expert_warning.set_message_type(Gtk.MessageType.WARNING)
warning_label = Gtk.Label(
label=(
"Expert mode is best-effort and may require manual troubleshooting. "
"Aman-managed mode is the canonical supported path."
)
)
warning_label.set_xalign(0.0)
warning_label.set_line_wrap(True)
expert_warning.get_content_area().pack_start(warning_label, True, True, 0)
expert_box.pack_start(expert_warning, False, False, 0)
window._allow_custom_models_check = Gtk.CheckButton(
label="Allow custom local model paths"
)
window._allow_custom_models_check.connect(
"toggled",
lambda *_: window._on_runtime_widgets_changed(),
)
expert_box.pack_start(window._allow_custom_models_check, False, False, 0)
whisper_model_path_label = Gtk.Label(label="Custom Whisper model path")
whisper_model_path_label.set_xalign(0.0)
expert_box.pack_start(whisper_model_path_label, False, False, 0)
window._whisper_model_path_entry = Gtk.Entry()
window._whisper_model_path_entry.connect(
"changed",
lambda *_: window._on_runtime_widgets_changed(),
)
expert_box.pack_start(window._whisper_model_path_entry, False, False, 0)
window._runtime_error = Gtk.Label(label="")
window._runtime_error.set_xalign(0.0)
window._runtime_error.set_line_wrap(True)
expert_box.pack_start(window._runtime_error, False, False, 0)
path_label = Gtk.Label(label="Config path")
path_label.set_xalign(0.0)
box.pack_start(path_label, False, False, 0)
path_entry = Gtk.Entry()
path_entry.set_editable(False)
path_entry.set_text(str(window._config_path))
box.pack_start(path_entry, False, False, 0)
note = Gtk.Label(
label=(
"Tip: after editing the file directly, use Reload Config from the tray to apply changes."
)
)
note.set_xalign(0.0)
note.set_line_wrap(True)
box.pack_start(note, False, False, 0)
return box
def build_help_page(window, *, present_about_dialog) -> Gtk.Widget:
box = _page_box()
help_text = Gtk.Label(
label=(
"Usage:\n"
"- Press your hotkey to start recording.\n"
"- Press the hotkey again to stop and process.\n"
"- Press Esc while recording to cancel.\n\n"
"Supported path:\n"
"- Daily use runs through the tray and user service.\n"
"- Aman-managed mode (recommended) handles model lifecycle for you.\n"
"- Expert mode keeps custom Whisper paths available for advanced users.\n\n"
"Recovery:\n"
"- Use Run Diagnostics from the tray for a deeper self-check.\n"
"- If that is not enough, run aman doctor, then aman self-check.\n"
"- Next escalations are journalctl --user -u aman and aman run --verbose.\n\n"
"Safety tips:\n"
"- Keep fact guard enabled to prevent accidental name/number changes.\n"
"- Strict safety blocks output on fact violations."
)
)
help_text.set_xalign(0.0)
help_text.set_line_wrap(True)
box.pack_start(help_text, False, False, 0)
about_button = Gtk.Button(label="Open About Dialog")
about_button.connect(
"clicked",
lambda *_: present_about_dialog(window._dialog),
)
box.pack_start(about_button, False, False, 0)
return box
def build_about_page(window, *, present_about_dialog) -> Gtk.Widget:
box = _page_box()
title = Gtk.Label()
title.set_markup("<span size='x-large' weight='bold'>Aman</span>")
title.set_xalign(0.0)
box.pack_start(title, False, False, 0)
subtitle = Gtk.Label(
label="Local amanuensis for X11 desktop dictation and rewriting."
)
subtitle.set_xalign(0.0)
subtitle.set_line_wrap(True)
box.pack_start(subtitle, False, False, 0)
about_button = Gtk.Button(label="About Aman")
about_button.connect(
"clicked",
lambda *_: present_about_dialog(window._dialog),
)
box.pack_start(about_button, False, False, 0)
return box

22
src/config_ui_runtime.py Normal file
View file

@ -0,0 +1,22 @@
from __future__ import annotations
from config import Config, DEFAULT_STT_PROVIDER
RUNTIME_MODE_MANAGED = "aman_managed"
RUNTIME_MODE_EXPERT = "expert_custom"
def infer_runtime_mode(cfg: Config) -> str:
is_canonical = (
cfg.stt.provider.strip().lower() == DEFAULT_STT_PROVIDER
and not bool(cfg.models.allow_custom_models)
and not cfg.models.whisper_model_path.strip()
)
return RUNTIME_MODE_MANAGED if is_canonical else RUNTIME_MODE_EXPERT
def apply_canonical_runtime_defaults(cfg: Config) -> None:
cfg.stt.provider = DEFAULT_STT_PROVIDER
cfg.models.allow_custom_models = False
cfg.models.whisper_model_path = ""

4
src/diagnostics.py
View file

@ -153,10 +153,6 @@ def run_self_check(config_path: str | None) -> DiagnosticReport:
return DiagnosticReport(checks=checks) return DiagnosticReport(checks=checks)
def run_diagnostics(config_path: str | None) -> DiagnosticReport:
return run_doctor(config_path)
def _resolved_config_path(config_path: str | Path | None) -> Path: def _resolved_config_path(config_path: str | Path | None) -> Path:
if config_path: if config_path:
return Path(config_path) return Path(config_path)

10
src/recorder.py
View file

@ -22,16 +22,6 @@ def list_input_devices() -> list[dict]:
return devices return devices
def default_input_device() -> int | None:
sd = _sounddevice()
default = sd.default.device
if isinstance(default, (tuple, list)) and default:
return default[0]
if isinstance(default, int):
return default
return None
def resolve_input_device(spec: str | int | None) -> int | None: def resolve_input_device(spec: str | int | None) -> int | None:
if spec is None: if spec is None:
return None return None

27
tests/test_aman_run.py
View file

@ -205,6 +205,33 @@ class AmanRunTests(unittest.TestCase):
self.assertIn("startup.readiness: startup failed: warmup boom", rendered) self.assertIn("startup.readiness: startup failed: warmup boom", rendered)
self.assertIn("next_step: run `aman self-check --config", rendered) self.assertIn("next_step: run `aman self-check --config", rendered)
def test_run_command_logs_safe_config_payload(self):
with tempfile.TemporaryDirectory() as td:
path = Path(td) / "config.json"
path.write_text(json.dumps({"config_version": 1}) + "\n", encoding="utf-8")
custom_model_path = Path(td) / "custom-whisper.bin"
custom_model_path.write_text("model\n", encoding="utf-8")
args = aman_cli.parse_cli_args(["run", "--config", str(path)])
desktop = _FakeDesktop()
cfg = Config()
cfg.recording.input = "USB Mic"
cfg.models.allow_custom_models = True
cfg.models.whisper_model_path = str(custom_model_path)
cfg.vocabulary.terms = ["SensitiveTerm"]
with patch("aman_run.lock_single_instance", return_value=object()), patch(
"aman_run.get_desktop_adapter", return_value=desktop
), patch("aman_run.load_runtime_config", return_value=cfg), patch(
"aman_run.Daemon", _FakeDaemon
), self.assertLogs(level="INFO") as logs:
exit_code = aman_run.run_command(args)
self.assertEqual(exit_code, 0)
rendered = "\n".join(logs.output)
self.assertIn('"custom_whisper_path_configured": true', rendered)
self.assertIn('"recording_input": "USB Mic"', rendered)
self.assertNotIn(str(custom_model_path), rendered)
self.assertNotIn("SensitiveTerm", rendered)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

16
tests/test_config.py
View file

@ -9,7 +9,7 @@ SRC = ROOT / "src"
if str(SRC) not in sys.path: if str(SRC) not in sys.path:
sys.path.insert(0, str(SRC)) sys.path.insert(0, str(SRC))
from config import CURRENT_CONFIG_VERSION, load, redacted_dict from config import CURRENT_CONFIG_VERSION, Config, config_as_dict, config_log_payload, load
class ConfigTests(unittest.TestCase): class ConfigTests(unittest.TestCase):
@ -39,7 +39,7 @@ class ConfigTests(unittest.TestCase):
self.assertTrue(missing.exists()) self.assertTrue(missing.exists())
written = json.loads(missing.read_text(encoding="utf-8")) written = json.loads(missing.read_text(encoding="utf-8"))
self.assertEqual(written, redacted_dict(cfg)) self.assertEqual(written, config_as_dict(cfg))
def test_loads_nested_config(self): def test_loads_nested_config(self):
payload = { payload = {
@ -311,6 +311,18 @@ class ConfigTests(unittest.TestCase):
): ):
load(str(path)) load(str(path))
def test_config_log_payload_omits_vocabulary_and_custom_model_path(self):
cfg = Config()
cfg.models.allow_custom_models = True
cfg.models.whisper_model_path = "/tmp/custom-whisper.bin"
cfg.vocabulary.terms = ["SensitiveTerm"]
payload = config_log_payload(cfg)
self.assertTrue(payload["custom_whisper_path_configured"])
self.assertNotIn("vocabulary", payload)
self.assertNotIn("whisper_model_path", payload)
if __name__ == "__main__": if __name__ == "__main__":
unittest.main() unittest.main()

53
tests/test_config_ui_audio.py Normal file
View file

@ -0,0 +1,53 @@
import sys
import unittest
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import patch
ROOT = Path(__file__).resolve().parents[1]
SRC = ROOT / "src"
if str(SRC) not in sys.path:
sys.path.insert(0, str(SRC))
from config_ui_audio import AudioSettingsService
class AudioSettingsServiceTests(unittest.TestCase):
def test_microphone_test_reports_success_when_audio_is_captured(self):
service = AudioSettingsService()
with patch("config_ui_audio.start_recording", return_value=("stream", "record")), patch(
"config_ui_audio.stop_recording",
return_value=SimpleNamespace(size=4),
), patch("config_ui_audio.time.sleep") as sleep_mock:
result = service.test_microphone("USB Mic", duration_sec=0.0)
self.assertTrue(result.ok)
self.assertEqual(result.message, "Microphone test successful.")
sleep_mock.assert_called_once_with(0.0)
def test_microphone_test_reports_empty_capture(self):
service = AudioSettingsService()
with patch("config_ui_audio.start_recording", return_value=("stream", "record")), patch(
"config_ui_audio.stop_recording",
return_value=SimpleNamespace(size=0),
), patch("config_ui_audio.time.sleep"):
result = service.test_microphone("USB Mic", duration_sec=0.0)
self.assertFalse(result.ok)
self.assertEqual(result.message, "No audio captured. Try another device.")
def test_microphone_test_surfaces_recording_errors(self):
service = AudioSettingsService()
with patch(
"config_ui_audio.start_recording",
side_effect=RuntimeError("device missing"),
), patch("config_ui_audio.time.sleep") as sleep_mock:
result = service.test_microphone("USB Mic", duration_sec=0.0)
self.assertFalse(result.ok)
self.assertEqual(result.message, "Microphone test failed: device missing")
sleep_mock.assert_not_called()
if __name__ == "__main__":
unittest.main()

21
tests/test_diagnostics.py
View file

@ -16,7 +16,6 @@ from diagnostics import (
DiagnosticCheck, DiagnosticCheck,
DiagnosticReport, DiagnosticReport,
run_doctor, run_doctor,
run_diagnostics,
run_self_check, run_self_check,
) )
@ -192,26 +191,6 @@ class DiagnosticsTests(unittest.TestCase):
self.assertIn("networked connection", results["model.cache"].next_step) self.assertIn("networked connection", results["model.cache"].next_step)
probe_model.assert_called_once() probe_model.assert_called_once()
def test_run_diagnostics_alias_matches_doctor(self):
cfg = Config()
with tempfile.TemporaryDirectory() as td:
config_path = Path(td) / "config.json"
config_path.write_text('{"config_version":1}\n', encoding="utf-8")
with patch.dict("os.environ", {"DISPLAY": ":0"}, clear=False), patch(
"diagnostics.load_existing", return_value=cfg
), patch("diagnostics.list_input_devices", return_value=[{"index": 1, "name": "Mic"}]), patch(
"diagnostics.resolve_input_device", return_value=1
), patch(
"diagnostics.get_desktop_adapter", return_value=_FakeDesktop()
), patch(
"diagnostics._run_systemctl_user",
return_value=_Result(returncode=0, stdout="running\n"),
):
report = run_diagnostics(str(config_path))
self.assertEqual(report.status, "ok")
self.assertEqual(len(report.checks), 7)
def test_report_json_schema_includes_status_and_next_step(self): def test_report_json_schema_includes_status_and_next_step(self):
report = DiagnosticReport( report = DiagnosticReport(
checks=[ checks=[

55
tests/test_packaging_metadata.py Normal file
View file

@ -0,0 +1,55 @@
import ast
import re
import subprocess
import tempfile
import unittest
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def _parse_toml_string_array(text: str, key: str) -> list[str]:
match = re.search(rf"(?ms)^\s*{re.escape(key)}\s*=\s*\[(.*?)^\s*\]", text)
if not match:
raise AssertionError(f"{key} array not found")
return ast.literal_eval("[" + match.group(1) + "]")
class PackagingMetadataTests(unittest.TestCase):
def test_py_modules_matches_top_level_src_modules(self):
text = (ROOT / "pyproject.toml").read_text(encoding="utf-8")
py_modules = sorted(_parse_toml_string_array(text, "py-modules"))
discovered = sorted(path.stem for path in (ROOT / "src").glob("*.py"))
self.assertEqual(py_modules, discovered)
def test_project_dependencies_exclude_native_gui_bindings(self):
text = (ROOT / "pyproject.toml").read_text(encoding="utf-8")
dependencies = _parse_toml_string_array(text, "dependencies")
self.assertNotIn("PyGObject", dependencies)
self.assertNotIn("python-xlib", dependencies)
def test_runtime_requirements_follow_project_dependency_contract(self):
with tempfile.TemporaryDirectory() as td:
output_path = Path(td) / "requirements.txt"
script = (
f'source "{ROOT / "scripts" / "package_common.sh"}"\n'
f'write_runtime_requirements "{output_path}"\n'
)
subprocess.run(
["bash", "-lc", script],
cwd=ROOT,
text=True,
capture_output=True,
check=True,
)
requirements = output_path.read_text(encoding="utf-8").splitlines()
self.assertIn("faster-whisper", requirements)
self.assertIn("llama-cpp-python", requirements)
self.assertNotIn("PyGObject", requirements)
self.assertNotIn("python-xlib", requirements)
if __name__ == "__main__":
unittest.main()

11
tests/test_portable_bundle.py
View file

@ -208,15 +208,22 @@ class PortableBundleTests(unittest.TestCase):
self.assertTrue(tarball.exists()) self.assertTrue(tarball.exists())
self.assertTrue(checksum.exists()) self.assertTrue(checksum.exists())
self.assertTrue(wheel_path.exists()) self.assertTrue(wheel_path.exists())
prefix = f"aman-x11-linux-{version}"
with zipfile.ZipFile(wheel_path) as archive: with zipfile.ZipFile(wheel_path) as archive:
wheel_names = set(archive.namelist()) wheel_names = set(archive.namelist())
metadata_path = f"aman-{version}.dist-info/METADATA" metadata_path = f"aman-{version}.dist-info/METADATA"
metadata = archive.read(metadata_path).decode("utf-8") metadata = archive.read(metadata_path).decode("utf-8")
self.assertNotIn("desktop_wayland.py", wheel_names) self.assertNotIn("desktop_wayland.py", wheel_names)
self.assertNotIn("Requires-Dist: pillow", metadata) self.assertNotIn("Requires-Dist: pillow", metadata)
self.assertNotIn("Requires-Dist: PyGObject", metadata)
self.assertNotIn("Requires-Dist: python-xlib", metadata)
with tarfile.open(tarball, "r:gz") as archive: with tarfile.open(tarball, "r:gz") as archive:
names = set(archive.getnames()) names = set(archive.getnames())
prefix = f"aman-x11-linux-{version}" requirements_path = f"{prefix}/requirements/cp311.txt"
requirements_member = archive.extractfile(requirements_path)
if requirements_member is None:
self.fail(f"missing {requirements_path} in portable archive")
requirements_text = requirements_member.read().decode("utf-8")
self.assertIn(f"{prefix}/install.sh", names) self.assertIn(f"{prefix}/install.sh", names)
self.assertIn(f"{prefix}/uninstall.sh", names) self.assertIn(f"{prefix}/uninstall.sh", names)
self.assertIn(f"{prefix}/portable_installer.py", names) self.assertIn(f"{prefix}/portable_installer.py", names)
@ -229,6 +236,8 @@ class PortableBundleTests(unittest.TestCase):
self.assertIn(f"{prefix}/requirements/cp311.txt", names) self.assertIn(f"{prefix}/requirements/cp311.txt", names)
self.assertIn(f"{prefix}/requirements/cp312.txt", names) self.assertIn(f"{prefix}/requirements/cp312.txt", names)
self.assertIn(f"{prefix}/systemd/aman.service.in", names) self.assertIn(f"{prefix}/systemd/aman.service.in", names)
self.assertNotIn("pygobject", requirements_text.lower())
self.assertNotIn("python-xlib", requirements_text.lower())
def test_fresh_install_creates_managed_paths_and_starts_service(self): def test_fresh_install_creates_managed_paths_and_starts_service(self):
with tempfile.TemporaryDirectory() as tmp: with tempfile.TemporaryDirectory() as tmp:

59
uv.lock generated
View file

@ -15,8 +15,6 @@ dependencies = [
{ name = "llama-cpp-python" }, { name = "llama-cpp-python" },
{ name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" }, { name = "numpy", version = "2.2.6", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
{ name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" }, { name = "numpy", version = "2.4.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
{ name = "pygobject" },
{ name = "python-xlib" },
{ name = "sounddevice" }, { name = "sounddevice" },
] ]
@ -25,8 +23,6 @@ requires-dist = [
{ name = "faster-whisper" }, { name = "faster-whisper" },
{ name = "llama-cpp-python" }, { name = "llama-cpp-python" },
{ name = "numpy" }, { name = "numpy" },
{ name = "pygobject" },
{ name = "python-xlib" },
{ name = "sounddevice" }, { name = "sounddevice" },
] ]
@ -740,31 +736,6 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" }, { url = "https://files.pythonhosted.org/packages/57/bf/2086963c69bdac3d7cff1cc7ff79b8ce5ea0bec6797a017e1be338a46248/protobuf-6.33.5-py3-none-any.whl", hash = "sha256:69915a973dd0f60f31a08b8318b73eab2bd6a392c79184b3612226b0a3f8ec02", size = 170687, upload-time = "2026-01-29T21:51:32.557Z" },
] ]
[[package]]
name = "pycairo"
version = "1.29.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/22/d9/1728840a22a4ef8a8f479b9156aa2943cd98c3907accd3849fb0d5f82bfd/pycairo-1.29.0.tar.gz", hash = "sha256:f3f7fde97325cae80224c09f12564ef58d0d0f655da0e3b040f5807bd5bd3142", size = 665871, upload-time = "2025-11-11T19:13:01.584Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/23/e2/c08847af2a103517f7785830706b6d1d55274494d76ab605eb744404c22f/pycairo-1.29.0-cp310-cp310-win32.whl", hash = "sha256:96c67e6caba72afd285c2372806a0175b1aa2f4537aa88fb4d9802d726effcd1", size = 751339, upload-time = "2025-11-11T19:11:21.266Z" },
{ url = "https://files.pythonhosted.org/packages/eb/36/2a934c6fd4f32d2011c4d9cc59a32e34e06a97dd9f4b138614078d39340b/pycairo-1.29.0-cp310-cp310-win_amd64.whl", hash = "sha256:65bddd944aee9f7d7d72821b1c87e97593856617c2820a78d589d66aa8afbd08", size = 845074, upload-time = "2025-11-11T19:11:27.111Z" },
{ url = "https://files.pythonhosted.org/packages/1b/f0/ee0a887d8c8a6833940263b7234aaa63d8d95a27d6130a9a053867ff057c/pycairo-1.29.0-cp310-cp310-win_arm64.whl", hash = "sha256:15b36aea699e2ff215cb6a21501223246032e572a3a10858366acdd69c81a1c8", size = 694758, upload-time = "2025-11-11T19:11:32.635Z" },
{ url = "https://files.pythonhosted.org/packages/31/92/1b904087e831806a449502786d47d3a468e5edb8f65755f6bd88e8038e53/pycairo-1.29.0-cp311-cp311-win32.whl", hash = "sha256:12757ebfb304b645861283c20585c9204c3430671fad925419cba04844d6dfed", size = 751342, upload-time = "2025-11-11T19:11:37.386Z" },
{ url = "https://files.pythonhosted.org/packages/db/09/a0ab6a246a7ede89e817d749a941df34f27a74bedf15551da51e86ae105e/pycairo-1.29.0-cp311-cp311-win_amd64.whl", hash = "sha256:3391532db03f9601c1cee9ebfa15b7d1db183c6020f3e75c1348cee16825934f", size = 845036, upload-time = "2025-11-11T19:11:43.408Z" },
{ url = "https://files.pythonhosted.org/packages/3c/b2/bf455454bac50baef553e7356d36b9d16e482403bf132cfb12960d2dc2e7/pycairo-1.29.0-cp311-cp311-win_arm64.whl", hash = "sha256:b69be8bb65c46b680771dc6a1a422b1cdd0cffb17be548f223e8cbbb6205567c", size = 694644, upload-time = "2025-11-11T19:11:48.599Z" },
{ url = "https://files.pythonhosted.org/packages/f6/28/6363087b9e60af031398a6ee5c248639eefc6cc742884fa2789411b1f73b/pycairo-1.29.0-cp312-cp312-win32.whl", hash = "sha256:91bcd7b5835764c616a615d9948a9afea29237b34d2ed013526807c3d79bb1d0", size = 751486, upload-time = "2025-11-11T19:11:54.451Z" },
{ url = "https://files.pythonhosted.org/packages/3a/d2/d146f1dd4ef81007686ac52231dd8f15ad54cf0aa432adaefc825475f286/pycairo-1.29.0-cp312-cp312-win_amd64.whl", hash = "sha256:3f01c3b5e49ef9411fff6bc7db1e765f542dc1c9cfed4542958a5afa3a8b8e76", size = 845383, upload-time = "2025-11-11T19:12:01.551Z" },
{ url = "https://files.pythonhosted.org/packages/01/16/6e6f33bb79ec4a527c9e633915c16dc55a60be26b31118dbd0d5859e8c51/pycairo-1.29.0-cp312-cp312-win_arm64.whl", hash = "sha256:eafe3d2076f3533535ad4a361fa0754e0ee66b90e548a3a0f558fed00b1248f2", size = 694518, upload-time = "2025-11-11T19:12:06.561Z" },
{ url = "https://files.pythonhosted.org/packages/f0/21/3f477dc318dd4e84a5ae6301e67284199d7e5a2384f3063714041086b65d/pycairo-1.29.0-cp313-cp313-win32.whl", hash = "sha256:3eb382a4141591807073274522f7aecab9e8fa2f14feafd11ac03a13a58141d7", size = 750949, upload-time = "2025-11-11T19:12:12.198Z" },
{ url = "https://files.pythonhosted.org/packages/43/34/7d27a333c558d6ac16dbc12a35061d389735e99e494ee4effa4ec6d99bed/pycairo-1.29.0-cp313-cp313-win_amd64.whl", hash = "sha256:91114e4b3fbf4287c2b0788f83e1f566ce031bda49cf1c3c3c19c3e986e95c38", size = 844149, upload-time = "2025-11-11T19:12:19.171Z" },
{ url = "https://files.pythonhosted.org/packages/15/43/e782131e23df69e5c8e631a016ed84f94bbc4981bf6411079f57af730a23/pycairo-1.29.0-cp313-cp313-win_arm64.whl", hash = "sha256:09b7f69a5ff6881e151354ea092137b97b0b1f0b2ab4eb81c92a02cc4a08e335", size = 693595, upload-time = "2025-11-11T19:12:23.445Z" },
{ url = "https://files.pythonhosted.org/packages/2d/fa/87eaeeb9d53344c769839d7b2854db7ff2cd596211e00dd1b702eeb1838f/pycairo-1.29.0-cp314-cp314-win32.whl", hash = "sha256:69e2a7968a3fbb839736257bae153f547bca787113cc8d21e9e08ca4526e0b6b", size = 767198, upload-time = "2025-11-11T19:12:42.336Z" },
{ url = "https://files.pythonhosted.org/packages/3c/90/3564d0f64d0a00926ab863dc3c4a129b1065133128e96900772e1c4421f8/pycairo-1.29.0-cp314-cp314-win_amd64.whl", hash = "sha256:e91243437a21cc4c67c401eff4433eadc45745275fa3ade1a0d877e50ffb90da", size = 871579, upload-time = "2025-11-11T19:12:48.982Z" },
{ url = "https://files.pythonhosted.org/packages/5e/91/93632b6ba12ad69c61991e3208bde88486fdfc152be8cfdd13444e9bc650/pycairo-1.29.0-cp314-cp314-win_arm64.whl", hash = "sha256:b72200ea0e5f73ae4c788cd2028a750062221385eb0e6d8f1ecc714d0b4fdf82", size = 719537, upload-time = "2025-11-11T19:12:55.016Z" },
{ url = "https://files.pythonhosted.org/packages/93/23/37053c039f8d3b9b5017af9bc64d27b680c48a898d48b72e6d6583cf0155/pycairo-1.29.0-cp314-cp314t-win_amd64.whl", hash = "sha256:5e45fce6185f553e79e4ef1722b8e98e6cde9900dbc48cb2637a9ccba86f627a", size = 874015, upload-time = "2025-11-11T19:12:28.47Z" },
{ url = "https://files.pythonhosted.org/packages/d7/54/123f6239685f5f3f2edc123f1e38d2eefacebee18cf3c532d2f4bd51d0ef/pycairo-1.29.0-cp314-cp314t-win_arm64.whl", hash = "sha256:caba0837a4b40d47c8dfb0f24cccc12c7831e3dd450837f2a356c75f21ce5a15", size = 721404, upload-time = "2025-11-11T19:12:36.919Z" },
]
[[package]] [[package]]
name = "pycparser" name = "pycparser"
version = "3.0" version = "3.0"
@ -774,27 +745,6 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" }, { url = "https://files.pythonhosted.org/packages/0c/c3/44f3fbbfa403ea2a7c779186dc20772604442dde72947e7d01069cbe98e3/pycparser-3.0-py3-none-any.whl", hash = "sha256:b727414169a36b7d524c1c3e31839a521725078d7b2ff038656844266160a992", size = 48172, upload-time = "2026-01-21T14:26:50.693Z" },
] ]
[[package]]
name = "pygobject"
version = "3.54.5"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "pycairo" },
]
sdist = { url = "https://files.pythonhosted.org/packages/d3/a5/68f883df1d8442e3b267cb92105a4b2f0de819bd64ac9981c2d680d3f49f/pygobject-3.54.5.tar.gz", hash = "sha256:b6656f6348f5245606cf15ea48c384c7f05156c75ead206c1b246c80a22fb585", size = 1274658, upload-time = "2025-10-18T13:45:03.121Z" }
[[package]]
name = "python-xlib"
version = "0.33"
source = { registry = "https://pypi.org/simple" }
dependencies = [
{ name = "six" },
]
sdist = { url = "https://files.pythonhosted.org/packages/86/f5/8c0653e5bb54e0cbdfe27bf32d41f27bc4e12faa8742778c17f2a71be2c0/python-xlib-0.33.tar.gz", hash = "sha256:55af7906a2c75ce6cb280a584776080602444f75815a7aff4d287bb2d7018b32", size = 269068, upload-time = "2022-12-25T18:53:00.824Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/fc/b8/ff33610932e0ee81ae7f1269c890f697d56ff74b9f5b2ee5d9b7fa2c5355/python_xlib-0.33-py2.py3-none-any.whl", hash = "sha256:c3534038d42e0df2f1392a1b30a15a4ff5fdc2b86cfa94f072bf11b10a164398", size = 182185, upload-time = "2022-12-25T18:52:58.662Z" },
]
[[package]] [[package]]
name = "pyyaml" name = "pyyaml"
version = "6.0.3" version = "6.0.3"
@ -877,15 +827,6 @@ wheels = [
{ url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" }, { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755, upload-time = "2023-10-24T04:13:38.866Z" },
] ]
[[package]]
name = "six"
version = "1.17.0"
source = { registry = "https://pypi.org/simple" }
sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
wheels = [
{ url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
]
[[package]] [[package]]
name = "sounddevice" name = "sounddevice"
version = "0.5.5" version = "0.5.5"