openspeechapi 0.2.3__tar.gz → 0.2.5__tar.gz

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openspeechapi
-Version: 0.2.3
+Version: 0.2.5
 Summary: Unified speech interface for STT/TTS providers
 Requires-Python: >=3.11
 Requires-Dist: httpx>=0.27

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/openspeechapi/__init__.py

@@ -1,6 +1,6 @@
 """OpenSpeechAPI — Unified speech interface for STT/TTS providers."""
 
-__version__ = "0.2.3"
+__version__ = "0.2.5"
 
 from openspeechapi.config import load_config
 from openspeechapi.core.base import SpeechProvider, STTProvider, TTSProvider

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/openspeechapi/core/models.py

@@ -50,6 +50,16 @@ class STTOptions:
     beam_size: int | None = None
     compute_type: str | None = None
     fp16: bool | None = None
+    # Per-call override for the trailing-silence threshold (ms) before
+    # the provider treats utterance as ended. ``None`` means "use the
+    # provider's configured default" (e.g. iflytek's ``settings.vad_eos``
+    # populated from speech_providers.yaml). Wallex passes the
+    # panel-supplied ``parameter.iat.eos`` here when the panel needs a
+    # different value than the deployment default — for instance a
+    # kiosk that wants more responsive cut-off than a slow-paced
+    # voice assistant. Providers that don't support VAD finalization
+    # (Whisper, Faster-Whisper) silently ignore this field.
+    vad_eos: int | None = None
 
 
 @dataclass

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/openspeechapi/dispatch/dispatcher.py

@@ -114,9 +114,17 @@ class _STTNamespace:
         self,
         provider: str,
         stream: "AsyncIterator[bytes]",
+        opts: "STTOptions | None" = None,
     ) -> "AsyncIterator[Transcription]":
-        """Stream audio chunks to the named provider and yield transcriptions."""
-        async for item in self._dispatcher._transcribe_stream(provider, stream):
+        """Stream audio chunks to the named provider and yield transcriptions.
+
+        ``opts`` is optional and forwarded to the provider's
+        ``transcribe_stream`` if it declares the parameter (current users:
+        iFlytek STT honors ``opts.vad_eos`` for per-call silence-threshold
+        override). Providers that don't declare ``opts`` raise TypeError;
+        callers that don't need the override should leave it ``None``.
+        """
+        async for item in self._dispatcher._transcribe_stream(provider, stream, opts):
             yield item
 
     async def fanout(
@@ -479,8 +487,14 @@ class ServiceDispatcher:
         self,
         provider: str,
         stream: AsyncIterator[bytes],
+        opts: STTOptions | None = None,
     ) -> AsyncIterator[Transcription]:
-        """Stream audio chunks to the provider and yield Transcription results."""
+        """Stream audio chunks to the provider and yield Transcription results.
+
+        ``opts`` is forwarded to the provider only when non-None — keeps
+        the call site backward-compatible with providers whose
+        ``transcribe_stream`` predates the ``opts`` parameter.
+        """
         handle = self._get_handle(provider)
         await self._lifecycle.ensure_ready(provider)
         ctx = InvokeContext(
@@ -488,6 +502,11 @@ class ServiceDispatcher:
             method="transcribe_stream",
             exec_mode=handle.exec_mode,
         )
+        # Build kwargs conditionally so providers without ``opts`` in
+        # their signature don't get a surprise unexpected-keyword error.
+        invoke_kwargs: dict[str, Any] = {"stream": stream}
+        if opts is not None:
+            invoke_kwargs["opts"] = opts
         with bind_context(
             provider=provider, engine=provider, request_id=ctx.request_id
         ):
@@ -500,7 +519,7 @@ class ServiceDispatcher:
                 count = 0
                 try:
                     async for item in handle.executor.invoke_stream(
-                        "transcribe_stream", stream=stream
+                        "transcribe_stream", **invoke_kwargs
                     ):
                         count += 1
                         yield item

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/openspeechapi/logging_config.py

