knowlsttclient 0.4.2__tar.gz

knowlsttclient-0.4.2/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: knowlsttclient
+Version: 0.4.2
+Summary: Python client for real-time streaming speech-to-text
+Requires-Dist: protobuf
+Requires-Dist: requests
+Requires-Dist: websockets

knowlsttclient-0.4.2/README.md

@@ -0,0 +1,116 @@
+# Parakeet Hindi ASR - Triton Inference Server
+
+This repository contains the Triton Inference Server configuration for serving the `parakeet-knowl-hindi.nemo` ASR model.
+
+## Model Repository Structure
+
+```
+model_repository/
+└── parakeet_hindi/
+    ├── config.pbtxt      # Triton configuration
+    └── 1/
+        └── model.py      # Python backend that loads the .nemo file
+```
+
+## Run Triton Server
+
+```bash
+docker run --gpus all --rm -it \
+  -p 8000:8000 -p 8001:8001 -p 8002:8002 \
+  -v /home/ubuntu/triton_work/model_repository:/models \
+  -v /home/ubuntu/hf_models:/home/ubuntu/hf_models:ro \
+  triton-parakeet-server:latest \
+  tritonserver --model-repository=/models
+```
+
+### Ports
+
+- `8000`: HTTP endpoint
+- `8001`: gRPC endpoint
+- `8002`: Metrics endpoint
+
+
+## Input/Output Specification
+
+### Inputs
+
+| Name | Data Type | Shape | Description |
+|------|-----------|-------|-------------|
+| AUDIO_SIGNAL | FP32 | [-1] | 1D array of audio samples (16 kHz mono, normalized) |
+| AUDIO_LENGTH | INT32 | [1] | Number of valid audio samples |
+
+### Outputs
+
+| Name | Data Type | Shape | Description |
+|------|-----------|-------|-------------|
+| TRANSCRIPT | STRING | [1] | Transcribed text |
+
+# Setting up VM instance
+## Create VM Instance
+```
+VM_INSTANCE_NAME='knowl-stt-inference'
+ZONE='asia-south1-c'
+gcloud compute instances create $VM_INSTANCE_NAME --project=tribal-datum-361011 --zone=$ZONE --machine-type=g2-standard-8 --network-interface=network-tier=PREMIUM,stack-type=IPV4_ONLY,subnet=default --metadata=enable-osconfig=TRUE --maintenance-policy=TERMINATE --provisioning-model=STANDARD --service-account=44392650498-compute@developer.gserviceaccount.com --scopes=https://www.googleapis.com/auth/devstorage.read_only,https://www.googleapis.com/auth/logging.write,https://www.googleapis.com/auth/monitoring.write,https://www.googleapis.com/auth/service.management.readonly,https://www.googleapis.com/auth/servicecontrol,https://www.googleapis.com/auth/trace.append --accelerator=count=1,type=nvidia-l4 --create-disk=auto-delete=yes,boot=yes,device-name=knowl-stt-inference,disk-resource-policy=projects/tribal-datum-361011/regions/asia-south1/resourcePolicies/default-schedule-1,image=projects/ubuntu-os-cloud/global/images/ubuntu-minimal-2204-jammy-v20251217,mode=rw,size=50,type=pd-balanced --no-shielded-secure-boot --shielded-vtpm --shielded-integrity-monitoring --labels=goog-ops-agent-policy=v2-x86-template-1-4-0,goog-ec-src=vm_add-gcloud --reservation-affinity=any && printf 'agentsRule:\n  packageState: installed\n  version: latest\ninstanceFilter:\n  inclusionLabels:\n  - labels:\n      goog-ops-agent-policy: v2-x86-template-1-4-0\n' > config.yaml && gcloud compute instances ops-agents policies create goog-ops-agent-v2-x86-template-1-4-0-$ZONE --project=tribal-datum-361011 --zone=$ZONE --file=config.yam
+```
+
+## setup git on the instance
+```
+sudo apt update
+sudo apt install -y git
+USER='bhups@knowl.io'
+ssh-keygen -t ed25519 -C "$USER"
+mkdir -p ~/.ssh && printf "Host github.com\n  AddKeysToAgent yes\n  IdentityFile ~/.ssh/id_ed25519\n" > ~/.ssh/config && chmod 600 ~/.ssh/config
+cat .ssh/id_ed25519.pub # copy content to clipboard and [follow instructions from here](https://docs.github.com/en/authentication/connecting-to-github-with-ssh/adding-a-new-ssh-key-to-your-github-account).
+ssh-keyscan -t ed25519 github.com >> ~/.ssh/known_hosts
+git clone git@github.com:knowl-doc/knowl-stt-inference-server.git
+```
+
+## install drivers
+```
+sudo apt install -y ubuntu-drivers-common
+sudo ubuntu-drivers install
+sudo reboot
+```
+## install cuda-toolkit
+sudo apt install nvidia-cuda-toolkit
+sudo apt install nvtop
+
+## install nvidia container toolkit
+distribution=ubuntu22.04
+curl -fsSL https://nvidia.github.io/nvidia-docker/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
+curl -fsSL https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list   | sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g'   | sudo tee /etc/apt/sources.list.d/nvidia-docker.list
+sudo apt update
+sudo apt install -y nvidia-container-toolkit
+
+## install python venv
+sudo apt install python3.10-venv
+
+## install Docker
+sudo install -m 0755 -d /etc/apt/keyrings
+curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+sudo chmod a+r /etc/apt/keyrings/docker.gpg
+
+echo \
+  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
+  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
+  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+
+sudo apt update
+sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+
+sudo usermod -aG docker $USER
+newgrp docker
+
+## create triton server docker with nemo toolkit
+```docker build -f Dockerfile.triton-nemo-toolkit -t triton-parakeet-server:latest .```
+
+## Create virtual env
+python3 -m venv knowl-env
+pip install -r requirements.txt
+
+## download model
+mkdir -p /home/ubuntu/models
+gsutil cp  gs://knowl-models/parakeet-knowl-hindi.nemo /home/ubuntu/models
+
+## run triton server on docker
+docker run --gpus all --rm -it   -p 8000:8000 -p 8001:8001 -p 8002:8002   -v /home/ubuntu/knowl-stt-inference-server/model_repository:/models   -v /home/ubuntu/models:/home/ubuntu/models:ro   triton-parakeet-server:latest   tritonserver --model-repository=/models

