desktop-ai-core 0.1.0__tar.gz

desktop_ai_core-0.1.0/.github/workflows/pypi.yml

@@ -0,0 +1,35 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - '*'
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+    permissions:
+      id-token: write  # This is required for OIDC
+      contents: read
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.x'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install setuptools setuptools-scm[toml] wheel build
+
+    - name: Build distribution
+      run: python -m build
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1

desktop_ai_core-0.1.0/.gitignore

@@ -0,0 +1,35 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.eggs/
+.venv/
+venv/
+env/
+.env
+
+# setuptools_scm
+desktop_ai_core/_version.py
+
+# Distribution / packaging
+*.tar.gz
+*.whl
+MANIFEST
+
+# Testing
+.tox/
+.pytest_cache/
+htmlcov/
+.coverage
+coverage.xml
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo

desktop_ai_core-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mahé Perrette
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

desktop_ai_core-0.1.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: desktop-ai-core
+Version: 0.1.0
+Summary: Shared provider abstractions and frontend scaffolding for desktop AI apps (Bard, Scribe, etc.)
+Author-email: Mahé Perrette <mahe.perrette@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Mahé Perrette
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/perrette/desktop-ai-core
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# desktop-ai-core
+
+Shared provider abstractions and frontend scaffolding for desktop AI applications. This package supplies the common primitives consumed by [Bard](https://github.com/perrette/bard) (TTS) and [Scribe](https://github.com/perrette/scribe) (STT): a `TTSBackend` / `STTBackend` / `Voice` / `LanguageModel` type hierarchy, a provider registry, a generic `AbstractFrontendApp` lifecycle class, a terminal menu mini-framework, tray-icon helpers, and a cross-platform desktop-file installer — so that each app can focus on its domain-specific logic rather than re-implementing the shared shell.

desktop_ai_core-0.1.0/README.md

@@ -0,0 +1,3 @@
+# desktop-ai-core
+
+Shared provider abstractions and frontend scaffolding for desktop AI applications. This package supplies the common primitives consumed by [Bard](https://github.com/perrette/bard) (TTS) and [Scribe](https://github.com/perrette/scribe) (STT): a `TTSBackend` / `STTBackend` / `Voice` / `LanguageModel` type hierarchy, a provider registry, a generic `AbstractFrontendApp` lifecycle class, a terminal menu mini-framework, tray-icon helpers, and a cross-platform desktop-file installer — so that each app can focus on its domain-specific logic rather than re-implementing the shared shell.

desktop_ai_core-0.1.0/desktop_ai_core/__init__.py

@@ -0,0 +1,3 @@
+from .install import install_desktop_file
+
+__all__ = ["install_desktop_file"]

desktop_ai_core-0.1.0/desktop_ai_core/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = 'gc08712694'

desktop_ai_core-0.1.0/desktop_ai_core/frontends/__init__.py

@@ -0,0 +1,17 @@
+from desktop_ai_core.frontends.abstract import AbstractFrontendApp
+from desktop_ai_core.frontends.terminal import Item, SetValueItem, Menu
+from desktop_ai_core.frontends.tray import flag_for, MultiStateTrayIcon, write_pidfile, remove_pidfile, register_signal_toggle
+from desktop_ai_core.frontends.dialog import show_error_dialog
+
+__all__ = [
+    "AbstractFrontendApp",
+    "Item",
+    "SetValueItem",
+    "Menu",
+    "flag_for",
+    "MultiStateTrayIcon",
+    "write_pidfile",
+    "remove_pidfile",
+    "register_signal_toggle",
+    "show_error_dialog",
+]

desktop_ai_core-0.1.0/desktop_ai_core/frontends/abstract.py

@@ -0,0 +1,55 @@
+import logging
+from typing import Callable
+
+_default_logger = logging.getLogger("desktop_ai_core")
+
+
+class AbstractFrontendApp:
+    """Generic frontend application scaffolding.
+
+    Holds the lifecycle pieces that are shared across desktop AI apps:
+    a ``view`` reference, a parameter dict, a logger, and an
+    ``error_callback`` hook surfaced through :meth:`notify_error`.
+    Audio, clipboard, and chunk-rendering concerns belong to subclasses.
+    """
+
+    def __init__(
+        self,
+        params=None,
+        view=None,
+        logger=_default_logger,
+        error_callback: Callable[[str, str], None] | None = None,
+    ):
+        self.params = params or {}
+        self.view = view
+        self.logger = logger
+        self.error_callback = error_callback
+
+    def notify_error(self, title: str, message: str) -> None:
+        self.logger.error(f"{title}: {message}")
+        if self.error_callback is not None:
+            try:
+                self.error_callback(title, message)
+            except Exception as cb_exc:
+                self.logger.error(f"error_callback raised: {cb_exc}")
+
+    def set_param(self, item, value=None):
+        self.params[str(item)] = item.value if hasattr(item, "value") and value is None else value
+
+    def get_param(self, item):
+        return self.params.get(str(item))
+
+    def checked(self, item):
+        return self.get_param(str(item))
+
+    def callback_toggle_option(self, view, item):
+        self.set_param(str(item), not self.get_param(str(item)))
+
+    def set_audioplayer(self, view, player):
+        """Protocol hook for subclasses that own an audio player.
+
+        Subclasses with audio concerns override this to wire the player
+        to the view. The base implementation is a no-op so generic
+        callers can invoke it unconditionally.
+        """
+        return None

desktop_ai_core-0.1.0/desktop_ai_core/frontends/dialog.py

@@ -0,0 +1,25 @@
+"""Error dialog helper — safe to call from any thread."""
+
+
+def show_error_dialog(title: str, message: str) -> None:
+    """Pop a modal error dialog. Safe to call from any thread.
+
+    A fresh Tk root is created inside a daemon thread on each call so it never
+    contends with the pystray/GTK main loop that runs in app mode. Degrades
+    gracefully if Tk is unavailable (logs to stdout instead).
+    """
+    import threading
+
+    def _run():
+        try:
+            import tkinter as tk
+            from tkinter import messagebox
+            root = tk.Tk()
+            root.withdraw()
+            root.attributes("-topmost", True)
+            messagebox.showerror(title, message)
+            root.destroy()
+        except Exception as exc:
+            print(f"[error dialog failed: {exc!r}] {title}: {message}")
+
+    threading.Thread(target=_run, daemon=True).start()

desktop_ai_core-0.1.0/desktop_ai_core/frontends/terminal.py

@@ -0,0 +1,101 @@
+class Item:
+    def __init__(self, name, callback, checked=None, checkable=False, visible=True, help=""):
+        self.name = name
+        self._callback = callback
+        self.checkable = checkable or (checked is not None)
+        self.checked = (checked if callable(checked) else lambda item: checked)
+        self.help = help
+        self.visible = visible if callable(visible) else lambda item: visible
+
+    def __call__(self, app, item):
+        return self._callback(app, self)
+
+    def __str__(self):
+        return self.name
+
+class SetValueItem(Item):
+    def __init__(self, name, callback, value=None, choices=None, type=None, **kwargs):
+        super().__init__(name, callback, **kwargs)
+        self.value = value
+        self.choices = choices
+        self.type = type
+
+    def _isvalid(self, value):
+
+        if self.type:
+            try:
+                value = self.type(value)
+            except ValueError as error:
+                print(f"Invalid type: {str(error)}")
+                return False
+
+        if self.choices and value not in self.choices:
+            print(f"Valid choices are {', '.join(map(str, self.choices))}. Got: {str(error)}")
+            return False
+
+        return True
+
+    def __call__(self, app, item):
+        self.is_active = True
+        while self.is_active:
+            value = self.value(item)
+            ans = input(f"Enter value for {self.name} (current {value}): ")
+            if not ans.strip():
+                ans = value
+            if self._isvalid(ans):
+                self.value = lambda item: ans
+                self.is_active = False
+        return self._callback(app, item)
+
+class Menu:
+    def __init__(self, items, name=None, help=""):
+        self.items = items
+        self.name = name
+        self.help = help
+        self.choices = {}
+        self.is_active_menu = False
+
+    def __call__(self, app, _):
+        self.is_active_menu = True
+        while app.is_running and self.is_active_menu:
+            self.show(app)
+            self.prompt(app)
+
+    def show(self, app):
+        print(f"\n{self.name or 'Options:'}")
+
+        count = 0
+        for item in self.items:
+            if not item.visible(item):
+                continue
+            count += 1
+            ticked = " "
+            if item.checkable and item.checked(item):
+                ticked = "✓"
+            if hasattr(item, "value") and item.value(item):
+                suffix = f"({item.value(item)})"
+            else:
+                suffix = ""
+            print(f"{ticked} {count}. {item.help or item.name} {suffix}")
+            self.choices[str(count)] = item
+            self.choices[item.name] = item
+
+    def prompt(self, app, title=None):
+
+        if getattr(app, "_player", None):
+            app.update_progress(app._player)
+
+        choice = input("\nChoose an option: ")
+
+        if choice in self.choices:
+            item = self.choices[choice]
+            print(item)
+            ans = item(app, item)
+            if isinstance(ans, bool):
+                self.is_active_menu = ans
+
+        elif choice in ("quit", "q"):
+            self.is_active_menu = False
+
+        else:
+            return print(f"Invalid choice: {choice}")

desktop_ai_core-0.1.0/desktop_ai_core/frontends/tray.py

@@ -0,0 +1,117 @@
+import time as _time
+import os as _os
+import signal as _signal
+import logging as _logging
+from pathlib import Path
+
+
+_FLAGS = {
+    "en-US": "🇺🇸",
+    "en-GB": "🇬🇧",
+    "fr-FR": "🇫🇷",
+    "de-DE": "🇩🇪",
+    "es-ES": "🇪🇸",
+    "it-IT": "🇮🇹",
+    "ja-JP": "🇯🇵",
+    "zh-CN": "🇨🇳",
+    "hi-IN": "🇮🇳",
+    "pt-BR": "🇧🇷",
+    "pt-PT": "🇵🇹",
+}
+
+
+def flag_for(language: str | None) -> str:
+    if language is None:
+        return ""
+    return _FLAGS.get(language, "")
+
+
+def write_pidfile(name: str) -> Path:
+    """Write a PID file for the named application. Returns the file path."""
+    runtime_dir = _os.environ.get("XDG_RUNTIME_DIR") or "/tmp"
+    pid_path = Path(runtime_dir) / f"{name}.pid"
+    with open(pid_path, "w") as f:
+        f.write(str(_os.getpid()))
+    pid_path.chmod(0o600)
+    return pid_path
+
+
+def remove_pidfile(name: str) -> None:
+    """Remove the PID file for the named application. Silently ignores missing files."""
+    runtime_dir = _os.environ.get("XDG_RUNTIME_DIR") or "/tmp"
+    pid_path = Path(runtime_dir) / f"{name}.pid"
+    try:
+        pid_path.unlink()
+    except FileNotFoundError:
+        pass
+
+
+def register_signal_toggle(signal_number: int, callback) -> None:
+    """Register *callback* as the handler for *signal_number*.
+
+    On platforms where the signal is unavailable the call is a no-op logged at
+    DEBUG level instead of raising.
+    """
+    try:
+        _signal.signal(signal_number, lambda *_: callback())
+    except (OSError, ValueError) as exc:
+        _logging.debug("register_signal_toggle: signal %d not available: %s", signal_number, exc)
+
+
+_UNSET = object()
+
+
+class MultiStateTrayIcon:
+    """Drive state-based image swaps on a pystray-style tray icon.
+
+    The helper wraps an existing icon and a mapping of state-name -> PIL
+    image. A caller-supplied ``get_state`` callable is queried on each
+    ``update`` to derive the current logical state (e.g. ``"recording"``,
+    ``"busy"``, or ``None`` for idle); when the value differs from the
+    previously applied state, the icon's image is swapped and
+    ``icon.update_menu()`` is called so visibility predicates re-evaluate.
+
+    A ``start_monitoring`` helper runs a poll loop (intended to be invoked
+    from a background thread) that keeps calling ``update`` while a
+    ``should_continue`` callable returns truthy, then performs one final
+    update before exiting so the icon settles to whatever the current state
+    is when the loop ends.
+
+    Parameters
+    ----------
+    icon:
+        A pystray ``Icon``-compatible object exposing assignable ``.icon``
+        and a callable ``.update_menu()``.
+    images:
+        Mapping of state name -> ``PIL.Image``. Use ``None`` as the key for
+        the idle state. Every value that ``get_state`` can return must be a
+        key.
+    get_state:
+        Zero-argument callable returning the current state name (or
+        ``None``).
+    poll_interval:
+        Seconds between polls in ``start_monitoring``. Defaults to 0.1.
+    """
+
+    def __init__(self, icon, images, get_state, poll_interval=0.1):
+        self.icon = icon
+        self.images = images
+        self.get_state = get_state
+        self.poll_interval = poll_interval
+        self._current = _UNSET
+
+    def update(self, force=False):
+        state = self.get_state()
+        if not force and state == self._current:
+            return
+        self.icon.icon = self.images[state]
+        self._current = state
+        self.icon.update_menu()
+
+    def start_monitoring(self, should_continue):
+        try:
+            while should_continue():
+                self.update()
+                _time.sleep(self.poll_interval)
+        finally:
+            self.update()

desktop_ai_core-0.1.0/desktop_ai_core/install.py

@@ -0,0 +1,42 @@
+import os
+import platform
+
+
+def install_desktop_file(
+    template: str,
+    name: str,
+    icon_folder: str,
+    bin_folder: str,
+    terminal: bool,
+    startup_wm_class: str | None,
+    options: str = "",
+) -> str:
+    """Write a .desktop entry under XDG_DATA_HOME/applications/ and return its path.
+
+    Raises NotImplementedError on non-Linux platforms.
+    """
+    if platform.system() != "Linux":
+        raise NotImplementedError("Desktop-file installation is only supported on Linux.")
+
+    simple_name = name.lower().replace(" ", "-").replace(os.path.sep, "-")
+    resolved_wm_class = startup_wm_class or f"crx_mpnasdandanpmm_{simple_name}"
+
+    home = os.environ.get("HOME", os.path.expanduser("~"))
+    xdg_share = os.environ.get("XDG_DATA_HOME", os.path.join(home, ".local", "share"))
+    xdg_app_data = os.path.join(xdg_share, "applications")
+    os.makedirs(xdg_app_data, exist_ok=True)
+
+    content = template.format(
+        icon_folder=icon_folder,
+        bin_folder=bin_folder,
+        name=name,
+        terminal=str(terminal).lower(),
+        StartupWMClass=resolved_wm_class,
+        options=options,
+    )
+
+    desktop_filepath = os.path.join(xdg_app_data, f"{simple_name}.desktop")
+    with open(desktop_filepath, "w") as f:
+        f.write(content)
+
+    return desktop_filepath

desktop_ai_core-0.1.0/desktop_ai_core/providers/__init__.py

@@ -0,0 +1,35 @@
+from desktop_ai_core.providers.base import (
+    Backend,
+    LanguageModel,
+    STTBackend,
+    TTSBackend,
+    Voice,
+)
+from desktop_ai_core.providers.errors import format_openai_error
+from desktop_ai_core.providers.registry import (
+    available_stt,
+    available_tts,
+    get_stt,
+    get_tts,
+    probe_stt,
+    probe_tts,
+    register_stt,
+    register_tts,
+)
+
+__all__ = [
+    "Backend",
+    "LanguageModel",
+    "STTBackend",
+    "TTSBackend",
+    "Voice",
+    "available_stt",
+    "available_tts",
+    "format_openai_error",
+    "get_stt",
+    "get_tts",
+    "probe_stt",
+    "probe_tts",
+    "register_stt",
+    "register_tts",
+]

desktop_ai_core-0.1.0/desktop_ai_core/providers/base.py

@@ -0,0 +1,68 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from pathlib import Path
+from typing import ClassVar, Iterator
+
+
+class Backend(ABC):
+    name: str
+
+
+@dataclass(frozen=True)
+class Voice:
+    id: str
+    language: str | None = None
+    gender: str | None = None
+    display: str | None = None
+
+    def __str__(self) -> str:
+        return self.id
+
+
+@dataclass(frozen=True)
+class LanguageModel:
+    id: str
+    display: str | None = None
+    description: str | None = None
+
+    def __str__(self) -> str:
+        return self.id
+
+
+class TTSBackend(Backend):
+    name: str
+    default_voice: str
+    default_model: str | None
+    output_format: str
+    sample_rate: int | None
+    supports_streaming: bool = False
+    is_local: ClassVar[bool] = False
+    install_hint: ClassVar[str | None] = None
+
+    @abstractmethod
+    def synthesize(self, text: str, out_path: Path) -> Path:
+        ...
+
+    @abstractmethod
+    def list_voices(self) -> list[str]:
+        ...
+
+    def list_voices_meta(self) -> list["Voice"]:
+        return [Voice(id=v) for v in self.list_voices()]
+
+    def list_models(self) -> list[str]:
+        return [self.default_model] if self.default_model else []
+
+    def synthesize_stream(self, text: str) -> Iterator[bytes]:
+        raise NotImplementedError
+
+
+class STTBackend(Backend):
+    name: str
+    default_model: str | None = None
+    is_local: ClassVar[bool] = False
+    install_hint: ClassVar[str | None] = None
+
+    @abstractmethod
+    def transcribe(self, audio_path: Path) -> str:
+        ...

desktop_ai_core-0.1.0/desktop_ai_core/providers/errors.py

@@ -0,0 +1,23 @@
+def format_openai_error(exc):
+    """Turn an openai exception into a (title, message) tuple suited for a user dialog."""
+    import openai
+    body = getattr(exc, "body", None) or {}
+    err = body.get("error") if isinstance(body, dict) else None
+    code = (err or {}).get("code") if isinstance(err, dict) else None
+    api_message = (err or {}).get("message") if isinstance(err, dict) else None
+    detail = api_message or str(exc) or exc.__class__.__name__
+
+    if isinstance(exc, openai.AuthenticationError):
+        return "Authentication failed", f"Check your API key.\n\n{detail}"
+    if isinstance(exc, openai.PermissionDeniedError):
+        return "Permission denied", detail
+    if isinstance(exc, openai.RateLimitError):
+        if code == "insufficient_quota" or "quota" in detail.lower() or "credit" in detail.lower():
+            return ("Credits exhausted",
+                    f"Your account is out of credits or has hit its quota.\n\n{detail}")
+        return "Rate limit", detail
+    if isinstance(exc, openai.APIConnectionError):
+        return "Connection error", f"Could not reach the API.\n\n{detail}"
+    if isinstance(exc, openai.BadRequestError):
+        return "Bad request", detail
+    return f"API error ({exc.__class__.__name__})", detail

desktop_ai_core-0.1.0/desktop_ai_core/providers/registry.py

@@ -0,0 +1,71 @@
+from typing import Callable
+
+from desktop_ai_core.providers.base import STTBackend, TTSBackend
+
+
+_TTS_REGISTRY: dict[str, type[TTSBackend]] = {}
+_TTS_PROBES: dict[str, Callable[[], tuple[bool, str | None]]] = {}
+
+
+def register_tts(
+    name: str,
+    backend_cls: type[TTSBackend],
+    *,
+    probe: Callable[[], tuple[bool, str | None]] | None = None,
+) -> type[TTSBackend]:
+    _TTS_REGISTRY[name] = backend_cls
+    if probe is not None:
+        _TTS_PROBES[name] = probe
+    return backend_cls
+
+
+def get_tts(name: str, **kwargs) -> TTSBackend:
+    if name not in _TTS_REGISTRY:
+        raise KeyError(name)
+    return _TTS_REGISTRY[name](**kwargs)
+
+
+def available_tts() -> list[str]:
+    return list(_TTS_REGISTRY)
+
+
+def probe_tts(name: str) -> tuple[bool, str | None]:
+    if name not in _TTS_REGISTRY:
+        raise KeyError(name)
+    if name in _TTS_PROBES:
+        return _TTS_PROBES[name]()
+    return True, None
+
+
+_STT_REGISTRY: dict[str, type[STTBackend]] = {}
+_STT_PROBES: dict[str, Callable[[], tuple[bool, str | None]]] = {}
+
+
+def register_stt(
+    name: str,
+    backend_cls: type[STTBackend],
+    *,
+    probe: Callable[[], tuple[bool, str | None]] | None = None,
+) -> type[STTBackend]:
+    _STT_REGISTRY[name] = backend_cls
+    if probe is not None:
+        _STT_PROBES[name] = probe
+    return backend_cls
+
+
+def get_stt(name: str, **kwargs) -> STTBackend:
+    if name not in _STT_REGISTRY:
+        raise KeyError(name)
+    return _STT_REGISTRY[name](**kwargs)
+
+
+def available_stt() -> list[str]:
+    return list(_STT_REGISTRY)
+
+
+def probe_stt(name: str) -> tuple[bool, str | None]:
+    if name not in _STT_REGISTRY:
+        raise KeyError(name)
+    if name in _STT_PROBES:
+        return _STT_PROBES[name]()
+    return True, None

desktop_ai_core-0.1.0/desktop_ai_core.egg-info/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: desktop-ai-core
+Version: 0.1.0
+Summary: Shared provider abstractions and frontend scaffolding for desktop AI apps (Bard, Scribe, etc.)
+Author-email: Mahé Perrette <mahe.perrette@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2024 Mahé Perrette
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+        
+Project-URL: Homepage, https://github.com/perrette/desktop-ai-core
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# desktop-ai-core
+
+Shared provider abstractions and frontend scaffolding for desktop AI applications. This package supplies the common primitives consumed by [Bard](https://github.com/perrette/bard) (TTS) and [Scribe](https://github.com/perrette/scribe) (STT): a `TTSBackend` / `STTBackend` / `Voice` / `LanguageModel` type hierarchy, a provider registry, a generic `AbstractFrontendApp` lifecycle class, a terminal menu mini-framework, tray-icon helpers, and a cross-platform desktop-file installer — so that each app can focus on its domain-specific logic rather than re-implementing the shared shell.

desktop_ai_core-0.1.0/desktop_ai_core.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+.gitignore
+LICENSE
+README.md
+pyproject.toml
+.github/workflows/pypi.yml
+desktop_ai_core/__init__.py
+desktop_ai_core/_version.py
+desktop_ai_core/install.py
+desktop_ai_core.egg-info/PKG-INFO
+desktop_ai_core.egg-info/SOURCES.txt
+desktop_ai_core.egg-info/dependency_links.txt
+desktop_ai_core.egg-info/top_level.txt
+desktop_ai_core/frontends/__init__.py
+desktop_ai_core/frontends/abstract.py
+desktop_ai_core/frontends/dialog.py
+desktop_ai_core/frontends/terminal.py
+desktop_ai_core/frontends/tray.py
+desktop_ai_core/providers/__init__.py
+desktop_ai_core/providers/base.py
+desktop_ai_core/providers/errors.py
+desktop_ai_core/providers/registry.py

desktop_ai_core-0.1.0/desktop_ai_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

desktop_ai_core-0.1.0/desktop_ai_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+desktop_ai_core

desktop_ai_core-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61.0", "setuptools_scm[toml]>=6.2", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "desktop-ai-core"
+dynamic = ["version"]
+description = "Shared provider abstractions and frontend scaffolding for desktop AI apps (Bard, Scribe, etc.)"
+authors = [
+    { name="Mahé Perrette", email="mahe.perrette@gmail.com" }
+]
+readme = "README.md"
+license = { file="LICENSE" }
+requires-python = ">=3.9"
+dependencies = []
+
+classifiers = [
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://github.com/perrette/desktop-ai-core"
+
+[tool.setuptools]
+packages = ["desktop_ai_core", "desktop_ai_core.providers", "desktop_ai_core.frontends"]
+
+[tool.setuptools_scm]
+write_to = "desktop_ai_core/_version.py"
+fallback_version = "0.1.0.dev0"

desktop_ai_core-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+