def main():
import time
from voice_engine.source import Source
src = Source()
kws = KWS()
src.link(kws)
def on_detected(keyword):
print('found {}'.format(keyword))
kws.on_detected = on_detected
kws.start()
src.start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
kws.stop()
src.stop()
def main():
import time
from voice_engine.source import Source
src = Source(channels=8, rate=16000, frames_size=160)
doa = DOA(channels=8)
src.link(doa)
doa.start()
src.start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
doa.stop()
src.stop()
pixel_ring.off()
APP_ID = '10783244'
API_KEY = 'GlQae1odOq3Y1w2wCpGBOI27'
SECRET_KEY = 'aeb8dc5f91cc18990a873edb294e6641'
aipSpeech = AipSpeech(APP_ID, API_KEY, SECRET_KEY)
baidu = BaiduVoiceApi(appkey=API_KEY, secretkey=SECRET_KEY)
def generator_list(list):
for l in list:
yield l
def on_detected(keyword):
print('found {}'.format(keyword))
os.system('play turnon.mp3')
kws.on_detected = on_detected
kws.start()
src.start()
while True:
try:
time.sleep(1)
except KeyboardInterrupt:
break
kws.stop()
src.stop()
def main(api_endpoint, credentials, project_id, device_model_id, device_id,
device_config, lang, verbose, grpc_deadline, once, *args, **kwargs):
"""Samples for the Google Assistant API.
Examples:
Run the sample with microphone input and speaker output:
$ python -m googlesamples.assistant
Run the sample with file input and speaker output:
$ python -m googlesamples.assistant -i <input file>
Run the sample with file input and output:
$ python -m googlesamples.assistant -i <input file> -o <output file>
"""
# Setup logging.
logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO)
# Load OAuth 2.0 credentials.
try:
with open(credentials, 'r') as f:
credentials = google.oauth2.credentials.Credentials(token=None,
**json.load(f))
http_request = google.auth.transport.requests.Request()
credentials.refresh(http_request)
except Exception as e:
logging.error('Error loading credentials: %s', e)
logging.error('Run google-oauthlib-tool to initialize '
'new OAuth 2.0 credentials.')
sys.exit(-1)
# Create an authorized gRPC channel.
grpc_channel = google.auth.transport.grpc.secure_authorized_channel(
credentials, http_request, api_endpoint)
logging.info('Connecting to %s', api_endpoint)
if not device_id or not device_model_id:
try:
with open(device_config) as f:
device = json.load(f)
device_id = device['id']
device_model_id = device['model_id']
logging.info("Using device model %s and device id %s",
device_model_id, device_id)
except Exception as e:
logging.warning('Device config not found: %s' % e)
logging.info('Registering device')
if not device_model_id:
logging.error('Option --device-model-id required '
'when registering a device instance.')
sys.exit(-1)
if not project_id:
logging.error('Option --project-id required '
'when registering a device instance.')
sys.exit(-1)
device_base_url = ('https://%s/v1alpha2/projects/%s/devices' %
(api_endpoint, project_id))
device_id = str(uuid.uuid1())
payload = {
'id': device_id,
'model_id': device_model_id,
'client_type': 'SDK_SERVICE'
}
session = google.auth.transport.requests.AuthorizedSession(
credentials)
r = session.post(device_base_url, data=json.dumps(payload))
if r.status_code != 200:
logging.error('Failed to register device: %s', r.text)
sys.exit(-1)
logging.info('Device registered: %s', device_id)
pathlib.Path(os.path.dirname(device_config)).mkdir(exist_ok=True)
with open(device_config, 'w') as f:
json.dump(payload, f)
assistant = SampleAssistant(lang, device_model_id, device_id, grpc_channel,
grpc_deadline)
src = Source(rate=16000, frames_size=1600)
kws = KWS(model='snowboy', sensitivity=0.6)
src.link(kws)
kws.link(assistant)
def on_keyword(keyword):
print('detected')
assistant.listen()
quit_event = threading.Event()
def on_interrupt(sig, frame):
print('quit')
quit_event.set()
signal.signal(signal.SIGINT, on_interrupt)
kws.on_detected = on_keyword
assistant.start()
kws.start()
src.start()
while not quit_event.is_set():
time.sleep(1)
src.stop()
kws.stop()
assistant.stop()
