Streaming from Microphone using python
import pyaudio
import socketio
import json
import requests
from six.moves import queue
sio = socketio.Client()
@sio.event
def connect():
print("I'm connected!")
@sio.event
def connect_error(data):
print("The connection failed!")
@sio.event
def disconnect():
print("I'm disconnected!")
#@sio.event
#def messages(sid, data):
# print(data)
@sio.event
def output(data):
data = json.loads(data)
print('Trascript : ', data.get('sentence'))
print('Sentiment : ', data.get('sentiment'))
print('Intent : ', data.get('intent'))
print('intent Phrase', data.get('intentPhrase'))
print('Tone : ', data.get('tone'))
print('Emotion : ', data.get('emotion'))
print('Statement-Question-Command : ', data.get('sqc'))
print('Preset Statement Tag : ', data.get('presetStatementTag'))
print('Custom Statement Tag : ', data.get('customStatementTag'))
@sio.event
def valid_token(data):
print('Token is valid')
send_binary_data()
@sio.event
def invalid_token(data):
print('Token is Invalid')
#This class helps us simulate a 16bit audio stream
class MicrophoneStream(object):
"""Opens a recording stream as a generator yielding the audio chunks."""
def __init__(self, rate, chunk):
self._rate = rate
self._chunk = chunk
# Create a thread-safe buffer of audio data
self._buff = queue.Queue()
self.closed = True
def __enter__(self):
self._audio_interface = pyaudio.PyAudio()
self._audio_stream = self._audio_interface.open(
format=pyaudio.paInt16,
# The API currently only supports 1-channel (mono) audio
# https://goo.gl/z757pE
channels=1,
rate=self._rate,
input=True,
frames_per_buffer=self._chunk,
# Run the audio stream asynchronously to fill the buffer object.
# This is necessary so that the input device's buffer doesn't
# overflow while the calling thread makes network requests, etc.
stream_callback=self._fill_buffer,
)
self.closed = False
return self
def __exit__(self, type, value, traceback):
self._audio_stream.stop_stream()
self._audio_stream.close()
self.closed = True
# Signal the generator to terminate so that the client's
# streaming_recognize method will not block the process termination.
self._buff.put(None)
self._audio_interface.terminate()
def _fill_buffer(self, in_data, frame_count, time_info, status_flags):
"""Continuously collect data from the audio stream, into the buffer."""
self._buff.put(in_data)
return None, pyaudio.paContinue
def generator(self):
while not self.closed:
# Use a blocking get() to ensure there's at least one chunk of
# data, and stop iteration if the chunk is None, indicating the
# end of the audio stream.
chunk = self._buff.get()
if chunk is None:
return
data = [chunk]
# Now consume whatever other data's still buffered.
while True:
try:
chunk = self._buff.get(block=False)
if chunk is None:
return
data.append(chunk)
except queue.Empty:
break
yield b"".join(data)
def get_token(apiKey, apiSecret, userId):
API_ENDPOINT = "https://api.marsview.ai/cb/v1/auth/create_access_token"
payload = {
"apiKey": apiKey,
"apiSecret": apiSecret,
"userId": userId
}
r = requests.post(url = API_ENDPOINT, data = payload)
token = json.loads(r.text)['data']['accessToken']
return token
def initiate_transaction(token, model_configs):
# importing the requests library
# defining the api-endpoint
API_ENDPOINT = "https://streams.marsview.ai/rb/v1/streams/setup_realtime_stream"
data = {
"channels":2,
"modelConfigs" : model_configs}
headers = {'Authorization': f'Bearer {token}'}
# sending post request and saving response as response object
r = requests.post(url = API_ENDPOINT, json = data, headers = headers)
pastebin_url = json.loads(r.text)['data']
txnId = pastebin_url['txnId']
channelId = pastebin_url['channels'][0]['channelId']
print("txnId : ", txnId)
print("channelId : ", channelId)
sio.connect('https://streams.marsview.ai', auth={'txnId': txnId, 'channelId': channelId, 'token':token})
sio.emit('startStream', '')
def send_binary_data():
RATE = 16000
CHUNK = int(RATE / 10)
print("* recording")
with MicrophoneStream(RATE, CHUNK) as stream:
audio_generator = stream.generator()
for content in audio_generator:
sio.emit('binaryData', content)
if __name__ == '__main__':
api_secret = <APISECRET>
api_key = <APIKEY>
user_id = <USERID>
token = get_token(api_key, api_secret, user_id)
model_configs = {
"intent_analysis":{
"intents":[]},
"custom_statement_tag_analysis":{
"statement_tag_ids":[],
"use_tag_level_threshold":True
},
}
initiate_transaction(token, model_configs)
Copy link