knowlsttclient-0.4.2/knowlsttclient/__init__.py

@@ -0,0 +1,5 @@
+from .streaming_client import StreamingClient, TritonTranscriptionClient
+
+# StreamingClient is the public name; TritonTranscriptionClient is a deprecated
+# alias kept for backwards compatibility (to be removed once all callers migrate).
+__all__ = ["StreamingClient", "TritonTranscriptionClient"]

knowlsttclient-0.4.2/knowlsttclient/proto/__init__.py

@@ -0,0 +1,4 @@
+from .transcription_event_pb2 import TranscriptionEvent
+from .control_message_pb2 import ControlMessage
+
+__all__ = ["TranscriptionEvent", "ControlMessage"]

knowlsttclient-0.4.2/knowlsttclient/proto/control_message_pb2.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: control_message.proto
+# Protobuf Python Version: 4.25.3
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x15\x63ontrol_message.proto\"\x9c\x01\n\x0e\x43ontrolMessage\x12)\n\x04type\x18\x01 \x01(\x0e\x32\x1b.ControlMessage.MessageType\x12\x0c\n\x04\x64\x61ta\x18\x02 \x01(\x0c\x12\x10\n\x08metadata\x18\x03 \x01(\t\"?\n\x0bMessageType\x12\t\n\x05MEDIA\x10\x00\x12\x0c\n\x08METADATA\x10\x01\x12\t\n\x05\x43LOSE\x10\x02\x12\x0c\n\x08\x46INALIZE\x10\x03\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'control_message_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_CONTROLMESSAGE']._serialized_start=26
+  _globals['_CONTROLMESSAGE']._serialized_end=182
+  _globals['_CONTROLMESSAGE_MESSAGETYPE']._serialized_start=119
+  _globals['_CONTROLMESSAGE_MESSAGETYPE']._serialized_end=182
+# @@protoc_insertion_point(module_scope)

