Migration guide: Speechmatics to AssemblyAI

1
import pyaudio
2
import websocket
3
import json
4
import threading
5
import time
6
7
# --- Configuration ---
8
9
YOUR_API_KEY = "YOUR-API-KEY" # Replace with your actual API key
10
11
CONNECTION_PARAMS = {
12
"language": "en",
13
"enable_partials": True,
14
"max_delay": 2.0
15
}
16
API_ENDPOINT = "wss://eu2.rt.speechmatics.com/v2/en"
17
18
# Audio Configuration
19
20
FRAMES_PER_BUFFER = 1024 # Chunk size
21
SAMPLE_RATE = None # Will be set based on device capabilities
22
CHANNELS = 1
23
FORMAT = pyaudio.paFloat32 # Speechmatics uses float32 format
24
25
# Global variables for audio stream and websocket
26
27
audio = None
28
stream = None
29
ws_app = None
30
audio_thread = None
31
stop_event = threading.Event() # To signal the audio thread to stop
32
audio_seq_no = 0 # Track number of audio chunks sent
33
34
# --- WebSocket Event Handlers ---
35
36
def on_open(ws):
37
"""Called when the WebSocket connection is established."""
38
print("WebSocket connection opened.")
39
print(f"Connected to: {API_ENDPOINT}")
40
41
    # Send StartRecognition message
42
    start_message = {
43
        "message": "StartRecognition",
44
        "audio_format": {
45
            "type": "raw",
46
            "encoding": "pcm_f32le",
47
            "sample_rate": SAMPLE_RATE
48
        },
49
        "transcription_config": {
50
            "language": CONNECTION_PARAMS["language"],
51
            "enable_partials": CONNECTION_PARAMS["enable_partials"],
52
            "max_delay": CONNECTION_PARAMS["max_delay"]
53
        }
54
    }
55
    ws.send(json.dumps(start_message))
56
57
def on_message(ws, message):
58
global audio_seq_no
59
60
    try:
61
        data = json.loads(message)
62
        msg_type = data.get('message')
63
64
        if msg_type == "RecognitionStarted":
65
            session_id = data.get('id')
66
            print(f"\nSession began: ID={session_id}")
67
68
            # Start sending audio data in a separate thread
69
            def stream_audio():
70
                global audio_seq_no, stream
71
                print("Starting audio streaming...")
72
                while not stop_event.is_set():
73
                    try:
74
                        audio_data = stream.read(FRAMES_PER_BUFFER, exception_on_overflow=False)
75
                        # Send audio data as binary message
76
                        ws.send(audio_data, websocket.ABNF.OPCODE_BINARY)
77
                        audio_seq_no += 1
78
                    except Exception as e:
79
                        print(f"Error streaming audio: {e}")
80
                        # If stream read fails, likely means it's closed, stop the loop
81
                        break
82
                print("Audio streaming stopped.")
83
84
            global audio_thread
85
            audio_thread = threading.Thread(target=stream_audio)
86
            audio_thread.daemon = (
87
                True  # Allow main thread to exit even if this thread is running
88
            )
89
            audio_thread.start()
90
91
        elif msg_type == "AddPartialTranscript":
92
            transcript = data.get('metadata', {}).get('transcript', '')
93
            if transcript:
94
                print(f"\r{transcript}", end='')
95
96
        elif msg_type == "AddTranscript":
97
            transcript = data.get('metadata', {}).get('transcript', '')
98
            if transcript:
99
                # Clear previous line for final messages
100
                print('\r' + ' ' * 80 + '\r', end='')
101
                print(transcript)
102
103
        elif msg_type == "EndOfTranscript":
104
            print("\nSession Terminated: Transcription complete")
105
106
        elif msg_type == "Error":
107
            error_type = data.get('type')
108
            reason = data.get('reason')
109
            print(f"\nWebSocket Error: {error_type} - {reason}")
110
            stop_event.set()
111
112
    except json.JSONDecodeError as e:
113
        print(f"Error decoding message: {e}")
114
    except Exception as e:
115
        print(f"Error handling message: {e}")
