prismatoid 0.4.5__cp313-cp313-manylinux_2_34_x86_64.whl

prism/__init__.py

@@ -0,0 +1,3 @@
+from .core import Backend, BackendId, Context, PrismException
+
+__all__ = ["Backend", "BackendId", "Context", "PrismException"]

prism/core.py

@@ -0,0 +1,374 @@
+import sys
+from enum import IntEnum
+
+from .lib import ffi, lib
+
+if sys.platform == "win32":
+    try:
+        from win32more.Windows.Win32.Foundation import HWND
+    except ImportError:
+        HWND = int
+else:
+    HWND = int
+
+
+class BackendId(IntEnum):
+    INVALID = 0
+    SAPI = 0x1D6DF72422CEEE66
+    AV_SPEECH = 0x28E3429577805C24
+    VOICE_OVER = 0xCB4897961A754BCB
+    SPEECH_DISPATCHER = 0xE3D6F895D949EBFE
+    NVDA = 0x89CC19C5C4AC1A56
+    JAWS = 0xAC3D60E9BD84B53E
+    ONE_CORE = 0x6797D32F0D994CB4
+    ORCA = 0x10AA1FC05A17F96C
+    ANDROID_SCREEN_READER = 0xD199C175AEEC494B
+    ANDROID_TTS = 0xBC175831BFE4E5CC
+    WEB_SPEECH = 0x3572538D44D44A8F
+    UIA = 0x6238F019DB678F8E
+    ZDSR = 0xAF63B44C8601A843
+    ZOOM_TEXT = 0xAE439D62DC7B1479
+
+
+class PrismError(Exception):
+    """Base class for all Prism-related errors."""
+
+    def __init__(self, code: lib.PrismError, message: str | None = None) -> None:
+        self.code = code
+        self.message = message
+        super().__init__(message or f"Prism Error Code: {code}")
+
+
+class PrismNotInitializedError(PrismError, RuntimeError):
+    """PRISM_ERROR_NOT_INITIALIZED"""
+
+
+class PrismAlreadyInitializedError(PrismError, RuntimeError):
+    """PRISM_ERROR_ALREADY_INITIALIZED"""
+
+
+class PrismInvalidOperationError(PrismError, RuntimeError):
+    """PRISM_ERROR_INVALID_OPERATION"""
+
+
+class PrismInternalError(PrismError, RuntimeError):
+    """PRISM_ERROR_INTERNAL"""
+
+
+class PrismBackendNotAvailableError(PrismError, RuntimeError):
+    """PRISM_ERROR_BACKEND_NOT_AVAILABLE"""
+
+
+class PrismNotImplementedError(PrismError, NotImplementedError):
+    """PRISM_ERROR_NOT_IMPLEMENTED"""
+
+
+class PrismInvalidParamError(PrismError, ValueError):
+    """PRISM_ERROR_INVALID_PARAM"""
+
+
+class PrismRangeError(PrismError, IndexError):
+    """PRISM_ERROR_RANGE_OUT_OF_BOUNDS"""
+
+
+class PrismInvalidUtf8Error(PrismError, UnicodeError):
+    """PRISM_ERROR_INVALID_UTF8"""
+
+
+class PrismNotSpeakingError(PrismError):
+    """PRISM_ERROR_NOT_SPEAKING"""
+
+
+class PrismNotPausedError(PrismError):
+    """PRISM_ERROR_NOT_PAUSED"""
+
+
+class PrismAlreadyPausedError(PrismError):
+    """PRISM_ERROR_ALREADY_PAUSED"""
+
+
+class PrismSpeakError(PrismError, IOError):
+    """PRISM_ERROR_SPEAK_FAILURE"""
+
+
+class PrismNoVoicesError(PrismError):
+    """PRISM_ERROR_NO_VOICES"""
+
+
+class PrismVoiceNotFoundError(PrismError, LookupError):
+    """PRISM_ERROR_VOICE_NOT_FOUND"""
+
+
+class PrismMemoryError(PrismError, MemoryError):
+    """PRISM_ERROR_MEMORY_FAILURE"""
+
+
+class PrismUnknownError(PrismError):
+    """PRISM_ERROR_UNKNOWN"""
+
+
+_ERROR_MAP = {
+    lib.PRISM_ERROR_NOT_INITIALIZED: PrismNotInitializedError,
+    lib.PRISM_ERROR_INVALID_PARAM: PrismInvalidParamError,
+    lib.PRISM_ERROR_NOT_IMPLEMENTED: PrismNotImplementedError,
+    lib.PRISM_ERROR_NO_VOICES: PrismNoVoicesError,
+    lib.PRISM_ERROR_VOICE_NOT_FOUND: PrismVoiceNotFoundError,
+    lib.PRISM_ERROR_SPEAK_FAILURE: PrismSpeakError,
+    lib.PRISM_ERROR_MEMORY_FAILURE: PrismMemoryError,
+    lib.PRISM_ERROR_RANGE_OUT_OF_BOUNDS: PrismRangeError,
+    lib.PRISM_ERROR_INTERNAL: PrismInternalError,
+    lib.PRISM_ERROR_NOT_SPEAKING: PrismNotSpeakingError,
+    lib.PRISM_ERROR_NOT_PAUSED: PrismNotPausedError,
+    lib.PRISM_ERROR_ALREADY_PAUSED: PrismAlreadyPausedError,
+    lib.PRISM_ERROR_INVALID_UTF8: PrismInvalidUtf8Error,
+    lib.PRISM_ERROR_INVALID_OPERATION: PrismInvalidOperationError,
+    lib.PRISM_ERROR_ALREADY_INITIALIZED: PrismAlreadyInitializedError,
+    lib.PRISM_ERROR_BACKEND_NOT_AVAILABLE: PrismBackendNotAvailableError,
+    lib.PRISM_ERROR_UNKNOWN: PrismUnknownError,
+}
+
+
+def _check_error(error_code: int) -> None:
+    """
+    Checks the error code. If it is OK, returns None.
+    Otherwise, raises the appropriate PrismError.
+    """
+    if error_code == 0:
+        return
+    exc_class = _ERROR_MAP.get(error_code, PrismUnknownError)
+    msg_ptr = lib.prism_error_string(error_code)
+    msg = ffi.string(msg_ptr).decode("utf-8")
+    raise exc_class(error_code, msg)
+
+
+class Backend:
+    _raw = None
+
+    def __init__(self, raw_ptr: lib.PrismBackend) -> None:
+        if raw_ptr == ffi.NULL:
+            raise RuntimeError("Backend raw pointer MUST NOT be NULL!")
+        self._raw = raw_ptr
+        res = lib.prism_backend_initialize(self._raw)
+        if res not in {lib.PRISM_OK, lib.PRISM_ERROR_ALREADY_INITIALIZED}:
+            _check_error(res)
+
+    def __del__(self) -> None:
+        lib.prism_backend_free(self._raw)
+        self._raw = None
+
+    @property
+    def name(self) -> str:
+        return ffi.string(lib.prism_backend_name(self._raw)).decode("utf-8")
+
+    def speak(self, text: str, interrupt: bool = False) -> None:
+        if len(text) == 0:
+            raise PrismInvalidParamError(
+                lib.PRISM_ERROR_INVALID_PARAM,
+                "Text MUST NOT be empty",
+            )
+        return _check_error(
+            lib.prism_backend_speak(self._raw, text.encode("utf-8"), interrupt),
+        )
+
+    def speak_to_memory(self, text: str, on_audio_data) -> None:
+        if len(text) == 0:
+            raise PrismInvalidParamError(
+                lib.PRISM_ERROR_INVALID_PARAM,
+                "Text MUST NOT be empty",
+            )
+
+        @ffi.callback("void(void *, const float *, size_t, size_t, size_t)")
+        def audio_callback_shim(
+            _userdata, samples_ptr: int, count, channels, rate
+        ) -> None:
+            pcm_data = ffi.unpack(samples_ptr, count * channels)
+            on_audio_data(pcm_data, channels, rate)
+
+        self._active_callback = audio_callback_shim
+        return _check_error(
+            lib.prism_backend_speak_to_memory(
+                self._raw,
+                text.encode("utf-8"),
+                audio_callback_shim,
+                ffi.NULL,
+            ),
+        )
+
+    def braille(self, text: str) -> None:
+        if len(text) == 0:
+            raise PrismInvalidParamError(
+                lib.PRISM_ERROR_INVALID_PARAM,
+                "Text MUST NOT be empty",
+            )
+        return _check_error(lib.prism_backend_braille(self._raw, text.encode("utf-8")))
+
+    def output(self, text: str, interrupt: bool = False) -> None:
+        if len(text) == 0:
+            raise PrismInvalidParamError(
+                lib.PRISM_ERROR_INVALID_PARAM,
+                "Text MUST NOT be empty",
+            )
+        return _check_error(
+            lib.prism_backend_output(self._raw, text.encode("utf-8"), interrupt),
+        )
+
+    def stop(self) -> None:
+        return _check_error(lib.prism_backend_stop(self._raw))
+
+    def pause(self) -> None:
+        return _check_error(lib.prism_backend_pause(self._raw))
+
+    def resume(self) -> None:
+        return _check_error(lib.prism_backend_resume(self._raw))
+
+    @property
+    def speaking(self) -> bool:
+        p_speaking = ffi.new("bool*")
+        _check_error(lib.prism_backend_is_speaking(self._raw, p_speaking))
+        return p_speaking[0]
+
+    @property
+    def volume(self) -> float:
+        p_volume = ffi.new("float*")
+        _check_error(lib.prism_backend_get_volume(self._raw, p_volume))
+        return p_volume[0]
+
+    @volume.setter
+    def volume(self, volume: float) -> None:
+        return _check_error(lib.prism_backend_set_volume(self._raw, volume))
+
+    @property
+    def rate(self) -> float:
+        p_rate = ffi.new("float*")
+        _check_error(lib.prism_backend_get_rate(self._raw, p_rate))
+        return p_rate[0]
+
+    @rate.setter
+    def rate(self, rate: float) -> None:
+        return _check_error(lib.prism_backend_set_rate(self._raw, rate))
+
+    @property
+    def pitch(self) -> float:
+        p_pitch = ffi.new("float*")
+        _check_error(lib.prism_backend_get_pitch(self._raw, p_pitch))
+        return p_pitch[0]
+
+    @pitch.setter
+    def pitch(self, pitch: float) -> None:
+        return _check_error(lib.prism_backend_set_pitch(self._raw, pitch))
+
+    def refresh_voices(self) -> None:
+        return _check_error(lib.prism_backend_refresh_voices(self._raw))
+
+    @property
+    def voices_count(self) -> int:
+        out_count = ffi.new("size_t*")
+        _check_error(lib.prism_backend_count_voices(self._raw, out_count))
+        return out_count[0]
+
+    def get_voice_name(self, idx: int) -> str:
+        pp_name = ffi.new("char **")
+        _check_error(lib.prism_backend_get_voice_name(self._raw, idx, pp_name))
+        return ffi.string(pp_name[0]).decode("utf-8")
+
+    def get_voice_language(self, idx: int) -> str:
+        pp_lang = ffi.new("char **")
+        _check_error(lib.prism_backend_get_voice_language(self._raw, idx, pp_lang))
+        return ffi.string(pp_lang[0]).decode("utf-8")
+
+    @property
+    def voice(self) -> int:
+        out_voice_id = ffi.new("size_t*")
+        _check_error(lib.prism_backend_get_voice(self._raw, out_voice_id))
+        return out_voice_id[0]
+
+    @voice.setter
+    def voice(self, idx: int) -> None:
+        return _check_error(lib.prism_backend_set_voice(self._raw, idx))
+
+    @property
+    def channels(self) -> int:
+        out_channels = ffi.new("size_t*")
+        _check_error(lib.prism_backend_get_channels(self._raw, out_channels))
+        return out_channels[0]
+
+    @property
+    def sample_rate(self) -> int:
+        out_sample_rate = ffi.new("size_t*")
+        _check_error(lib.prism_backend_get_sample_rate(self._raw, out_sample_rate))
+        return out_sample_rate[0]
+
+    @property
+    def bit_depth(self) -> int:
+        out_bit_depth = ffi.new("size_t*")
+        _check_error(lib.prism_backend_get_bit_depth(self._raw, out_bit_depth))
+        return out_bit_depth[0]
+
+
+class Context:
+    _ctx: lib.PrismContext = None
+
+    def __init__(self, hwnd: HWND | int | None = None) -> None:
+        config = lib.prism_config_init()
+        if hwnd is not None:
+            config.platform_data = ffi.cast("void*", int(hwnd))
+        self._ctx = lib.prism_init(ffi.new("PrismConfig *", config))
+        if self._ctx == ffi.NULL:
+            raise RuntimeError("Prism could not be initialized")
+
+    def __del__(self):
+        if hasattr(self, "_ctx") and self._ctx:
+            lib.prism_shutdown(self._ctx)
+            self._ctx = None
+
+    @property
+    def backends_count(self) -> int:
+        return lib.prism_registry_count(self._ctx)
+
+    def id_of(self, index_or_name: int | str) -> BackendId:
+        if isinstance(index_or_name, int):
+            res = lib.prism_registry_id_at(self._ctx, index_or_name)
+        elif isinstance(index_or_name, str):
+            res = lib.prism_registry_id(self._ctx, index_or_name.encode("utf-8"))
+        else:
+            raise TypeError("Expected int or string")
+        try:
+            return BackendId(res)
+        except ValueError as e:
+            raise ValueError(f"Prism returned unknown backend ID: {res:#x}") from e
+
+    def name_of(self, backend_id: BackendId) -> str:
+        c_ptr = lib.prism_registry_name(self._ctx, backend_id)
+        if c_ptr == ffi.NULL:
+            raise ValueError("Backend ID not found")
+        return ffi.string(c_ptr).decode("utf-8")
+
+    def priority_of(self, backend_id: BackendId) -> int:
+        return lib.prism_registry_priority(self._ctx, backend_id)
+
+    def exists(self, backend_id: BackendId) -> bool:
+        return bool(lib.prism_registry_exists(self._ctx, backend_id))
+
+    def create(self, backend_id: BackendId) -> Backend:
+        res = lib.prism_registry_create(self._ctx, int(backend_id))
+        if res == ffi.NULL:
+            raise ValueError("Invalid or unsupported backend")
+        return Backend(res)
+
+    def create_best(self) -> Backend:
+        res = lib.prism_registry_create_best(self._ctx)
+        if res == ffi.NULL:
+            raise ValueError("Invalid or unsupported backend")
+        return Backend(res)
+
+    def acquire(self, backend_id: BackendId) -> Backend:
+        res = lib.prism_registry_acquire(self._ctx, int(backend_id))
+        if res == ffi.NULL:
+            raise ValueError("Invalid or unsupported backend")
+        return Backend(res)
+
+    def acquire_best(self) -> Backend:
+        res = lib.prism_registry_acquire_best(self._ctx)
+        if res == ffi.NULL:
+            raise ValueError("Invalid or unsupported backend")
+        return Backend(res)