knowlsttclient-0.4.2/knowlsttclient/proto/transcription_event_pb2.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: transcription_event.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x19transcription_event.proto\"\xb3\x02\n\x12TranscriptionEvent\x12+\n\x04type\x18\x01 \x01(\x0e\x32\x1d.TranscriptionEvent.EventType\x12\x12\n\ntranscript\x18\x02 \x01(\t\x12\x12\n\nstart_time\x18\x03 \x01(\x02\x12\x10\n\x08\x65nd_time\x18\x04 \x01(\x02\x12\x1d\n\x15vad_speech_start_time\x18\x05 \x01(\x02\x12\x19\n\x11speech_start_time\x18\x06 \x01(\x02\x12\x17\n\x0fspeech_end_time\x18\x07 \x01(\x02\x12\x10\n\x08is_final\x18\x08 \x01(\x08\"Q\n\tEventType\x12\x0e\n\nTRANSCRIPT\x10\x00\x12\n\n\x06\x43LOSED\x10\x01\x12\x14\n\x10VAD_SPEECH_START\x10\x02\x12\x12\n\x0eVAD_SPEECH_END\x10\x03\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'transcription_event_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _TRANSCRIPTIONEVENT._serialized_start=30
+  _TRANSCRIPTIONEVENT._serialized_end=337
+  _TRANSCRIPTIONEVENT_EVENTTYPE._serialized_start=256
+  _TRANSCRIPTIONEVENT_EVENTTYPE._serialized_end=337
+# @@protoc_insertion_point(module_scope)

knowlsttclient-0.4.2/knowlsttclient/streaming_client.py