@@ -185,10 +185,24 @@ def bind_context(
         if v is not None:
             bindings[k] = v
 
+    # NOTE: we drive logger.contextualize manually instead of using its
+    # ``with`` form so we can swallow the cleanup-time ValueError that
+    # loguru raises when bind_context wraps a ``yield`` in an async
+    # generator and that generator is closed from a different asyncio
+    # Context (e.g. the consumer task gets cancelled). The token loguru
+    # tries to reset was set in the original Context and Python forbids
+    # cross-context reset. The bindings are scoped to the closing
+    # Context anyway, so dropping the reset is harmless — Python GCs the
+    # vanishing Context's vars regardless.
+    contextualizer = logger.contextualize(**bindings)
+    contextualizer.__enter__()
     try:
-        with logger.contextualize(**bindings):
-            yield bindings
+        yield bindings
     finally:
+        try:
+            contextualizer.__exit__(None, None, None)
+        except ValueError:
+            pass
         for var, token in reversed(resets):
             try:
                 var.reset(token)

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/openspeechapi/providers/stt/iflytek.py

@@ -216,10 +216,18 @@ class IflytekSTT(STTProvider):
                     # confuses anyone reading the request body, so
                     # gate it on the canonical language.
                     canon = _canonical_language(self.settings.language)
+                    # Per-call override (``opts.vad_eos``) trumps the
+                    # provider default. Wallex routes the panel's
+                    # ``parameter.iat.eos`` through here so a kiosk
+                    # can ship a tighter or looser silence threshold
+                    # than the deployment yaml.
+                    eos = (opts.vad_eos
+                           if opts is not None and opts.vad_eos is not None
+                           else self.settings.vad_eos)
                     business = {
                         "language": canon,
                         "domain": "iat",
-                        "vad_eos": self.settings.vad_eos,
+                        "vad_eos": eos,
                     }
                     if canon == "zh_cn":
                         business["accent"] = "mandarin"
@@ -288,7 +296,7 @@ class IflytekSTT(STTProvider):
         return "".join(parts)
 
     async def transcribe_stream(
-        self, stream: AsyncIterator[bytes]
+        self, stream: AsyncIterator[bytes], opts: STTOptions | None = None,
     ) -> AsyncIterator[Transcription]:
         """Stream audio chunks to iFlytek via WebSocket and yield transcriptions.
 
@@ -345,11 +353,17 @@ class IflytekSTT(STTProvider):
                             # See transcribe() for rationale on
                             # canonicalizing language and gating accent.
                             canon = _canonical_language(self.settings.language)
+                            # Per-call ``opts.vad_eos`` (e.g. wallex
+                            # forwarding the panel's ``parameter.iat.eos``)
+                            # trumps the provider's configured default.
+                            eos = (opts.vad_eos
+                                   if opts is not None and opts.vad_eos is not None
+                                   else self.settings.vad_eos)
                             business = {
                                 "language": canon,
                                 "domain": "iat",
                                 "dwa": "wpgs",
-                                "vad_eos": self.settings.vad_eos,
+                                "vad_eos": eos,
                             }
                             if canon == "zh_cn":
                                 business["accent"] = "mandarin"

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "openspeechapi"
-version = "0.2.3"
+version = "0.2.5"
 description = "Unified speech interface for STT/TTS providers"
 requires-python = ">=3.11"
 dependencies = [

{openspeechapi-0.2.3 → openspeechapi-0.2.5}/tests/unit/test_logging.py

@@ -96,6 +96,38 @@ def test_bind_context_sets_and_resets_request_id() -> None:
     assert get_request_id() is None
 
 
+def test_bind_context_aclose_from_different_asyncio_context_does_not_raise() -> None:
+    """When bind_context wraps a yield in an async generator and the generator
+    is later closed from a different asyncio Context, loguru's
+    contextualize.__exit__ raises
+    ``ValueError("<Token ...> was created in a different Context")``.
+
+    Production trace (2026-05-06): openspeechapi/dispatch/dispatcher.py
+    ``_synthesize_stream`` holds bind_context across ``yield chunk``; when
+    the consumer's task is cancelled, athrow runs the finally in a new
+    Context and the unhandled ValueError pollutes the log.
+
+    bind_context must swallow that cleanup error.
+    """
+    import asyncio
+
+    async def gen():
+        with bind_context(request_id="rid", provider="prov"):
+            for i in range(3):
+                yield i
+
+    async def driver():
+        g = gen()
+        first = await g.__anext__()
+        assert first == 0
+        # Closing from a freshly-created task puts aclose in a different
+        # asyncio Context than where bind_context was entered. This is the
+        # exact mismatch that production hit.
+        await asyncio.create_task(g.aclose())
+
+    asyncio.run(driver())
+
+
 def test_bind_context_decorates_log_records(tmp_path: Path) -> None:
     configure_logging(level="DEBUG", format="json", log_dir=str(tmp_path))
     captured: list[dict] = []