prism/lib.py

@@ -0,0 +1,230 @@
+import contextlib
+import importlib
+import os
+import sys
+from pathlib import Path
+
+from cffi import FFI
+
+
+def _find_native_dir() -> str:
+    local_path = Path(__file__).parent / "_native"
+    if local_path.exists() and any(local_path.iterdir()):
+        return local_path
+    relative_path = Path("prism") / "_native"
+    for path in sys.path:
+        if not path:
+            continue
+        candidate = Path(path) / relative_path
+        if (candidate / "prism.dll").exists():
+            return candidate.resolve()
+
+    return local_path
+
+
+dll_home = _find_native_dir()
+with contextlib.suppress(AttributeError):
+    os.add_dll_directory(str(dll_home))
+
+
+def _is_android() -> bool:
+    with contextlib.suppress(ImportError):
+        if importlib.util.find_spec("", "android") is not None:
+            return True
+    if sys.platform == "linux":
+        with contextlib.suppress(FileNotFoundError), Path("/system/build.prop").open():
+            return True
+    return False
+
+
+ffi = FFI()
+if sys.platform == "win32" or _is_android():
+    ffi.cdef(r"""// SPDX-License-Identifier: MPL-2.0
+
+typedef struct PrismContext PrismContext;
+typedef struct PrismBackend PrismBackend;
+typedef uint64_t PrismBackendId;
+typedef struct {
+  uint8_t version;
+  void* platform_data;
+} PrismConfig;
+
+typedef enum PrismError {
+  PRISM_OK = 0,
+  PRISM_ERROR_NOT_INITIALIZED,
+  PRISM_ERROR_INVALID_PARAM,
+  PRISM_ERROR_NOT_IMPLEMENTED,
+  PRISM_ERROR_NO_VOICES,
+  PRISM_ERROR_VOICE_NOT_FOUND,
+  PRISM_ERROR_SPEAK_FAILURE,
+  PRISM_ERROR_MEMORY_FAILURE,
+  PRISM_ERROR_RANGE_OUT_OF_BOUNDS,
+  PRISM_ERROR_INTERNAL,
+  PRISM_ERROR_NOT_SPEAKING,
+  PRISM_ERROR_NOT_PAUSED,
+  PRISM_ERROR_ALREADY_PAUSED,
+  PRISM_ERROR_INVALID_UTF8,
+  PRISM_ERROR_INVALID_OPERATION,
+  PRISM_ERROR_ALREADY_INITIALIZED,
+  PRISM_ERROR_BACKEND_NOT_AVAILABLE,
+  PRISM_ERROR_UNKNOWN,
+  PRISM_ERROR_COUNT
+} PrismError;
+
+typedef void(PrismAudioCallback)(
+    void *userdata, const float *samples, size_t sample_count,
+    size_t channels, size_t sample_rate);
+
+PrismConfig prism_config_init(void);
+PrismContext *prism_init(PrismConfig* cfg);
+void prism_shutdown(PrismContext *ctx);
+size_t prism_registry_count(PrismContext *ctx);
+PrismBackendId prism_registry_id_at(PrismContext *ctx, size_t index);
+PrismBackendId prism_registry_id(PrismContext *ctx, const char *name);
+const char *prism_registry_name(PrismContext *ctx, PrismBackendId id);
+int prism_registry_priority(PrismContext *ctx, PrismBackendId id);
+bool prism_registry_exists(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_get(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_create(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_create_best(PrismContext *ctx);
+PrismBackend *prism_registry_acquire(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_acquire_best(PrismContext *ctx);
+void prism_backend_free(PrismBackend *backend);
+const char *prism_backend_name(PrismBackend *backend);
+PrismError prism_backend_initialize(PrismBackend *backend);
+PrismError prism_backend_speak(PrismBackend *backend, const char *text, bool interrupt);
+PrismError prism_backend_speak_to_memory(
+    PrismBackend *backend,
+    const char *text,
+    PrismAudioCallback callback,
+    void *userdata
+);
+PrismError prism_backend_braille(PrismBackend *backend, const char *text);
+PrismError prism_backend_output(PrismBackend *backend, const char *text, bool interrupt);
+PrismError prism_backend_stop(PrismBackend *backend);
+PrismError prism_backend_pause(PrismBackend *backend);
+PrismError prism_backend_resume(PrismBackend *backend);
+PrismError prism_backend_is_speaking(PrismBackend *backend, bool *out_speaking);
+PrismError prism_backend_set_volume(PrismBackend *backend, float volume);
+PrismError prism_backend_get_volume(PrismBackend *backend, float *out_volume);
+PrismError prism_backend_set_rate(PrismBackend *backend, float rate);
+PrismError prism_backend_get_rate(PrismBackend *backend, float *out_rate);
+PrismError prism_backend_set_pitch(PrismBackend *backend, float pitch);
+PrismError prism_backend_get_pitch(PrismBackend *backend, float *out_pitch);
+PrismError prism_backend_refresh_voices(PrismBackend *backend);
+PrismError prism_backend_count_voices(PrismBackend *backend, size_t *out_count);
+PrismError prism_backend_get_voice_name(
+    PrismBackend *backend,
+    size_t voice_id,
+    const char **out_name
+);
+PrismError prism_backend_get_voice_language(
+    PrismBackend *backend,
+    size_t voice_id,
+    const char **out_language
+);
+PrismError prism_backend_set_voice(PrismBackend *backend, size_t voice_id);
+PrismError prism_backend_get_voice(PrismBackend *backend, size_t *out_voice_id);
+PrismError prism_backend_get_channels(PrismBackend *backend, size_t *out_channels);
+PrismError prism_backend_get_sample_rate(PrismBackend *backend, size_t *out_sample_rate);
+PrismError prism_backend_get_bit_depth(PrismBackend *backend, size_t *out_bit_depth);
+const char *prism_error_string(PrismError error);
+""")
+else:
+    ffi.cdef(r"""// SPDX-License-Identifier: MPL-2.0
+
+typedef struct PrismContext PrismContext;
+typedef struct PrismBackend PrismBackend;
+typedef uint64_t PrismBackendId;
+typedef struct {
+  uint8_t version;
+} PrismConfig;
+
+typedef enum PrismError {
+  PRISM_OK = 0,
+  PRISM_ERROR_NOT_INITIALIZED,
+  PRISM_ERROR_INVALID_PARAM,
+  PRISM_ERROR_NOT_IMPLEMENTED,
+  PRISM_ERROR_NO_VOICES,
+  PRISM_ERROR_VOICE_NOT_FOUND,
+  PRISM_ERROR_SPEAK_FAILURE,
+  PRISM_ERROR_MEMORY_FAILURE,
+  PRISM_ERROR_RANGE_OUT_OF_BOUNDS,
+  PRISM_ERROR_INTERNAL,
+  PRISM_ERROR_NOT_SPEAKING,
+  PRISM_ERROR_NOT_PAUSED,
+  PRISM_ERROR_ALREADY_PAUSED,
+  PRISM_ERROR_INVALID_UTF8,
+  PRISM_ERROR_INVALID_OPERATION,
+  PRISM_ERROR_ALREADY_INITIALIZED,
+  PRISM_ERROR_BACKEND_NOT_AVAILABLE,
+  PRISM_ERROR_UNKNOWN,
+  PRISM_ERROR_COUNT
+} PrismError;
+
+typedef void(PrismAudioCallback)(
+    void *userdata, const float *samples, size_t sample_count,
+    size_t channels, size_t sample_rate);
+
+PrismConfig prism_config_init(void);
+PrismContext *prism_init(PrismConfig* cfg);
+void prism_shutdown(PrismContext *ctx);
+size_t prism_registry_count(PrismContext *ctx);
+PrismBackendId prism_registry_id_at(PrismContext *ctx, size_t index);
+PrismBackendId prism_registry_id(PrismContext *ctx, const char *name);
+const char *prism_registry_name(PrismContext *ctx, PrismBackendId id);
+int prism_registry_priority(PrismContext *ctx, PrismBackendId id);
+bool prism_registry_exists(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_get(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_create(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_create_best(PrismContext *ctx);
+PrismBackend *prism_registry_acquire(PrismContext *ctx, PrismBackendId id);
+PrismBackend *prism_registry_acquire_best(PrismContext *ctx);
+void prism_backend_free(PrismBackend *backend);
+const char *prism_backend_name(PrismBackend *backend);
+PrismError prism_backend_initialize(PrismBackend *backend);
+PrismError prism_backend_speak(PrismBackend *backend, const char *text, bool interrupt);
+PrismError prism_backend_speak_to_memory(
+    PrismBackend *backend,
+    const char *text,
+    PrismAudioCallback callback,
+    void *userdata
+);
+PrismError prism_backend_braille(PrismBackend *backend, const char *text);
+PrismError prism_backend_output(PrismBackend *backend, const char *text, bool interrupt);
+PrismError prism_backend_stop(PrismBackend *backend);
+PrismError prism_backend_pause(PrismBackend *backend);
+PrismError prism_backend_resume(PrismBackend *backend);
+PrismError prism_backend_is_speaking(PrismBackend *backend, bool *out_speaking);
+PrismError prism_backend_set_volume(PrismBackend *backend, float volume);
+PrismError prism_backend_get_volume(PrismBackend *backend, float *out_volume);
+PrismError prism_backend_set_rate(PrismBackend *backend, float rate);
+PrismError prism_backend_get_rate(PrismBackend *backend, float *out_rate);
+PrismError prism_backend_set_pitch(PrismBackend *backend, float pitch);
+PrismError prism_backend_get_pitch(PrismBackend *backend, float *out_pitch);
+PrismError prism_backend_refresh_voices(PrismBackend *backend);
+PrismError prism_backend_count_voices(PrismBackend *backend, size_t *out_count);
+PrismError prism_backend_get_voice_name(
+    PrismBackend *backend,
+    size_t voice_id,
+    const char **out_name
+);
+PrismError prism_backend_get_voice_language(
+    PrismBackend *backend,
+    size_t voice_id,
+    const char **out_language
+);
+PrismError prism_backend_set_voice(PrismBackend *backend, size_t voice_id);
+PrismError prism_backend_get_voice(PrismBackend *backend, size_t *out_voice_id);
+PrismError prism_backend_get_channels(PrismBackend *backend, size_t *out_channels);
+PrismError prism_backend_get_sample_rate(PrismBackend *backend, size_t *out_sample_rate);
+PrismError prism_backend_get_bit_depth(PrismBackend *backend, size_t *out_bit_depth);
+const char *prism_error_string(PrismError error);
+""")
+if sys.platform == "win32":
+    lib_path = (dll_home / "prism.dll").resolve()
+elif sys.platform == "darwin":
+    lib_path = (dll_home / "libprism.dylib").resolve()
+else:
+    lib_path = (dll_home / "libprism.so").resolve()
+lib = ffi.dlopen(str(lib_path))