@@ -0,0 +1,368 @@
+"""
+Client library for connecting to Triton Inference Server WebSocket for real-time audio transcription.
+
+This library is designed for applications that have their own WebSocket connections to VOIP services
+and receive 8k mono telephony packets. They can use this library to transcribe audio in real-time.
+
+Example usage:
+    import asyncio
+    from knowlsttclient import StreamingClient
+
+    async def on_transcript(transcript: str):
+        print(f"Transcript: {transcript}")
+
+    async def main():
+        client = StreamingClient(
+            server_url="ws://localhost:8765",
+            on_transcript=on_transcript
+        )
+        
+        await client.connect()
+        
+        # Send audio data (8k mono 16-bit PCM)
+        audio_data = b"..."  # Your audio bytes
+        await client.send_audio(audio_data)
+        
+        # Keep connection alive and process transcripts
+        await client.wait_for_transcripts()
+    
+    asyncio.run(main())
+"""
+
+import asyncio
+import json
+import logging
+from typing import Optional, Callable, Awaitable
+import websockets
+from websockets import WebSocketClientProtocol
+from websockets.exceptions import ConnectionClosedOK, ConnectionClosedError
+from knowlsttclient.proto import TranscriptionEvent
+from knowlsttclient.proto import ControlMessage
+import uuid
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(levelname)s] %(name)s - %(message)s",
+)
+logger = logging.getLogger("knowlsttclient")
+
+
+class StreamingClient:
+    """
+    Client for real-time streaming speech-to-text over a WebSocket.
+    
+    The client expects:
+    - Audio format: Mono 16-bit signed PCM (little-endian), 8 kHz sample rate
+    - Audio packets: Typically 20ms chunks (160 samples = 320 bytes)
+    
+    The server will:
+    - Accumulate audio and run VAD (Voice Activity Detection)
+    - Send transcripts as text messages when speech is detected (minimum 1 second of audio)
+    """
+    
+    def __init__(
+        self,
+        server_url: str = "ws://localhost:8765",
+        on_transcript: Optional[Callable[[str], Awaitable[None]]] = None,
+        on_vad_event: Optional[Callable[[str], Awaitable[None]]] = None,
+        on_error: Optional[Callable[[Exception], Awaitable[None]]] = None,
+        on_close: Optional[Callable[[], Awaitable[None]]] = None,
+        auto_reconnect: bool = True,
+        reconnect_delay: float = 5.0,
+        stream_id: Optional[str] = None,
+        stop_history_ms: Optional[int] = None,
+        endpointing: Optional[dict] = None,
+        api_key: Optional[str] = None,
+        sample_rate: int = 8000,
+    ):
+        """
+        Initialize the Triton Transcription Client.
+
+        Args:
+            server_url: WebSocket URL of the Triton inference server (default: ws://localhost:8765)
+            on_transcript: Async callback function called when a transcript is received.
+                          Signature: async def on_transcript(transcript: str) -> None
+            on_error: Async callback function called when an error occurs.
+                     Signature: async def on_error(error: Exception) -> None
+            on_close: Async callback function called when the connection is closed.
+                     Signature: async def on_close() -> None
+            auto_reconnect: Whether to automatically reconnect on connection loss (default: True)
+            reconnect_delay: Delay in seconds before attempting to reconnect (default: 5.0)
+            stream_id: Optional stream ID to identify the stream.
+            stop_history_ms: Optional per-call endpointing duration — trailing
+                silence (ms) before a segment is finalized. Lower = faster finals
+                (lower latency) at the risk of cutting on natural pauses. Sweet
+                spot for telephony is ~300-500 ms. None = use the server default
+                (~800 ms baked into the model). Only honoured by the Riva backend.
+            endpointing: Optional dict for advanced endpointing knobs, any of:
+                stop_history_ms, stop_history_eou_ms, start_history_ms (ints, ms),
+                stop_threshold, stop_threshold_eou, start_threshold (floats, 0..1).
+                ``stop_history_ms`` (the kwarg) takes precedence over this dict.
+            api_key: Optional API key for the gated external endpoint
+                (e.g. wss://voice.knowl.io/stt/v1). Sent as
+                ``Authorization: Bearer <key>`` on the WebSocket handshake.
+                Leave unset for the internal endpoint (no auth).
+            sample_rate: Input PCM sample rate in Hz (default 8000). 8000 is
+                upsampled to 16 kHz server-side; 16000 is sent to the model
+                as-is (no upsampling). Audio must be mono 16-bit PCM at this rate.
+        """
+        self.server_url = server_url
+        self.on_transcript = on_transcript
+        self.on_vad_event = on_vad_event
+        self.on_error = on_error
+        self.on_close = on_close
+        self.auto_reconnect = auto_reconnect
+        self.reconnect_delay = reconnect_delay
+        self.stream_id = stream_id if stream_id else str(uuid.uuid4())
+        self.api_key = api_key
+        self.served_by = None  # serving host (X-Served-By header), set on connect
+        # Input PCM rate. 8000 (default) is upsampled to 16 kHz server-side;
+        # 16000 is sent to the model as-is (no upsampling). Sent in METADATA.
+        self.sample_rate = sample_rate
+        # Assemble per-call endpointing overrides (sent in the METADATA message).
+        self.endpointing: dict = dict(endpointing or {})
+        if stop_history_ms is not None:
+            self.endpointing["stop_history_ms"] = stop_history_ms
+        self.websocket: Optional[WebSocketClientProtocol] = None
+        self._receive_task: Optional[asyncio.Task] = None
+        self._connected = False
+        self._should_reconnect = True
+        
+    def _build_metadata(self) -> str:
+        """Build the METADATA payload. Plain stream_id when there are no
+        endpointing overrides (back-compatible); a JSON object otherwise."""
+        meta = dict(self.endpointing)
+        if self.sample_rate != 8000:
+            meta["sample_rate"] = self.sample_rate
+        if not meta:
+            return self.stream_id
+        return json.dumps({"stream_id": self.stream_id, **meta})
+
+    async def connect(self) -> None:
+        """
+        Connect to the Triton inference server WebSocket.
+
+        Raises:
+            Exception: If connection fails
+        """
+        try:
+            logger.info(f"Connecting to {self.server_url}...")
+            connect_kwargs = {"max_size": None, "max_queue": None}
+            # Only attach an auth header when an API key is set (the internal
+            # fleet is keyless). websockets >= 14 renamed `extra_headers` to
+            # `additional_headers`; pick the kwarg the INSTALLED version accepts
+            # so the client works against both — callers (e.g. the call-manager)
+            # may pin an older websockets that rejects `additional_headers`.
+            if self.api_key:
+                try:
+                    _ws_major = int(websockets.__version__.split(".")[0])
+                except Exception:
+                    _ws_major = 0
+                header_kwarg = "additional_headers" if _ws_major >= 14 else "extra_headers"
+                connect_kwargs[header_kwarg] = {"Authorization": f"Bearer {self.api_key}"}
+            self.websocket = await websockets.connect(self.server_url, **connect_kwargs)
+            self._connected = True
+            # Record the serving host from the handshake response (X-Served-By).
+            # websockets >= 14 exposes .response.headers; < 14 uses .response_headers.
+            try:
+                resp = getattr(self.websocket, "response", None)
+                hdrs = resp.headers if resp is not None else getattr(self.websocket, "response_headers", None)
+                self.served_by = hdrs.get("X-Served-By") if hdrs else None
+            except Exception:
+                self.served_by = None
+            logger.info("Connected to Triton inference server (served_by=%s)", self.served_by)
+            await self.websocket.send(ControlMessage(
+                type=ControlMessage.MessageType.METADATA,
+                metadata=self._build_metadata(),
+            ).SerializeToString())
+            
+            # Start receiving transcripts
+            self._receive_task = asyncio.create_task(self._receive_loop())
+            
+        except Exception as e:
+            self._connected = False
+            logger.error(f"Failed to connect to server: {e}")
+            if self.on_error:
+                await self.on_error(e)
+            raise
+    
+    async def _receive_loop(self) -> None:
+        """Internal loop to receive transcripts from the server."""
+        try:
+            while self._connected and self.websocket:
+                try:
+                    message = await self.websocket.recv()
+                    transcription_event = TranscriptionEvent()
+                    # TODO: Handle bad message
+                    transcription_event.ParseFromString(message)
+                    match transcription_event.type:
+                        case TranscriptionEvent.EventType.TRANSCRIPT:
+                            if self.on_transcript:
+                                try:
+                                    await self.on_transcript(transcription_event)
+                                except Exception as e:
+                                    logger.error(f"Error in on_transcript callback: {e}")
+                                    if self.on_error:
+                                        await self.on_error(e)
+                        case TranscriptionEvent.EventType.VAD_SPEECH_START | TranscriptionEvent.EventType.VAD_SPEECH_END:
+                            if self.on_vad_event:
+                                try:
+                                    await self.on_vad_event(transcription_event)
+                                except Exception as e:
+                                    logger.error(f"Error in on_vad_event callback: {e}")
+                                    if self.on_error:
+                                        await self.on_error(e)
+                        case TranscriptionEvent.EventType.CLOSED:
+                            logger.info("Server closed connection")
+                            self._connected = False
+                            if self.on_close:
+                                await self.on_close()
+                            break
+                        case _:
+                            logger.warning("Received unexpected transcription event type")
+                        
+                except ConnectionClosedOK:
+                    logger.info("Server closed connection cleanly")
+                    self._connected = False
+                    break
+                except ConnectionClosedError as e:
+                    logger.warning(f"Server connection error: {e}")
+                    self._connected = False
+                    break
+                except Exception as e:
+                    logger.error(f"Error receiving message: {e}")
+                    if self.on_error:
+                        await self.on_error(e)
+                    self._connected = False
+                    break
+                    
+        except asyncio.CancelledError:
+            logger.debug("Receive loop cancelled")
+        except Exception as e:
+            logger.error(f"Unexpected error in receive loop: {e}")
+            if self.on_error:
+                await self.on_error(e)
+        finally:
+            self._connected = False
+            if self.on_close:
+                await self.on_close()
+    
+    async def send_audio(self, audio_data: bytes) -> None:
+        """
+        Send audio data to the server for transcription.
+        
+        Args:
+            audio_data: Raw 8 kHz mono 16-bit PCM audio bytes (little-endian)
+            
+        Raises:
+            RuntimeError: If not connected to the server
+            Exception: If sending fails
+        """
+        if not self._connected or not self.websocket:
+            raise RuntimeError("Not connected to server. Call connect() first.")
+        
+        try:
+            await self.websocket.send(ControlMessage(type=ControlMessage.MessageType.MEDIA, data=audio_data).SerializeToString())
+            logger.debug(f"Sent {len(audio_data)} bytes of audio data")
+        except ConnectionClosedOK:
+            logger.warning("Connection closed while sending audio")
+            self._connected = False
+            if self.auto_reconnect and self._should_reconnect:
+                await self._reconnect()
+            raise
+        except ConnectionClosedError as e:
+            logger.warning(f"Connection error while sending audio: {e}")
+            self._connected = False
+            if self.auto_reconnect and self._should_reconnect:
+                await self._reconnect()
+            raise
+        except Exception as e:
+            logger.error(f"Error sending audio: {e}")
+            if self.on_error:
+                await self.on_error(e)
+            raise
+    
+    async def send_close_message(self) -> None:
+        """
+        Send a close message to the server.
+
+        Raises:
+            RuntimeError: If not connected to the server
+            Exception: If sending fails
+        """
+        if not self._connected or not self.websocket:
+            raise RuntimeError("Not connected to server. Call connect() first.")
+        try:
+            await self.websocket.send(ControlMessage(type=ControlMessage.MessageType.CLOSE).SerializeToString())
+            logger.debug(f"Sent close message")
+        except Exception as e:
+            logger.error(f"Error sending close message: {e}")
+            if self.on_error:
+                await self.on_error(e)
+            raise
+
+    async def _reconnect(self) -> None:
+        """Attempt to reconnect to the server."""
+        logger.info(f"Attempting to reconnect in {self.reconnect_delay} seconds...")
+        await asyncio.sleep(self.reconnect_delay)
+        
+        try:
+            await self.connect()
+        except Exception as e:
+            logger.error(f"Reconnection failed: {e}")
+            if self.auto_reconnect and self._should_reconnect:
+                # Schedule another reconnection attempt
+                asyncio.create_task(self._reconnect())
+    
+    async def wait_for_transcripts(self) -> None:
+        """
+        Wait for transcripts to be received. This will block until the connection is closed.
+        Useful for keeping the connection alive while processing transcripts.
+        """
+        if self._receive_task:
+            try:
+                await self._receive_task
+            except asyncio.CancelledError:
+                pass
+    
+    def is_connected(self) -> bool:
+        """Check if currently connected to the server."""
+        return self._connected and self.websocket is not None
+    
+    async def disconnect(self) -> None:
+        """Disconnect from the server and clean up resources."""
+        logger.info("Disconnecting from server...")
+        self._should_reconnect = False
+        self._connected = False
+        
+        if self._receive_task:
+            self._receive_task.cancel()
+            try:
+                await self._receive_task
+            except asyncio.CancelledError:
+                pass
+        
+        if self.websocket:
+            try:
+                await self.websocket.close()
+            except Exception as e:
+                logger.warning(f"Error closing websocket: {e}")
+        
+        logger.info("Disconnected from server")
+    
+    async def __aenter__(self):
+        """Async context manager entry."""
+        await self.connect()
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.disconnect()
+
+
+# Backwards-compatible alias. `StreamingClient` is the public name; older callers
+# (and the current prod fleet) import `TritonTranscriptionClient`. Both refer to
+# the same class so existing code keeps working. The alias will be removed once
+# all consumers have migrated to `StreamingClient`.
+TritonTranscriptionClient = StreamingClient
+