116
117
def on_error(ws, error):
118
"""Called when a WebSocket error occurs."""
119
print(f"\nWebSocket Error: {error}") # Attempt to signal stop on error
120
stop_event.set()
121
122
def on_close(ws, close_status_code, close_msg):
123
"""Called when the WebSocket connection is closed."""
124
print(f"\nWebSocket Disconnected: Status={close_status_code}, Msg={close_msg}") # Ensure audio resources are released
125
global stream, audio
126
stop_event.set() # Signal audio thread just in case it's still running
127
128
    if stream:
129
        if stream.is_active():
130
            stream.stop_stream()
131
        stream.close()
132
        stream = None
133
    if audio:
134
        audio.terminate()
135
        audio = None
136
    # Try to join the audio thread to ensure clean exit
137
    if audio_thread and audio_thread.is_alive():
138
        audio_thread.join(timeout=1.0)
139
140
# --- Main Execution ---
141
142
def run():
143
global audio, stream, ws_app, SAMPLE_RATE
144
145
    # Initialize PyAudio
146
    audio = pyaudio.PyAudio()
147
148
    # Get default input device (can alter to specify specific device)
149
    default_device = audio.get_default_input_device_info()
150
    device_index = default_device['index']
151
    SAMPLE_RATE = int(audio.get_device_info_by_index(device_index)['defaultSampleRate'])
152
153
    print(f"Using microphone: {default_device['name']}")
154
155
    # Open microphone stream
156
    try:
157
        stream = audio.open(
158
            input=True,
159
            frames_per_buffer=FRAMES_PER_BUFFER,
160
            channels=CHANNELS,
161
            format=FORMAT,
162
            rate=SAMPLE_RATE,
163
            input_device_index=device_index
164
        )
165
        print("Microphone stream opened successfully.")
166
        print("Speak into your microphone. Press Ctrl+C to stop.")
167
    except Exception as e:
168
        print(f"Error opening microphone stream: {e}")
169
        if audio:
170
            audio.terminate()
171
        return  # Exit if microphone cannot be opened
172
173
    # Create WebSocketApp
174
    ws_app = websocket.WebSocketApp(
175
        API_ENDPOINT,
176
        header={"Authorization": f"Bearer {YOUR_API_KEY}"},  # Speechmatics uses Bearer token
177
        on_open=on_open,
178
        on_message=on_message,
179
        on_error=on_error,
180
        on_close=on_close,
181
    )
182
183
    # Run WebSocketApp in a separate thread to allow main thread to catch KeyboardInterrupt
184
    ws_thread = threading.Thread(target=lambda: ws_app.run_forever(ping_interval=30, ping_timeout=10))
185
    ws_thread.daemon = True
186
    ws_thread.start()
187
188
    try:
189
        # Keep main thread alive until interrupted
190
        while ws_thread.is_alive():
191
            time.sleep(0.1)
192
    except KeyboardInterrupt:
193
        print("\nCtrl+C received. Stopping...")
194
        stop_event.set()  # Signal audio thread to stop
195
196
        # Send EndOfStream message to the server
197
        if ws_app and ws_app.sock and ws_app.sock.connected:
198
            try:
199
                end_message = {
200
                    "message": "EndOfStream",
201
                    "last_seq_no": audio_seq_no
202
                }
203
                print(f"Sending termination message: {json.dumps(end_message)}")
204
                ws_app.send(json.dumps(end_message))
205
                # Give a moment for messages to process before forceful close
206
                time.sleep(1)
207
            except Exception as e:
208
                print(f"Error sending termination message: {e}")
209
210
        # Close the WebSocket connection (will trigger on_close)
211
        if ws_app:
212
            ws_app.close()
213
214
        # Wait for WebSocket thread to finish
215
        ws_thread.join(timeout=2.0)
216
217
    except Exception as e:
218
        print(f"\nAn unexpected error occurred: {e}")
219
        stop_event.set()
220
        if ws_app:
221
            ws_app.close()
222
        ws_thread.join(timeout=2.0)
223
224
    finally:
225
        # Final cleanup (already handled in on_close, but good as a fallback)
226
        if stream and stream.is_active():
227
            stream.stop_stream()
228
        if stream:
229
            stream.close()
230
        if audio:
231
            audio.terminate()
232
        print("Cleanup complete. Exiting.")
233
234
if **name** == "**main**":
235
run()

1
if __name__ == "__main__":
2
    run()