prismatoid-0.4.5.dist-info/METADATA

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: prismatoid
+Version: 0.4.5
+Summary: The Platform-Agnostic Reader Interface for Speech and Messages
+Author-Email: Ethin Probst <ethindp@pm.me>
+License-Expression: MPL-2.0
+License-File: LICENSE
+License-File: LICENSES/nvdaController/lgpl-2.1.txt
+License-File: LICENSES/nvgt/LICENSE.md
+License-File: LICENSES/prism/mpl-2.0.txt
+License-File: LICENSES/simdutf/apache-2.0.txt
+License-File: NOTICE
+Requires-Python: >=3.10
+Requires-Dist: cffi>=1.0.0
+Requires-Dist: win32more>=0.8.0; sys_platform == "win32"
+Description-Content-Type: text/markdown
+
+# PRISM
+
+Prism is the Platform-agnostic Reader Interface for Speech and Messages. Since that's a hell of a mouthful, we just call it Prism for short. The name comes from prisms in optics, which are transparent optical components with flat surfaces that refract light into many beams. Thus, the metaphor: refract your TTS strings to send them to many different backends, potentially simultaneously.
+
+Prism aims to unify the various screen reader abstraction libraries like SpeechCore, UniversalSpeech, SRAL, Tolk, etc., into a single unified system with a single unified API. Of course, we also support traditional TTS engines. I have tried to develop Prism in such a way that compilation is trivial and requires no external dependencies. To that end, the CMake builder will download all needed dependencies. However, since it uses [cpm.cmake](https://github.com/cpm-cmake/CPM.cmake), vendoring of dependencies is very possible.
+
+## Building
+
+To build Prism, all you need do is create a build directory and run cmake as you ordinarily would. The only build option at this time is `PRISM_ENABLE_TESTS`, which will determine whether the test suite is built or not. In the 99 percent of cases, you should disable this option, since running the tests is only for validating that the library functions correctly. However, the tests have currently known problems and are still in a very early stage of development, so validation is platform-dependent and may fail in very strange ways on other platforms than Windows. (Specifically, failure is known to happen on at least MacOS, due to the header's various compiler attributes in use.)
+
+## Documentation
+
+Documentation uses [mdbook](https://github.com/rust-lang/mdBook). To view it offline, install mdbook and then run `mdbook serve` from the doc directory.
+
+## API
+
+The API is fully documented in the documentation above. If the documentation and header do not align in guarantees or expectations, this is a bug and should be reported.
+
+## Bindings
+
+Currently bindings are an in-progress effort. We are working on bindings to at least Python and .NET, although both will take a bit of time to actually do. If you wish to contribute bindings, please don't hesitate to open a pull request. Your bindings must obey the restrictions in the documentation; specifically, where the documentation requires something to not occur, your bindings MUST prohibit that occurence before calling any Prism C API function. For example, calling `prism_backend_speak` with a `NULL` backend or text string MUST be prohibited by your bindings.
+
+## License
+
+This project is licensed under the Mozilla Public License version 2.0. Full details are available in the LICENSE file.
+
+This project uses code from other projects. Specifically:
+
+* The SAPI bridge is credited to the [NVGT](https://github.com/samtupy/nvgt) project, as well as the functions `range_convert` and `range_convert_midpoint` in utils.h and utils.cpp. Similar attribution goes to NVGT for the Android screen reader backend.
+* The `simdutf` library is licensed under the Apache-2.0 license.
+* On Windows, Prism includes NVDA controller client RPC definitions under LGPL-2.1 (and generated RPC stubs from those inputs). Those portions remain under LGPL-2.1. See licenses/ and idl/ for the actual texts. On all non-Windows platforms, this does not apply, however the LGPL licenses are included for completeness in all SDKs.
+
+## Contributing
+
+Contributions are welcome. This includes, but is not limited to, documentation enhancements, new backends, bindings, build system improvements, etc. The project uses C++23 so please ensure that your compiler supports that standard.
+

prismatoid-0.4.5.dist-info/RECORD

@@ -0,0 +1,22 @@
+prism/__init__.py,sha256=hvOVuGBvJt49J93-RVCaqhoVp2a8u-Kuta1V2j3sa1s,127
+prism/core.py,sha256=C8IZwU_Q27ZGY6U3nXrnTRF4p_Jt-yKABGwIGVssrXw,12136
+prism/lib.py,sha256=GkVMQrCrJ_0fXx28aulL5v6wMW1YZ0-itVOsqLumA8U,9162
+prism/_native/libprism.so,sha256=eau5YBk-QljcwkW6LwSwmWqVCvIlkr8SztrgMPLTbgs,950241
+prismatoid.libs/libblkid-78417c21.so.1.1.0,sha256=QqZ-GpXrrYD8Z-TLU44NwleXfE2ia_rcK1yLWFb7PnI,238513
+prismatoid.libs/libgio-2-867cbb79.0.so.0.6800.4,sha256=2DOZ884qBG1HYMKg0a88c1oSLlSJFPc27SGln6hy_tU,2121369
+prismatoid.libs/libgmodule-2-75c2a560.0.so.0.6800.4,sha256=8ZfC-XXe7zATWQ1CQz-7Gl2Y9LhPGQP5HO2H0bgf1yU,22505
+prismatoid.libs/libltdl-ffb4ec7a.so.7,sha256=taLEZits6e1U8TMtnuz-OsGiis3gVT14hW0ZSZ0QuTc,41121
+prismatoid.libs/libmount-935e7fa5.so.1.1.0,sha256=AbqJJuAlYyHYYihRNVFaEWLSMeug5EsfyZQo4b49H98,315697
+prismatoid.libs/libpcre2-8-b77f698a.so.0.11.0,sha256=hQ2wPgk-6gm4ZYWGy6wPDCt46HtNTpYIRBUyH9Fq-9U,642033
+prismatoid.libs/libselinux-a1ff09bf.so.1,sha256=7Y8jm3YrZ3BrrNxLFY1Bto0ik3_YTQYg8_rrT14cEiE,195361
+prismatoid.libs/libspeechd-900e1c56.so.2.6.0,sha256=BF07fd9prhIVoWos6whZin2APQ4AVtHTOgvPd8Yr9wU,60001
+prismatoid-0.4.5.dist-info/METADATA,sha256=6xAGZf4snAyJlm7AGci8ZfLA8Jz0OMR8-wfQ2mF6R6M,4227
+prismatoid-0.4.5.dist-info/WHEEL,sha256=47S8GfAIuXQZhoya3X2DlgmMrDYgF2L6qDW1EsYZuBA,118
+prismatoid-0.4.5.dist-info/RECORD,,
+prismatoid-0.4.5.dist-info/licenses/LICENSE,sha256=bJjy9y1AlJwaGk73Q5A_oHcZ2pQdzPH7dHnRwV8Fq3o,15504
+prismatoid-0.4.5.dist-info/licenses/NOTICE,sha256=v4o4GrCMWTkwIOfhO_SKDv44i_qA69vtbRf-z1xfn44,886
+prismatoid-0.4.5.dist-info/licenses/LICENSES/nvdaController/lgpl-2.1.txt,sha256=2DCML-JO2IgZa8Uj30YhR1kAjYd-IlK0jM3ajiuO1Rs,25967
+prismatoid-0.4.5.dist-info/licenses/LICENSES/nvgt/LICENSE.md,sha256=v_AyXYuvXEo6Ra4_2yZ5tOzk8TpmevvhIRozYbtjzQI,903
+prismatoid-0.4.5.dist-info/licenses/LICENSES/prism/mpl-2.0.txt,sha256=ZsEFNaSV9M2BFWB-iQ-BFtZXBkuYVX9mDFHhI7Pz_uY,15190
+prismatoid-0.4.5.dist-info/licenses/LICENSES/simdutf/apache-2.0.txt,sha256=wnT4A3LZDAEpNzcPDh8VCH0i4wjvmLJ86l3A0tCINmw,10279
+prismatoid-0.4.5.dist-info/sboms/auditwheel.cdx.json,sha256=hu8LBuxzaChdW7GgFH3a1lsuPbvsMCP91CrhZKTGsDc,4107