knowlsttclient-0.4.2/knowlsttclient.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: knowlsttclient
+Version: 0.4.2
+Summary: Python client for real-time streaming speech-to-text
+Requires-Dist: protobuf
+Requires-Dist: requests
+Requires-Dist: websockets

knowlsttclient-0.4.2/knowlsttclient.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+knowlsttclient/__init__.py
+knowlsttclient/streaming_client.py
+knowlsttclient.egg-info/PKG-INFO
+knowlsttclient.egg-info/SOURCES.txt
+knowlsttclient.egg-info/dependency_links.txt
+knowlsttclient.egg-info/requires.txt
+knowlsttclient.egg-info/top_level.txt
+knowlsttclient/proto/__init__.py
+knowlsttclient/proto/control_message_pb2.py
+knowlsttclient/proto/transcription_event_pb2.py

knowlsttclient-0.4.2/knowlsttclient.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

knowlsttclient-0.4.2/knowlsttclient.egg-info/requires.txt

@@ -0,0 +1,3 @@
+protobuf
+requests
+websockets

knowlsttclient-0.4.2/knowlsttclient.egg-info/top_level.txt

@@ -0,0 +1 @@
+knowlsttclient

knowlsttclient-0.4.2/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "knowlsttclient"
+version = "0.4.2"
+description = "Python client for real-time streaming speech-to-text"
+dependencies = ["protobuf", "requests", "websockets"]
+
+[tool.setuptools.packages.find]
+include = ["knowlsttclient*"]
+exclude = ["server*", "proto*", "model_repository*", "sample-wav*"]

knowlsttclient-0.4.2/setup.cfg

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