Getting Started

1
# Install the dependencies
2
pip install pyaudio==0.2.14

1
import json
2
import os
3
import threading
4
import asyncio
5
import queue
6
7
import websockets
8
from websockets.sync.client import connect
9
10
import pyaudio
11
12
TIMEOUT = 0.050
13
FORMAT = pyaudio.paInt16
14
CHANNELS = 1
15
RATE = 48000
16
CHUNK = 8000
17
18
DEFAULT_URL = f"wss://api.deepgram.com/v1/speak?encoding=linear16&sample_rate={RATE}"
19
DEFAULT_TOKEN = os.environ.get("DEEPGRAM_API_KEY", None)
20
21
def main():
22
    print(f"Connecting to {DEFAULT_URL}")
23
24
    _socket = connect(
25
        DEFAULT_URL, additional_headers={"Authorization": f"Token {DEFAULT_TOKEN}"}
26
    )
27
    _exit = threading.Event()
28
29
    _story = [
30
        "The sun had just begun to rise over the sleepy town of Millfield.",
31
        "Emily a young woman in her mid-twenties was already awake and bustling about.",
32
    ]
33
34
    async def receiver():
35
        speaker = Speaker()
36
        speaker.start()
37
        try:
38
            while True:
39
                if _socket is None or _exit.is_set():
40
                    break
41
42
                message = _socket.recv()
43
                if message is None:
44
                    continue
45
46
                if type(message) is str:
47
                    print(message)
48
                elif type(message) is bytes:
49
                    speaker.play(message)
50
        except Exception as e:
51
            print(f"receiver: {e}")
52
        finally:
53
            speaker.stop()
54
55
    _receiver_thread = threading.Thread(target=asyncio.run, args=(receiver(),))
56
    _receiver_thread.start()
57
58
    for text_input in _story:
59
        print(f"Sending: {text_input}")
60
        _socket.send(json.dumps({"type": "Speak", "text": text_input}))
61
62
    print("Flushing...")
63
    _socket.send(json.dumps({"type": "Flush"}))
64
65
    input("Press Enter to exit...")
66
    _exit.set()
67
    _socket.send(json.dumps({"type": "Close"}))
68
    _socket.close()
69
70
    _listen_thread.join()
71
    _listen_thread = None
72
73
class Speaker:
74
    _audio: pyaudio.PyAudio
75
    _chunk: int
76
    _rate: int
77
    _format: int
78
    _channels: int
79
    _output_device_index: int
80
81
    _stream: pyaudio.Stream
82
    _thread: threading.Thread
83
    _asyncio_loop: asyncio.AbstractEventLoop
84
    _asyncio_thread: threading.Thread
85
    _queue: queue.Queue
86
    _exit: threading.Event
87
88
    def __init__(
89
        self,
90
        rate: int = RATE,
91
        chunk: int = CHUNK,
92
        channels: int = CHANNELS,
93
        output_device_index: int = None,
94
    ):
95
        self._exit = threading.Event()
96
        self._queue = queue.Queue()
97
98
        self._audio = pyaudio.PyAudio()
99
        self._chunk = chunk
100
        self._rate = rate
101
        self._format = FORMAT
102
        self._channels = channels
103
        self._output_device_index = output_device_index
104
105
    def _start_asyncio_loop(self) -> None:
106
        self._asyncio_loop = asyncio.new_event_loop()
107
        self._asyncio_loop.run_forever()
108
109
    def start(self) -> bool:
110
        self._stream = self._audio.open(
111
            format=self._format,
112
            channels=self._channels,
113
            rate=self._rate,
114
            input=False,
115
            output=True,
116
            frames_per_buffer=self._chunk,
117
            output_device_index=self._output_device_index,
118
        )
119
120
        self._exit.clear()
121
122
        self._thread = threading.Thread(
123
            target=_play, args=(self._queue, self._stream, self._exit), daemon=True
124
        )
125
        self._thread.start()
126
127
        self._stream.start_stream()
128
129
        return True
130
131
    def stop(self):
132
        self._exit.set()
133
134
        if self._stream is not None:
135
            self._stream.stop_stream()
136
            self._stream.close()
137
            self._stream = None
138
139
        self._thread.join()
140
        self._thread = None
141
142
        self._queue = None
143
144
    def play(self, data):
145
        self._queue.put(data)
146
147
def _play(audio_out: queue, stream, stop):
148
    while not stop.is_set():
149
        try:
150
            data = audio_out.get(True, TIMEOUT)
151
            stream.write(data)
152
        except queue.Empty as e:
153
            # print(f"queue is empty")
154
            pass
155
        except Exception as e:
156
            print(f"_play: {e}")
157
158
if __name__ == "__main__":
159
    main()

1
{
2
  "type": "Speak",
3
  "text": "Your text to transform to speech",
4
}

1
{
2
  "type": "Flush"
3
}

1
{
2
  "type": "Close"
3
}