def __init__(self): self.api_endpoint = ASSISTANT_API_ENDPOINT self.credentials = os.path.join( click.get_app_dir('google-oauthlib-tool'), 'credentials.json') # Setup logging. logging.basicConfig( ) # filename='assistant.log', level=logging.DEBUG if self.verbose else logging.INFO) self.logger = logging.getLogger("assistant") self.logger.setLevel(logging.DEBUG) self.custom_command = False self.once = True # Load OAuth 2.0 credentials. try: with open(self.credentials, 'r') as f: self.credentials = google.oauth2.credentials.Credentials( token=None, **json.load(f)) self.http_request = google.auth.transport.requests.Request() self.credentials.refresh(self.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.') return # Create an authorized gRPC channel. self.grpc_channel = google.auth.transport.grpc.secure_authorized_channel( self.credentials, self.http_request, self.api_endpoint) logging.info('Connecting to %s', self.api_endpoint) self.audio_sample_rate = audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE self.audio_sample_width = audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH self.audio_iter_size = audio_helpers.DEFAULT_AUDIO_ITER_SIZE self.audio_block_size = audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE self.audio_flush_size = audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE self.grpc_deadline = DEFAULT_GRPC_DEADLINE self.device_id = "roghecv2assistant-roghecv2-59lv9s" # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2_grpc.EmbeddedAssistantStub( self.grpc_channel) # Opaque blob provided in AssistResponse that, # when provided in a follow-up AssistRequest, # gives the Assistant a context marker within the current state # of the multi-Assist()-RPC "conversation". # This value, along with MicrophoneMode, supports a more natural # "conversation" with the Assistant. self.conversation_state = None # Force reset of first conversation. self.is_new_conversation = True self.device_handler = device_helpers.DeviceRequestHandler( "roghecv2assistant-roghecv2-59lv9s") # Stores the current volument percentage. # Note: No volume change is currently implemented in this sample self.volume_percentage = 50 self.display = True
def __init__(self): root_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__))) self.language_code = 'en-US' self.device_config_path = os.path.join(root_dir, 'device_config.json') self.device_credentials_path = os.path.join(root_dir, 'credentials.json') self._set_credentials() self._load_device_config() self._create_conversation_stream() self.display = False self._set_http_request() self._create_gprc_channel() self.conversation_state = None self.is_new_conversation = True self.assistant = embedded_assistant_pb2_grpc.EmbeddedAssistantStub( self.channel) self.deadline = 60 * 3 + 5 self.device_handler = device_helpers.DeviceRequestHandler( self.device_id)
def deviceRequestHandler(device_id): device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.minsoft.actions.PlayMusic') def playMusic(artist, album): logging.info('Llega reproducir música de %s y %s.', artist, album) #s.send(b"{\"jsonrpc\": \"2.0\", \"method\": \"JSONRPC.Introspect\", \"id\": 1}") #s.send(b"{\"jsonrpc\": \"2.0\", \"method\": \"Player.SetPartymode\", \"id\": 1, \"params\": { \"playerid\": 0, \"partymode\": true } }") #s.send(b"{\"jsonrpc\": \"2.0\", \"method\": \"Player.GetPlayers\", \"id\": 1, \"params\": { \"media\": \"all\" } }") sendCommand( b"{\"jsonrpc\": \"2.0\", \"method\": \"Player.SetPartymode\", \"id\": 1, \"params\": { \"playerid\": 0, \"partymode\": true } }" ) @device_handler.command('com.minsoft.actions.Stop') def stop(): sendCommand( b"{\"jsonrpc\": \"2.0\", \"method\": \"Player.Stop\", \"id\": 1, \"params\": { \"playerid\": 0 } }" ) @device_handler.command('com.minsoft.actions.Pause') def pause(): sendCommand( b"{\"jsonrpc\": \"2.0\", \"method\": \"Player.PlayPause\", \"id\": 1, \"params\": { \"playerid\": 0, \"play\": false } }" ) @device_handler.command('com.minsoft.actions.Resume') def pause(): sendCommand( b"{\"jsonrpc\": \"2.0\", \"method\": \"Player.PlayPause\", \"id\": 1, \"params\": { \"playerid\": 0, \"play\": true } }" ) return device_handler
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) # text to speech : text를 음성으로 바꾸어서 스피커에 출력 def tts(text, lang='ko'): if lang == None: speech = gTTS(text=text) else: speech = gTTS(text=text, lang=lang) speech.save('tmp.mp3') os.system("omxplayer tmp.mp3") os.remove('tmp.mp3') # speech to text : speech를 text를 바꾸어서 text 변수에 저장 def stt(commands=None, is_respon=False): # voice recognition/respone.******* continue_conversation, stt_tmp = assistant.assist(commands=commands, is_respon=is_respon) wait_for_user_trigger = not continue_conversation #if once and (not continue_conversation): # break text = stt_tmp return text with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: if input_audio_file or output_audio_file: assistant.assist() return wait_for_user_trigger = not once # 내가 말할 command들 select = ['컨트롤', '교육'] control = ['초음파', '추적', '불빛', '명령', '꺼'] yn = ['네', '아니'] move = ['앞으로', '뒤로', '오른쪽', '왼쪽'] first = True more = False # dc,servo,ultra sonic,led module = m.mode() while True: if first == True: tts("컨트롤모드와 교육모드 중에 선택해주세요 ,.,.,.") first = False text = stt(select, is_respon=True) print("[INFO] answer : ", text) if select[0] in text: print('동작 모드 ') tts('동작모드 입니다.... ') while True: if more == True: tts("동작모드를 더 하실껀가요 ") text = stt(is_respon=False) if yn[0] in text: more = False tts('다시 시작할게요 ') if yn[1] in text: more = False first = True break text = stt(is_respon=False) print("[INFO] answer : ", text) if control[0] in text: print("초음파 모드") tts('초음파 모드 입니다 ') sel = random.randrange(2) if sel == 0: print('1') module.avoid() else: print('2') module.avoid2() tts("초음파 모드가 끝났어요 ") more = True elif control[1] in text: print('추적 모드') tts('추적 모드 입니다 ') module.tracking() tts("추적 모드가 끝났어요 ") more = True elif control[2] in text: print('불빛 모드') tts('블빛 모드 입니다 ') module.servo_led() tts("붗빛 모드가 끝났어요 ") more = True elif control[3] in text: print('명령모드') tts('명령 모드 입니다 ') try: start = time.time() while True: if time.time() - start > 60: break text = stt(commands=move, is_respon=False) print(text) if move[0] in text: #if module.distance() > 80: module.go(100, 100) sleep(2) module.stop() elif move[1] in text: module.back(100, 100) sleep(2) module.stop() elif move[2] in text: module.spin_right(100, 100) sleep(3) module.stop() elif move[3] in text: module.spin_left(100, 100) sleep(3) module.stop() except KeyboardInterrupt: module.stop() module.stop() tts("명령모드가 끝났어요 ") more = True elif control[4] in text: tts("끝낼게요 ") first = True break elif select[1] in text: #DB Setting host = '192.168.0.8' user = '******' dbname = 'Education' password = '******' ser = 1 name = 'LEE' e = Education(host, user, dbname, password, ser, name) conn, cur = e.connection() e.dbclean(conn, cur) tts("교육모드 입니다. ") count = 0 stage = 0 while True: distance = module.distance() if distance < 50: count += 1 if count > 100: count = 0 tts("반가워요 제가 동화를 들려드릴게요 ") sleep(1) os.system( "omxplayer ~/workspace/Raspi_google_robot/stt/ka_01.mp3" ) tts("동화가 끝났어요 재미있으셨나요 ") sleep(1) while True: text = stt(is_respon=False) e.isfun(conn, cur, text) if yn[0] in text: tts("고마워요 다음에 또 들려줄게요 ") break elif yn[1] in text: tts("나중에는 더 재미있는 이야기를 들려줄게요 ") break e.search_isfun(conn, cur) tts("우리 같이 숫자 공부해요 ") sleep(1) tts("일 더하기 이는 무엇일까요 ") life = 5 math_pt = 100 while True: text = stt(is_respon=False) print(text) if '3' in text: tts("정답이에요 축하해요 ") break elif not text: pass else: tts("틀렸어요 다시한번 말해주세요 ") life -= 1 math_pt -= 5 if life == 0: tts("코인을 다썼어요 아쉽네요 다음 기회에 또 봐요 ") break e.math(conn, cur, math_pt) e.search_math(conn, cur) time.sleep(1) tts("우리 같이 발음을 맞춰봐요 ") life = 5 english_pt = 100 quiz = 'orange' tts(quiz, lang=None) while True: text = stt(is_respon=False) print(text) if '오렌지' in text: tts("정답 이에요") break elif not text: pass else: tts("틀렸어요 다시한번 말해주세요 ") life -= 1 english_pt -= 5 if life == 0: tts("아쉽네요 다음 기회에 또 봐요 ") break e.english(conn, cur, english_pt) e.search_english(conn, cur) time.sleep(1) tts("교육모드가 끝났습니다. ") e.dbclose(conn, cur) first = True break else: first = True m.clean()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) GPIO.setmode(GPIO.BCM) GPIO.setup(12, GPIO.OUT, initial=GPIO.LOW) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once porcupine = PorcupineDemo(library_path=pvporcupine.LIBRARY_PATH, model_path=pvporcupine.MODEL_PATH, keyword_paths=[ pvporcupine.KEYWORD_PATHS[x] for x in ['terminator'] ], sensitivities=[0.95], output_path=None, input_device_index=None) porcupine_thread = threading.Thread(target=porcupine.run) porcupine_thread.start() bill = Billy() while True: if wait_for_user_trigger: while not porcupine.detected: time.sleep(0.1) #click.pause(info='Press Enter to send a new request...') assistant.bill.eye_on() continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break assistant.bill.eye_off()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') if not device_id or not device_model_id: logging.error( 'No device_id or no device_model_id found. Please check config.py') sys.exit(0) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: click.pause(info='Press Enter to send a new request...') continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
def main(): # Configuration api_endpoint = ASSISTANT_API_ENDPOINT credentials = os.path.join(click.get_app_dir('google-oauthlib-tool'), 'credentials.json') project_id = os.getenv("PROJECT_ID") device_model_id = os.getenv("DEVICE_MODEL_ID") device_id = os.getenv("DEVICE_ID") device_config = os.path.join(click.get_app_dir('googlesamples-assistant'), 'device_config.json') lang = "en-US" display = False verbose = False audio_sample_rate = audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE audio_sample_width = audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH audio_iter_size = audio_helpers.DEFAULT_AUDIO_ITER_SIZE audio_block_size = audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE audio_flush_size = audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE grpc_deadline = DEFAULT_GRPC_DEADLINE # 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) # Configure audio source and sink. audio_device = None audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. # Initialise car share app. assistant.assist(text_query="talk to car share") while True: continue_conversation = assistant.assist()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, grpc_deadline, *args, **kwargs): # 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) device_handler = device_helpers.DeviceRequestHandler(device_id) with Fish() as fish: # Configure audio source and sink. audio_sink = FishDeviceStream(fish=fish, sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size) audio_source = audio_sink # Create conversation stream with the given audio source and sink. conversation_stream = FishConversationStream( fish=fish, source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: fish.setIndicator(True) continue_conversation = False while True: if not continue_conversation: logging.info('Waiting for button press') while not fish.getTriggerButton(): time.sleep(0.05) continue_conversation = assistant.assist()
def main(api_endpoint, credentials, project_id, device_model_id, device_config, lang, display, verbose, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, grpc_deadline, once): # 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) # Configure audio source and sink. audio_device = None input_audio_file = False output_audio_file = False audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: print('Turning device on') else: print('Turning device off') @device_handler.command('Extend') def extend(number): global ser ser.write(b'f') print(" Extending ... ") @device_handler.command('Flex') def extend(number): global ser ser.write(b'b') print(" Flexing ... ") @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: def signal_handler(signal, frame): detector.terminate() def interrupt_callback(): global continue_conversation if continue_conversation: continue_conversation = assistant.assist() print('listening..') def det_call(): print('yes master') global continue_conversation continue_conversation = assistant.assist() print('done================') return 0 signal.signal(signal.SIGINT, signal_handler) detector = snowboydecoder.HotwordDetector('saaedy.pmdl', sensitivity=0.6) detector.start(detected_callback=det_call, interrupt_check=interrupt_callback, sleep_time=0.1)
def main(api_endpoint=ASSISTANT_API_ENDPOINT, credentials=os.path.join(click.get_app_dir('google-oauthlib-tool'), 'credentials.json'), project_id=None, device_model_id=None, device_id=None, device_config=os.path.join( click.get_app_dir('googlesamples_assistant'), 'device_config.json'), lang="en_GB", display=True, verbose=False, input_audio_file=None, output_audio_file=None, audio_sample_rate=audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE, audio_sample_width=audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH, audio_iter_size=audio_helpers.DEFAULT_AUDIO_ITER_SIZE, audio_block_size=audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE, audio_flush_size=audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE, grpc_deadline=DEFAULT_GRPC_DEADLINE, once=False, *args, **kwargs): # 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) #|=============================================| #| | #| Handle commands for Google Assistant Stuff | #| | #|=============================================| device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.SetVolume') def changeVolume(volumeLevel, isPercentage): if (isPercentage): os.system( 'pactl set-sink-volume "alsa_output.usb-Generic_USB2.0_Device_20130100ph0-00.analog-stereo" ' + str(volumeLevel) + '%') with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: input("PRESS ENTER TO SPEAK") continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, grpc_deadline, once, hotword_model, *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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_source = audio_device = ( audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) ) if output_audio_file: audio_sink = audio_helpers.WaveSink( open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_sink = audio_device = ( audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) ) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: pin13.write(1) logging.info('Turning device on') else: pin13.write(0) logging.info('Turning device off') @device_handler.command('action.devices.commands.BrightnessAbsolute') def brightnessCheck(brightness): pin13.write(brightness/100) logging.info('ok , brightness is ' , brightness) @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return import snowboydecoder def listening(): detector = snowboydecoder.HotwordDetector(hotword_model, sensitivity=0.397, audio_gain=1) print("Say dalilaa .....or, Press Ctrl+C to exit") detector.start(detected_callback=detectedCallback, sleep_time=0.01) detector.terminate() def detectedCallback(): continue_conversation = assistant.assist() print("Say dalilaa ...... or Press Ctrl+C to exit") # listening() listening()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: Now = datetime.datetime.now() DateTimeStamp = "{:%d/%m/%Y}".format(Now) print(DateTimeStamp) cached_list = cached.find_one({'ref': DateTimeStamp})['cached'] print(cached_list) current_detected = memcache.Client(['127.0.0.1:11211'], debug=0) assistant.assist(text_query='Talk to my test app') # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. #wait_for_user_trigger = not once while True: if assistant.MODE is 0 or assistant.MODE is 1: query = '' while True: name = current_detected.get('Name') if name is not '': query = name assistant.switch_mode(1) if name not in cached_list: cached_list.append(name) cached.update({'ref': DateTimeStamp}, {'$push': { 'cached': name }}) query = name + "first" assistant.switch_mode(0) break if assistant.MODE is 0: click.echo('<you> %s' % query) text, continue_conversation = assistant.assist( text_query=query) #print(text) elif assistant.MODE is 1: click.echo('<you> %s' % query) text, continue_conversation = assistant.assist( text_query=query) #print(text) assistant.switch_mode(2) elif assistant.MODE is 2: text, continue_conversation = assistant.assist(text_query=None) print(text) if text == 'Please report activity again.': print('recording again') assistant.switch_mode(2) #text, continue_conversation = assistant.assist(text_query=None) else: print('why??') assistant.switch_mode(1) # wait for user trigger if there is no follow-up turn in # the conversation. #wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if not continue_conversation: assistant.assist(text_query='Talk to my test app') time.sleep(1)
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) context = zmq.Context.instance() socket = context.socket(zmq.REP) socket.bind('tcp://127.0.0.1:5555') while True: print('receiving socket message...') msg = socket.recv_string() if msg == 'stop': socket.send_string('stopping') context.destroy() break if msg != 'start': socket.send_string('invalid message') continue print('received start message') # Configure audio source and sink. audio_device = None audio_source = audio_helpers.WaveSource( open('in.wav', 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) if output_audio_file: audio_sink = audio_helpers.WaveSink( open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') 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'] 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} 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) os.makedirs(os.path.dirname(device_config), exist_ok=True) with open(device_config, 'w') as f: json.dump(payload, f) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. #if input_audio_file or output_audio_file: assistant.assist() print("accepting another request...") socket.send_string('done')
def main(api_endpoint=ASSISTANT_API_ENDPOINT, credentials=os.path.join(click.get_app_dir('google-oauthlib-tool'), 'credentials.json'), device_config=os.path.join( click.get_app_dir('googlesamples-assistant'), 'device_config.json'), device_id=None, project_id=None, device_model_id=None, input_audio_file=None, output_audio_file=None, audio_sample_rate=audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE, audio_sample_width=audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH, audio_block_size=audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE, audio_flush_size=audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE, audio_iter_size=audio_helpers.DEFAULT_AUDIO_ITER_SIZE, lang='ko-KR', verbose=False, once=False, grpc_deadline=DEFAULT_GRPC_DEADLINE): # 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') print('JCH MP3 Play') #launch subprocess #python cannot play mp3 #subprocess.call(['lxterminal', '-e', 'python runMP3.py']) subprocess.call(['lxterminal', '-e', './runMP3.sh']) print('JCH fork process is run. parent process is still running') else: logging.info('Turning device off') killMP3Pid() print('JCH turn off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) #JCH : get MP3 player pid def killMP3Pid(): count = 1 pid = -1 cmd = ['ps', '-ef'] fd_popen = subprocess.Popen(cmd, stdout=subprocess.PIPE).stdout for line in fd_popen: if line.find('runMP3') != -1: list = line.split() pid = list[1] print('bash pid:' + str(pid)) os.kill(int(pid), signal.SIGTERM) #or signal.SIGKILL break fd_popen.close() fd_popen = subprocess.Popen(cmd, stdout=subprocess.PIPE).stdout for line in fd_popen: if line.find('omxplayer') != -1: print('find') list = line.split() pid = list[1] print('pid:' + str(pid)) os.kill(int(pid), signal.SIGTERM) if count == 2: break else: count = count + 1 fd_popen.close() # with SampleAssistant(lang, device_model_id, device_id, conversation_stream, grpc_channel, grpc_deadline, device_handler) as assistant: while assistant.assist(): if once: break
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Porcupine setup library_path = "lib/linux/x86_64/libpv_porcupine.so" # Path to Porcupine's C library available under lib/${SYSTEM}/${MACHINE}/ model_file_path = "lib/common/porcupine_params.pv" # It is available at lib/common/porcupine_params.pv keyword_file_paths = ['picovoice_linux.ppn', 'ok_google_linux_2020-04-28_v1.7.0.ppn', 'hey_google_linux_2020-04-28_v1.7.0.ppn'] sensitivities = [0.8, 0.9, 0.9] porcupine = None pa = None audio_stream = None # 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_source = audio_device = ( audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) ) if output_audio_file: audio_sink = audio_helpers.WaveSink( open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_sink = audio_device = ( audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) ) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return wait_for_user_trigger = not once try: porcupine = Porcupine( library_path, model_file_path, keyword_file_paths=keyword_file_paths, sensitivities=sensitivities) pa = pyaudio.PyAudio() audio_stream = pa.open( rate=porcupine.sample_rate, channels=1, format=pyaudio.paInt16, input=True, frames_per_buffer=porcupine.frame_length, input_device_index=2) while True: #print('listening') pcm = audio_stream.read(porcupine.frame_length) pcm = struct.unpack_from("h" * porcupine.frame_length, pcm) #print('test') result = porcupine.process(pcm) if result >= 0: print('detected keyword') continue_conversation = assistant.assist() wait_for_user_trigger = not continue_conversation except KeyboardInterrupt: print('stopping ...') finally: if porcupine is not None: porcupine.delete() if audio_stream is not None: audio_stream.close() if pa is not None: pa.terminate()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: query = '' cached = [] current_detected = memcache.Client(['127.0.0.1:11211'], debug=0) assistant.assist(text_query='Talk to my test app') # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. #wait_for_user_trigger = not once while True: while True: name = current_detected.get('Name') if name is not '': query = name break click.echo('<you> %s' % query) #always set MODE = TRUE for text input for detection input #if not assistant.MODE: # assistant.switch_mode() #first request made to Dialogflow to notify the user detected continue_conversation = assistant.assist(text_query=query) #decision fork, whether it is first detection for check in #or subsequent detections for action tracking if query not in cached: cached.append(query) continue_conversation = assistant.assist(text_query='start') else: assistant.switch_mode() continue_conversation = assistant.assist(text_query=None) assistant.switch_mode()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, grpc_deadline, once, *args, **kwargs): # Setup logging. logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO) # Load OAuth 2.0 credentials. credentials, http_request = create_credentials_and_http_request( credentials) # 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) # Configure audio source and sink. audio_device = None audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) if not device_id or not device_model_id: device_id, device_model_id = configure_device_id_and_model_id( device_config) device_handler = device_helpers.DeviceRequestHandler(device_id) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: if input_audio_file or output_audio_file: assistant.assist() return while True: signal.signal(signal.SIGUSR2, sigusr2_handler) global SHOULD_ASSIST if not SHOULD_ASSIST: time.sleep(0.5) continue # keep looping # temp disabling sighandler signal.signal(signal.SIGUSR2, sigusr2_handler_disabled) continue_conversation = assistant.assist() if not continue_conversation: SHOULD_ASSIST = False
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.acme.commands.play_kkbox') def play_music(songName ): # You must match the parameters from the Action Package. logging.info('play %s ' % songName) # url = 'https://widget.kkbox.com/v1/?id=4kxvr3wPWkaL9_y3o_&type=song&terr=TW&lang=TC&autoplay=true&loop=true' # result = subprocess.Popen(['firefox', url], stdout=subprocess.PIPE) # print(result.stdout) from kkbox_partner_sdk.auth_flow import KKBOXOAuth CLIENT_ID = 'cea7cb81a731b46caeb9b8c0e25abd22' CLIENT_SECRET = '6317f7914dcc9e1fb50d01f744b3f1fb' auth = KKBOXOAuth(CLIENT_ID, CLIENT_SECRET) token = auth.fetch_access_token_by_client_credentials() print(token) from kkbox_partner_sdk.api import KKBOXAPI kkboxapi = KKBOXAPI(token) keyword = '女武神' types = ['track'] result = kkboxapi.search_fetcher.search(keyword, types) tracks = result['tracks']['data'] # print('搜尋結果是:{}'.format(tracks)) track_id = result['tracks']['data'][0]['id'] track_info = kkboxapi.track_fetcher.fetch_track(track_id) url = track_info['url'] print('歌曲資訊連結是:{}'.format(url)) send(url) tickets = kkboxapi.ticket_fetcher.fetch_media_provision(track_id) url = tickets['url'] print('下載位置連結是:{}'.format(url)) print('底下是播放資訊') import subprocess subprocess.run(['ffplay', '-nodisp', '-autoexit', url]) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. once = True wait_for_user_trigger = not once while True: if wait_for_user_trigger: click.pause(info='Press Enter to send a new request...') continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('com.example.commands.SearchCar') def search_cars(filter, param): print('SEARCH CARS\n' + 'FILTER: ' + filter + ', PARAM: ' + param) try: response = requests.get( 'http://localhost:5000/api/cars?{}={}'.format(filter, param)) data = json.loads(response.text) cars = data['cars'] except: print("Problem communicating with server") cars = [] print('%-2s | %-10s | %-10s | %-8s | %s | %s | %s' % ("ID", "Make", "Body Type", "Colour", "No. Seats", "Cost/Hour", "Location")) print( '---+------------+------------+----------+-----------+-----------+----------------------' ) for car in cars: print('%-2d | %-10s | %-10s | %-8s | %-9d | $%-8d | %s' % (car['id'], car['make'], car['body_type'], car['colour'], car['no_seats'], car['cost_per_hour'], car['location'])) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: click.pause(info='Press Enter to send a new request...') continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # ウェイクワードでの起動 porcupine = None pa = None audio_stream = None try: # ハンドル作成 porcupine = pvporcupine.create(keywords=['jarvis', 'snowboy']) # pyaudioでの録音 pa = pyaudio.PyAudio() audio_stream = pa.open(rate=porcupine.sample_rate, channels=1, format=pyaudio.paInt16, input=True, frames_per_buffer=porcupine.frame_length) # 待ちループ def get_next_audio_frame(): pcm = audio_stream.read(porcupine.frame_length, exception_on_overflow=False) pcm = struct.unpack_from("h" * porcupine.frame_length, pcm) return pcm while True: keyword_index = porcupine.process(get_next_audio_frame()) if keyword_index >= 0: # detection event logic/callback continue_conversation = assistant.assist() while audio_stream.get_read_available() > 0: get_next_audio_frame() finally: if porcupine is not None: porcupine.delete() if audio_stream is not None: audio_stream.close() if pa is not None: pa.terminate() # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: click.pause(info='Press Enter to send a new request...') continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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> """ ############################################################################3 global updt_time, query, resp_text, mute, startmouth, TezHead, beep, faceFound, name2, onceface, facerec_en, keyboard_on # Setup logging. Kpx = 1 Kpy = 1 Ksp = 40 ## Head X and Y angle limits time.sleep(5) Xmax = 725 Xmin = 290 Ymax = 550 Ymin = 420 keyboard_on = False ## Initial Head position Xcoor = 511 Ycoor = 450 Facedet = 0 ## Time head wait turned touch_wait = 2 no_face_tm = time.time() face_det_tm = time.time() last_face_det_tm = time.time() touch_tm = 0 touch_samp = time.time() qbo_touch = 0 touch_det = False face_not_found_idx = 0 mutex_wait_touch = False faceFound = False onceface = False dist = 100 audio_response1 = '/home/pi/Reebo_Python/up.wav' wavep = wave.open(audio_response1, 'rb') audio_response2 = '/home/pi/Reebo_Python/HiTej.wav' wavep2 = wave.open(audio_response2, 'rb') facerec_en = False ############################################################################3 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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/v1alphapi@raspber2/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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "slowly": delay = 2 elif speed == "quickly": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) #~ def findquery(): ############################# FACEREC THREAD ##################################################33 def facerec(): global name2 f = open("/home/pi/Reebo_Python/face_features.pkl", 'rb') details = pickle.load(f) # Initialize some variables face_locations = [] face_encodings = [] face_names = [] name2 = [] unknown_picture = fr.load_image_file("/home/pi/Reebo_Python/test.jpg") # Grab a single frame of video # frame = unknown_picture # Resize frame of video to 1/4 size for faster face recognition processing # small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25) # Convert the image from BGR color (which OpenCV uses) to RGB color (which face_recognition uses) # rgb_small_frame = small_frame[:, :, ::-1] # Find all the faces and face encodings in the current frame of video face_locations = fr.face_locations(unknown_picture) face_encodings = fr.face_encodings(unknown_picture, face_locations) print("{0} persons identified".format(len(face_locations))) face_names = [] for face_encoding in face_encodings: matches = fr.compare_faces(details['encodings'], face_encoding, 0.45) name = "Unknown" # If a match was found in known_face_encodings, just use the first one. if True in matches: first_match_index = matches.index(True) name = details["name"][first_match_index] face_names.append(name) print(face_names) for i in range(0, len(face_names)): name_temp = str(face_names[i]).replace('photos/', "") name_temp = str(name_temp).replace(']\'', "") name2.append(str(name_temp)) print name2 n = open("/home/pi/Reebo_Python/names.txt", 'w') for i in face_names: n.write(i + "\n") n.close() for (top, right, bottom, left), name in zip(face_locations, face_names): if not name: continue if name == "warner": cv2.rectangle(unknown_picture, (left, top), (right, bottom), (255, 0, 0), 2) cv2.rectangle(unknown_picture, (left, bottom - 25), (right, bottom), (255, 0, 0), 1) font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(unknown_picture, name, (left + 6, bottom - 6), font, 0.5, (255, 255, 255), 1) else: cv2.rectangle(unknown_picture, (left, top), (right, bottom), (0, 0, 255), 2) cv2.rectangle(unknown_picture, (left, bottom - 25), (right, bottom), (0, 0, 255), 1) font = cv2.FONT_HERSHEY_DUPLEX cv2.putText(unknown_picture, name, (left + 6, bottom - 6), font, 0.5, (255, 255, 255), 1) cv2.imwrite("/home/pi/Reebo_Python/result.png", unknown_picture) def findFace(): global name2, faceFound, onceface, facerec_en, updt_time found_tm = time.time() onceface = False touch_samp = time.time() Xmax = 725 Xmin = 290 Ymax = 550 Ymin = 420 qbo_touch = 0 while True: #print("find face " + str(time.time())) try: faceFound = False # while not faceFound : # This variable is set to true if, on THIS loop a face has already been found # We search for a face three diffrent ways, and if we have found one already- # there is no reason to keep looking. #thread.start_new_thread(WaitForSpeech, ()) # WaitForSpeech() # ServoHome() Cface = [0, 0] t_ini = time.time() while time.time() - t_ini < 0.01: # wait for present frame t_ini = time.time() aframe = webcam.read()[ 1] #print "t: " + str(time.time()-t_ini) fface = frontalface.detectMultiScale( aframe, 1.3, 4, (cv2.cv.CV_HAAR_DO_CANNY_PRUNING + cv2.cv.CV_HAAR_FIND_BIGGEST_OBJECT + cv2.cv.CV_HAAR_DO_ROUGH_SEARCH), (60, 60)) pfacer = profileface.detectMultiScale( aframe, 1.3, 4, (cv2.cv.CV_HAAR_DO_CANNY_PRUNING + cv2.cv.CV_HAAR_FIND_BIGGEST_OBJECT + cv2.cv.CV_HAAR_DO_ROUGH_SEARCH), (80, 80)) if fface != (): # if we found a frontal face... for f in fface: # f in fface is an array with a rectangle representing a face faceFound = True face = f elif pfacer != (): # if we found a profile face... for f in pfacer: faceFound = True face = f if faceFound: updt_time = time.time() #facerec() if onceface == False: cv2.imwrite("/home/pi/Reebo_Python/test.jpg", aframe) onceface = True found_tm = time.time() x, y, w, h = face Cface = [ (w / 2 + x), (h / 2 + y) ] # we are given an x,y corner point and a width and height, we need the center TezHead.SetNoseColor(4) #print "face ccord: " + str(Cface[0]) + "," + str(Cface[1]) faceOffset_X = 160 - Cface[0] if (faceOffset_X > 20) | (faceOffset_X < -20): time.sleep(0.002) # acquire mutex TezHead.SetAngleRelative(1, faceOffset_X >> 1) # release mutex #wait for move time.sleep(0.05) #print "MOVE REL X: " + str(faceOffset_X >> 1) faceOffset_Y = Cface[1] - 120 if (faceOffset_Y > 20) | (faceOffset_Y < -20): time.sleep(0.002) # acquire mutex TezHead.SetAngleRelative(2, faceOffset_Y >> 1) # release mutex #wait for move time.sleep(0.05) if time.time() - found_tm > 0.5: TezHead.SetNoseColor(0) except Exception as e: print e pass try: current_touched = cap.touched() #last_touched = cap.touched() cap.set_thresholds(10, 6) # Check each pin's last and current state to see if it was pressed or released. i = 0 for i in [1, 11]: pin_bit = 1 << i # Each pin is represented by a bit in the touched value. A value of 1 # First check if transitioned from not touched to touched. if current_touched & pin_bit: #and not last_touched & pin_bit: print('{0} touched!'.format(i)) qbo_touch = int(i) ## # Next check if transitioned from touched to not touched. ## if not current_touched & pin_bit and last_touched & pin_bit: ## print('{0} released!'.format(i)) ## # Update last state and wait a short period before repeating. ## last_touched = current_touched #time.sleep(0.1) except: #print sys.exc_info() #print "error" pass if (time.time() - touch_samp > 0.5): # & (time.time() - last_face_det_tm > 3): touch_samp = time.time() #~ time.sleep(0.002) if qbo_touch in [1, 11]: if qbo_touch == 1: print("right") TezHead.SetServo(1, Xmax - 50, 100) time.sleep(0.002) TezHead.SetServo(2, Ymin - 5, 100) #thread.start_new_thread(WaitTouchMove, ()) # wait for begin touch move. time.sleep(1) qbo_touch = 0 elif qbo_touch == [2]: #~ time.sleep(0.002) TezHead.SetServo(2, Ymin - 5, 100) thread.start_new_thread(WaitTouchMove, ()) # wait for begin touch move. time.sleep(1) qbo_touch = 0 elif qbo_touch == 11: print("left") TezHead.SetServo(1, Xmin + 50, 100) time.sleep(0.002) TezHead.SetServo(2, Ymin - 5, 100) #thread.start_new_thread(WaitTouchMove, ()) # wait for begin touch move. time.sleep(1) qbo_touch = 0 def distance(): # set Trigger to HIGH GPIO.output(GPIO_TRIGGER, True) # set Trigger after 0.01ms to LOW time.sleep(0.00001) GPIO.output(GPIO_TRIGGER, False) StartTime = time.time() StopTime = time.time() # save StartTime while GPIO.input(GPIO_ECHO) == 0: StartTime = time.time() # save time of arrival while GPIO.input(GPIO_ECHO) == 1: StopTime = time.time() # time difference between start and arrival TimeElapsed = StopTime - StartTime # multiply with the sonic speed (34300 cm/s) # and divide by 2, because there and back distance = (TimeElapsed * 34300) / 2 return distance ################################## SOCKET THREAD ###################################################### def socket_thread(conn): print 'Socket.IO Thread Started.' def empid_received(): socket.emit('event-ask-cardno') print "ASK CARD NO" def cardno_received(): print "Card No received" conn.send(False) socket.on('event-empid-received', empid_received) socket.on('event-cardno-received', cardno_received) socket.wait() def findquery(parent_conn): global resp_text, mute, query, beep keyboard_on = False if resp_text == "Sorry, I can't help.": query = "Talk to Reebo" mute = True elif resp_text == "Alright! Say Cheese!": print "camera" aframe = webcam.read()[1] cv2.imwrite("/home/pi/reebo-backend/selfie.jpg", aframe) socket.emit('event-take-selfie') #mute=False elif resp_text.startswith("Can you please smile for the camera?"): mute = False beep = False print "BEEP" time.sleep(5) aframe = webcam.read()[1] cv2.imwrite("/home/pi/reebo-backend/selfie.jpg", aframe) socket.emit('event-take-selfie') query = "Say@#$: Thank you. Please enter your employee ID and card number" assistant.assist() socket.emit('event-ask-empid') keyboard_on = True print "KEYBOARD in findquery: ", keyboard_on keyboard_on = parent_conn.recv() query = "Say@#$: Thank You. You will be granted access shortly" mute = False beep = False if len(sys.argv) > 1: port = sys.argv[1] else: port = '/dev/serial0' try: # Open serial port ser = serial.Serial(port, baudrate=115200, bytesize=serial.EIGHTBITS, stopbits=serial.STOPBITS_ONE, parity=serial.PARITY_NONE, rtscts=False, dsrdtr=False, timeout=0) print "Open serial port sucessfully." print(ser.name) except Exception as e: print e print "Error opening serial port." sys.exit() try: cap = MPR121.MPR121() time.sleep(3) # if not cap.begin(): print('Error initializing MPR121. Check your wiring!') except Exception as e: print(e) pass TezHead = TezCmd.Controller(ser) TezHead.SetMouth(0x110E00) time.sleep(1) #TezHead.SetPid(1, 26, 12, 16) TezHead.SetPid(1, 26, 2, 16) #TezHead.SetPid(2, 26, 12, 16) TezHead.SetPid(2, 26, 2, 16) time.sleep(1) TezHead.SetServo(1, Xcoor, 100) TezHead.SetServo(2, Ycoor, 100) time.sleep(1) TezHead.SetNoseColor(0) webcam = cv2.VideoCapture( -1) # Get ready to start getting images from the webcam webcam.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 320) # I have found this to be about the highest- webcam.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 240) # resolution you'll want to attempt on the pi #webcam.set(cv2.CV_CAP_PROP_BUFFERSIZE, 2) # frame buffer storage if not webcam: print "Error opening WebCAM" sys.exit(1) #open = False frontalface = cv2.CascadeClassifier( "/home/pi/Documents/Python projects/haarcascade_frontalface_alt2.xml" ) # frontal face pattern detection profileface = cv2.CascadeClassifier( "/home/pi/Documents/Python projects/haarcascade_profileface.xml" ) # side face pattern detection #parent_conn, child_conn = Pipe() t1 = Thread(target=findFace) t1.start() t3 = Thread(target=facerec) parent_conn, child_conn = Pipe() socket_thd = Thread(target=socket_thread, args=(child_conn, )) socket_thd.start() with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once button_once = False #playsound('/home/pi/env/HiTej.wav') print "playsound" mute = True query = "Talk to Reebo" print query #################################################################################3 #~ query,mute=findquery() #####################################FIND QUERY AND MUTE#####################3 assistant.assist() mute = False query = "audio" time.sleep(1) updt_time = time.time() stream = conversation_stream num_frames = wavep.getnframes( ) # number of frames in audio response file resp_samples = wavep.readframes(num_frames) # get frames from wav file num_frames2 = wavep2.getnframes( ) # number of frames in audio response file resp_samples2 = wavep2.readframes( num_frames2) # get frames from wav file name = "" while True: #if wait_for_user_trigger: #logging.info('Press key') #x=raw_input() #~ stream.start_recording() # unelegant method to access private methods.. findquery(parent_conn) if mute == False or beep == True: print "beep" stream.start_playback() #~ stream.stop_recording() stream.write( resp_samples) # write response sample to output stream print "HI" stream.stop_playback() assistant.assist() beep = False query = "audio" mute = False #updt_time=time.time() print time.time() - updt_time dist = distance() #~ if dist<50: #~ print dist #~ updt_time=time.time() if time.time() - updt_time > 10: name2 = "" if onceface == True: facerec_en = False print "Thread Status", t3.is_alive() if t3.is_alive(): t3.terminate() t3.join(1) print "t3 terminated" print facerec_en onceface = False print("in loop") query = "audio" dist = distance() print faceFound while faceFound == False: time.sleep(0.1) #print "FACE FALSE" #~ if dist>60: #~ #mute=False #~ updt_time=time.time() #~ print query #~ while dist>60: #~ dist=distance() #~ time.sleep(0.1) #~ print dist #~ query="Hi" #~ print query #~ assistant.assist() #~ print ("playback") #~ socket.emit('event-robot-message',"Hi! Do you want some help ?") print "Thread Status", t3.is_alive() t3 = Thread(target=facerec) t3.start() #~ query="Talk to Tej" #~ mute=True #~ assistant.assist() #time.sleep(3) stream.start_playback() #~ stream.stop_recording() stream.write( resp_samples2) # write response sample to output stream socket.emit( 'event-robot-message', "Hi! My Name is Reebo. I\'ll be your personal assistant for today" ) stream.stop_playback() query = "Say:@#$: " if len(name2) >= 1: for i in range(0, len(name2)): if name2[i] != "" and name2[i] != "Unknown": query = query + " Hi " + str(name2[i]) + "!" query = query + "What can I do for you?" mute = False print query assistant.assist() #time.sleep(0.1) #~ stream.start_playback() #~ stream.stop_recording() #~ stream.write(resp_samples2) # write response sample to output stream #~ stream.stop_playback() #~ #query="Talk to Tej" #~ mute=True #~ assistant.assist() #~ updt_time= time.time() query = "audio" mute = False
def run(self): rospy.loginfo(self.logname + 'Initializing...') # Get parameters from launch file keyphrase_dir = rospy.get_param('key_phrase_dir', "") keyphrase_1 = rospy.get_param('key_phrase_1', "") keyphrase_1_path = keyphrase_dir + '/' + keyphrase_1 keyphrase_2 = rospy.get_param('key_phrase_2', "") keyphrase_2_path = keyphrase_dir + '/' + keyphrase_2 # Hotword Sensitivity: larger value is more sensitive (good for quiet room) hotword_sensitivity = 0.50 # rospy.get_param('hotword_sensitivity', 0.80) # 0.38? apply_frontend = rospy.get_param('apply_frontend', True) # Frontend filtering proxyUrl = rospy.get_param('proxyUrl', "") # default to no proxy rospy.loginfo(self.logname + "KEYPHRASE INFO: ") rospy.loginfo(" keyphrase_dir: " + keyphrase_dir) rospy.loginfo(" keyphrase_1: " + keyphrase_1) rospy.loginfo(" keyphrase_2: " + keyphrase_2) rospy.loginfo("========================================") if (keyphrase_1 == "") or (keyphrase_2 == ""): rospy.logfatal("========================================") rospy.logfatal("MISSING KEYPHRASE! SHUTTING DOWN!") rospy.logfatal("========================================") return # Check for Internet connection (fail early unstead of first time we try to use a cloud service) if not self.internet_available(): rospy.logfatal("========================================") rospy.logfatal("INTERNET NOT AVAILABLE, SHUTTING DOWN!") rospy.logfatal("========================================") return #===================================================================================== # Google Assistant Setup rospy.loginfo('Initializing Google Assistant...') # initialize parameters (these are usually passed on command line in sample) verbose = False credentials = '/home/system/.config/google-oauthlib-tool/credentials.json' device_config = '/home/system/.config/googlesamples-assistant/device_config.json' # Setup logging. #logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO) # Load OAuth 2.0 credentials. rospy.loginfo('Loading 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: rospy.logfatal('Error loading credentials: %s', e) rospy.logfatal('Run google-oauthlib-tool to initialize ' 'new OAuth 2.0 credentials.') sys.exit(-1) # Create an authorized gRPC channel. self.grpc_channel = google.auth.transport.grpc.secure_authorized_channel( credentials, http_request, ASSISTANT_API_ENDPOINT) rospy.loginfo('Connecting to %s', ASSISTANT_API_ENDPOINT) # get device info from the config file try: with open(device_config) as f: device = json.load(f) self.device_id = device['id'] self.device_model_id = device['model_id'] rospy.loginfo("Using device model %s and device id %s", self.device_model_id, self.device_id) except Exception as e: rospy.logfatal('Device config not found: %s' % e) sys.exit(-1) #=================================================================== # DEVICE HANDLERS. See resources/actions .json to add more actions rospy.loginfo('Setting up Google Assistant device handlers...') self.device_handler = device_helpers.DeviceRequestHandler( self.device_id) @self.device_handler.command('com.shinselrobots.commands.move') def move(move_direction, amount): if amount == '$amount': amount = '' rospy.loginfo('******> Got Move Command [%s] [%s] ', move_direction, amount) move_speed = '0.5' move_command = '0.75' # Normal Move (meters) if move_direction == 'BACKWARD': move_command = '-0.5' # Normal Backward Move (meters) if amount == 'SMALL': move_command = '-0.25' # Small Move elif amount == 'LARGE': move_command = '-0.75' # Large Move else: move_command = '0.75' # Normal Forward Move (meters) if amount == 'SMALL': move_command = '0.25' # Small Move elif amount == 'LARGE': move_command = '1.0' # Large Move self.handle_behavior_command('MOVE', move_command, move_speed, ('ok, moving ' + move_direction)) @self.device_handler.command('com.shinselrobots.commands.turn') def turn(turn_direction, amount): if amount == '$amount': amount = '' rospy.loginfo('******> Got Turn Command [%s] [%s] ', turn_direction, amount) turn_speed = '0.5' turn_command = '45' # Normal Turn if amount == 'SMALL': turn_command = '30' # Small Turn elif amount == 'LARGE': turn_command = '90' # Large Turn if turn_direction == 'RIGHT': turn_command = '-' + turn_command # Negative Turn self.handle_behavior_command('TURN', turn_command, turn_speed, ('turning ' + turn_direction)) @self.device_handler.command('com.shinselrobots.commands.spin_left') def spin_left(param1): turn_speed = '0.5' self.handle_behavior_command('TURN', '180', turn_speed, 'spinning left') @self.device_handler.command('com.shinselrobots.commands.spin_right') def spin_right(param1): turn_speed = '0.5' self.handle_behavior_command('TURN', '-180', turn_speed, 'spinning right') @self.device_handler.command('com.shinselrobots.commands.stop') def stop(param1): self.handle_behavior_command('STOP', '', '', 'stopping') @self.device_handler.command('com.shinselrobots.commands.sleep') def sleep(param1): self.handle_behavior_command('SLEEP', '', '', 'ok') @self.device_handler.command('com.shinselrobots.commands.wake') def wake(param1): self.handle_behavior_command('WAKEUP', '', '', 'ok, waking up') @self.device_handler.command('com.shinselrobots.commands.intro') def intro(param1): self.handle_behavior_command('INTRO', '', '', 'ok, sure') @self.device_handler.command('com.shinselrobots.commands.hands_up') def hands_up(param1): self.handle_behavior_command('HANDS_UP', '', '', 'ok') @self.device_handler.command('com.shinselrobots.commands.shake_hands') def shake_hands(param1): self.handle_behavior_command('SHAKE_HANDS', '', '', 'ok') @self.device_handler.command('com.shinselrobots.commands.arms_home') def arms_home(param1): self.handle_behavior_command('ARMS_HOME', '', '', 'ok') @self.device_handler.command('com.shinselrobots.commands.follow') def follow(param1): self.handle_behavior_command('FOLLOW_ME', '', '', 'ok, I will follow you') @self.device_handler.command( 'com.shinselrobots.commands.microphone_off') def microphone_off(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: MICROPHONE OFF') rospy.loginfo('**********************************************') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text("Ok, I will stop listening") self.mic_user_enable_pub.publish(False) @self.device_handler.command('com.shinselrobots.commands.microphone_on' ) def microphone_on(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: MICROPHONE ON') rospy.loginfo('**********************************************') # no action needed, but send just in case... self.mic_user_enable_pub.publish(True) @self.device_handler.command('com.shinselrobots.commands.toggle_lights' ) def toggle_lights(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: toggle lights') rospy.loginfo('**********************************************') # TODO Fix this temp Kludge, to use some global state (param server, or messaging?) text_to_say = "" light_mode = 0 if self.arm_lights_on: rospy.loginfo('SPEECH: TURN LIGHTS OFF (Toggle)') light_mode = 0 text_to_say = "entering stealth mode" self.arm_lights_on = False else: rospy.loginfo('SPEECH: TURN LIGHTS ON (Toggle)') light_mode = 1 text_to_say = "Doesnt this look cool?" self.arm_lights_on = True rospy.loginfo('DEBUG2: *********') self.pub_light_mode.publish(light_mode) rospy.loginfo('DEBUG3: *********') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text(text_to_say) rospy.loginfo('DEBUG: DONE WITH TOGGLE LIGHTS *********') @self.device_handler.command('com.shinselrobots.commands.sing_believer' ) def sing_believer(param1): self.handle_behavior_command('RUN_SCRIPT', 'believer', '', 'all right') @self.device_handler.command('com.shinselrobots.commands.bow') def bow(param1): self.handle_behavior_command('BOW', '', '', 'ok') @self.device_handler.command( 'com.shinselrobots.commands.who_is_president') def who_is_president(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: Who is President') rospy.loginfo('**********************************************') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text( "According to the internet, the president is Donald Trump. but, that might just be fake news" ) @self.device_handler.command('com.shinselrobots.commands.wave') def wave(param1): self.handle_behavior_command('WAVE', '', '', '') @self.device_handler.command('com.shinselrobots.commands.head_center') def head_center(param1): self.handle_behavior_command('HEAD_CENTER', '', '', 'ok') @self.device_handler.command('com.shinselrobots.commands.tell_time') def tell_time(param1): self.handle_behavior_command('TELL_TIME', '', '', 'let me check') @self.device_handler.command('com.shinselrobots.commands.joke') def joke(param1): self.handle_behavior_command('TELL_JOKE', param1, '', 'ok') @self.device_handler.command('com.shinselrobots.commands.tell_age') def tell_age(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: TELL AGE') rospy.loginfo(' Param1 = %s', param1) rospy.loginfo('**********************************************') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text( "I have been under construction for about a year. My hardware is nearly complete, but my software is constantly evolving" ) @self.device_handler.command('com.shinselrobots.commands.tell_function' ) def tell_function(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: TELL FUNCTION') rospy.loginfo(' Param1 = %s', param1) rospy.loginfo('**********************************************') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text( "i am currently focused on human interaction. but I hope to gain object manipulation capabilities soon. because the ultimate goal of any robot is to fetch beer" ) @self.device_handler.command('com.shinselrobots.commands.tell_size') def tell_size(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: TELL SIZE') rospy.loginfo(' Param1 = %s', param1) rospy.loginfo('**********************************************') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text( "I am 4 foot 3 inches tall, and I weigh about 75 pounds") @self.device_handler.command('com.shinselrobots.commands.tell_sex') def tell_sex(param1): rospy.loginfo('**********************************************') rospy.loginfo(' Google Assistant Command: TELL SEX') rospy.loginfo(' Param1 = %s', param1) rospy.loginfo('**********************************************') if not use_google_assistant_voice: # assistant not acknowledging the command, so we do it self.local_voice_say_text("i am a boy robot") rospy.loginfo('Google Assistant *** Initialization complete ***') self.TTS_client = None if not use_google_assistant_voice: # check for service as late as possible to give service time to start up rospy.loginfo(self.logname + "Initializing LOCAL Text to Speech...") client = actionlib.SimpleActionClient( "/speech_service", audio_and_speech_common.msg.speechAction) if (False == client.wait_for_server(rospy.Duration(10, 0))): rospy.logerr( self.logname + "WARNING!!! Text to Speech server is not available, skipping" ) else: self.TTS_client = client rospy.loginfo(self.logname + "LOCAL Text to speech server ready") #===================================================================================== rospy.loginfo(self.logname + "Starting detector...") keyphrase_models = [keyphrase_1_path, keyphrase_2_path] detector = snowboydecoder.HotwordDetector( keyphrase_models, sensitivity=hotword_sensitivity, apply_frontend=False) rospy.loginfo(self.logname + "Listening for keyphrase...") # main loop - This funciton will block until ros shutdown keyword_detected_callbacks = [ self.detectedCallback1, self.detectedCallback2 ] detector.start(detected_callback=keyword_detected_callbacks, audio_recorder_callback=self.audioRecorderCallback, interrupt_check=interrupt_callback, mic_pause=mic_pause_callback, sleep_time=0.01, silent_count_threshold=15, recording_timeout=10) # (blocks? 10 = about 4 seconds) # Tune recording_timeout for max expected command. Default of 100 is a LONG time! detector.terminate()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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> """ # GPIO setup GPIO.setmode(GPIO.BCM) GPIO.setwarnings(False) GPIO.setup(sBUTTON, GPIO.IN) GPIO.setup(gBUTTON, GPIO.IN, pull_up_down=GPIO.PUD_UP) GPIO.setup(gLED, GPIO.OUT, initial=GPIO.HIGH) # 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_source = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) if output_audio_file: audio_sink = audio_helpers.WaveSink(open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width) else: audio_sink = audio_device = (audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size)) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) image_dir = '/home/pi/robot/image/' def camera(): now = datetime.now() dir_name = now.strftime('%Y%m%d') dir_path = image_dir + dir_name + '/' file_name = now.strftime('%H%M%S') + '.jpg' fname = dir_path + file_name try: os.mkdir(dir_path) except OSError: logging.info('Date dir already exists') os.system('raspistill -o ' + fname) return fname @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') #Klight added GPIO.output(gLED, GPIO.HIGH) time.sleep(1) GPIO.output(gLED, GPIO.LOW) #os.system('python /home/pi/robot/blinkt_color.py') else: logging.info('Turning device off') GPIO.output(gLED, GPIO.LOW) # Kblink @device_handler.command('com.acme.commands.blink_light') def blinker(number, lightKey): logging.info('Blinking device %s times.' % number) for i in range(int(number)): logging.info('Device is blinking %s/%s time.' % (i, number)) time.sleep(0.5) GPIO.output(gLED, GPIO.HIGH) time.sleep(0.5) GPIO.output(gLED, GPIO.LOW) # Kcamera @device_handler.command('com.acme.commands.pi_camera') def picamera(number, cameraKey): logging.info('Taking a %s %s times.' % (cameraKey, number)) GPIO.output(gLED, GPIO.HIGH) if cameraKey: # in ('picture', 'camera', 'photo'): fname = camera() result = os.system( 'python3 /home/pi/AIY-projects-python/src/examples/voice/visiontalk.py face ' + fname) #robot/vision.py "" '+fname) logging.info('Image:' + fname) GPIO.output(gLED, GPIO.LOW) @device_handler.command('com.acme.commands.pi_jp') def pijp(number, cameraKey): logging.info(cameraKey) GPIO.output(gLED, GPIO.HIGH) if cameraKey: # in ('picture', 'camera', 'photo'): fname = camera() result = os.system( 'python3 /home/pi/AIY-projects-python/src/examples/voice/visiontalk.py face ' + fname) #robot/vision.py "" '+fname) logging.info('Image:' + fname) GPIO.output(gLED, GPIO.LOW) @device_handler.command('com.acme.commands.pi_motor') def pimotor(number, directionKey): logging.info(directionKey) GPIO.output(gLED, GPIO.HIGH) result = os.system('python3 /home/pi/robot/motor.py') GPIO.output(gLED, GPIO.LOW) """if color.get('name') == "blue": #shoot: logging.info('Camera shoot!') GPIO.output(gLED, GPIO.HIGH) else: logging.info('Something else happened.') GPIO.output(gLED, GPIO.LOW)""" with SampleAssistant(lang, device_model_id, device_id, conversation_stream, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: # GPIO button added state = GPIO.input(gBUTTON) logging.info("Push button to Google talk!") GPIO.output(gLED, GPIO.HIGH) time.sleep(0.2) GPIO.output(gLED, GPIO.LOW) if state: pass #continue else: continue #pass #click.pause(info='Press Enter to send a new request...') continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
class Assistant(): def __init__(self): self.api_endpoint = ASSISTANT_API_ENDPOINT self.credentials = os.path.join( click.get_app_dir('google-oauthlib-tool'), 'credentials.json') # Setup logging. logging.basicConfig( ) # filename='assistant.log', level=logging.DEBUG if self.verbose else logging.INFO) self.logger = logging.getLogger("assistant") self.logger.setLevel(logging.DEBUG) self.custom_command = False self.once = True # Load OAuth 2.0 credentials. try: with open(self.credentials, 'r') as f: self.credentials = google.oauth2.credentials.Credentials( token=None, **json.load(f)) self.http_request = google.auth.transport.requests.Request() self.credentials.refresh(self.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.') return # Create an authorized gRPC channel. self.grpc_channel = google.auth.transport.grpc.secure_authorized_channel( self.credentials, self.http_request, self.api_endpoint) logging.info('Connecting to %s', self.api_endpoint) self.audio_sample_rate = audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE self.audio_sample_width = audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH self.audio_iter_size = audio_helpers.DEFAULT_AUDIO_ITER_SIZE self.audio_block_size = audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE self.audio_flush_size = audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE self.grpc_deadline = DEFAULT_GRPC_DEADLINE self.device_id = "roghecv2assistant-roghecv2-59lv9s" # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2_grpc.EmbeddedAssistantStub( self.grpc_channel) # Opaque blob provided in AssistResponse that, # when provided in a follow-up AssistRequest, # gives the Assistant a context marker within the current state # of the multi-Assist()-RPC "conversation". # This value, along with MicrophoneMode, supports a more natural # "conversation" with the Assistant. self.conversation_state = None # Force reset of first conversation. self.is_new_conversation = True self.device_handler = device_helpers.DeviceRequestHandler( "roghecv2assistant-roghecv2-59lv9s") # Stores the current volument percentage. # Note: No volume change is currently implemented in this sample self.volume_percentage = 50 self.display = True def assist(self, canvas): device_actions_futures = [] # Configure audio source and sink. self.audio_device = None self.audio_source = self.audio_device = ( self.audio_device or audio_helpers.SoundDeviceStream( sample_rate=self.audio_sample_rate, sample_width=self.audio_sample_width, block_size=self.audio_block_size, flush_size=self.audio_flush_size)) self.audio_sink = self.audio_device = ( self.audio_device or audio_helpers.SoundDeviceStream( sample_rate=self.audio_sample_rate, sample_width=self.audio_sample_width, block_size=self.audio_block_size, flush_size=self.audio_flush_size)) # Create conversation stream with the given audio source and sink. self.conversation_stream = audio_helpers.ConversationStream( source=self.audio_source, sink=self.audio_sink, iter_size=self.audio_iter_size, sample_width=self.audio_sample_width) restart = False continue_dialog = True try: while continue_dialog: continue_dialog = False self.conversation_stream.start_recording() self.logger.info('Recording audio request.') def iter_log_assist_requests(): for c in self.gen_assist_requests(): assistant_helpers.log_assist_request_without_audio(c) yield c logging.debug('Reached end of AssistRequest iteration.') # This generator yields AssistResponse proto messages # received from the gRPC Google Assistant API. for resp in self.assistant.Assist(iter_log_assist_requests(), self.grpc_deadline): assistant_helpers.log_assist_response_without_audio(resp) if resp.event_type == END_OF_UTTERANCE: logging.info('End of audio request detected.') logging.info('Stopping recording.') self.conversation_stream.stop_recording() if resp.speech_results: mess = ' '.join(r.transcript for r in resp.speech_results) logging.info('Transcript of user request: "%s".', mess) canvas[1]['text'] = mess if self.once: self.custom_command = google_control.custom_command_handler( mess, canvas) if len(resp.audio_out.audio_data ) > 0 and not self.custom_command: if not self.conversation_stream.playing: self.conversation_stream.stop_recording() self.conversation_stream.start_playback() logging.info('Playing assistant response.') self.conversation_stream.write( resp.audio_out.audio_data) if resp.dialog_state_out.conversation_state: conversation_state = resp.dialog_state_out.conversation_state logging.debug('Updating conversation state.') self.conversation_state = conversation_state if resp.dialog_state_out.volume_percentage != 0: volume_percentage = resp.dialog_state_out.volume_percentage logging.info('Setting volume to %s%%', volume_percentage) self.conversation_stream.volume_percentage = volume_percentage if resp.dialog_state_out.microphone_mode == DIALOG_FOLLOW_ON: continue_conversation = True logging.info('Expecting follow-on query from user.') elif resp.dialog_state_out.microphone_mode == CLOSE_MICROPHONE: continue_conversation = False if resp.device_action.device_request_json: device_request = json.loads( resp.device_action.device_request_json) fs = self.device_handler(device_request) if fs: device_actions_futures.extend(fs) if self.display and resp.screen_out.data and not self.custom_command: system_browser = browser_helpers.system_browser system_browser.display(resp.screen_out.data) self.scrapper(canvas) self.logger.info('Finished playing assistant response.') self.conversation_stream.stop_playback() except Exception as e: self._create_assistant() self.logger.exception('Skipping because of connection reset') restart = True try: self.conversation_stream.close() if restart: self.assist() except Exception: self.logger.error('Failed to close conversation_stream.') self.once = True device_handler = device_helpers.DeviceRequestHandler( "roghecv2assistant-roghecv2-59lv9s") def scrapper(self, canvas): tree = html.parse( "/home/ubberboy/Documents/RoghecV2/snowboy/google-assistant-sdk-screen-out.html" ) result = tree.xpath( '/html/body/div/div[2]/div[3]/div[2]/div/div/text()') final_text = '\n'.join(result) print(final_text) canvas[3]["text"] = ''.join(c if c <= '\uffff' else ''.join( chr(x) for x in struct.unpack('>2H', c.encode('utf-16be'))) for c in final_text) def _create_assistant(self): # Create gRPC channel grpc_channel = google.auth.transport.grpc.secure_authorized_channel( self.credentials, self.http_request, self.api_endpoint) self.logger.info('Connecting to %s', self.api_endpoint) # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2_grpc.EmbeddedAssistantStub( grpc_channel) def is_grpc_error_unavailable(e): is_grpc_error = isinstance(e, grpc.RpcError) if is_grpc_error and (e.code() == grpc.StatusCode.UNAVAILABLE): logging.error('grpc unavailable error: %s', e) return True return False @retry(reraise=True, stop=stop_after_attempt(3), retry=retry_if_exception(is_grpc_error_unavailable)) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') # This generator yields ConverseRequest to send to the gRPC # Google Assistant API. def gen_assist_requests(self): """Yields: AssistRequest messages to send to the API.""" config = embedded_assistant_pb2.AssistConfig( audio_in_config=embedded_assistant_pb2.AudioInConfig( encoding='LINEAR16', sample_rate_hertz=self.conversation_stream.sample_rate, ), audio_out_config=embedded_assistant_pb2.AudioOutConfig( encoding='LINEAR16', sample_rate_hertz=self.conversation_stream.sample_rate, volume_percentage=self.conversation_stream.volume_percentage, ), dialog_state_in=embedded_assistant_pb2.DialogStateIn( conversation_state=self.conversation_state, is_new_conversation=self.is_new_conversation, ), device_config=embedded_assistant_pb2.DeviceConfig( device_id=self.device_id, device_model_id=self.device_id, )) if self.display: config.screen_out_config.screen_mode = PLAYING # Continue current conversation with later requests. self.is_new_conversation = False # The first AssistRequest must contain the AssistConfig # and no audio data. yield embedded_assistant_pb2.AssistRequest(config=config) for data in self.conversation_stream: # Subsequent requests need audio data, but not config. yield embedded_assistant_pb2.AssistRequest(audio_in=data)
def main(api_endpoint=ASSISTANT_API_ENDPOINT, credentials=os.path.join(click.get_app_dir('google-oauthlib-tool'), 'credentials.json'), device_config=os.path.join(click.get_app_dir('googlesamples-assistant'),'device_config.json'), device_id=None, project_id=None, device_model_id=None, input_audio_file=None, output_audio_file=None, audio_sample_rate=audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE, audio_sample_width=audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH, audio_block_size=audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE, audio_flush_size=audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE, audio_iter_size=audio_helpers.DEFAULT_AUDIO_ITER_SIZE, lang='en-US', display=False, verbose=False, once=False, grpc_deadline=DEFAULT_GRPC_DEADLINE, *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> """ connectMQTT() # 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_source = audio_device = ( audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) ) if output_audio_file: audio_sink = audio_helpers.WaveSink( open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_sink = audio_device = ( audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) ) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') @device_handler.command('com.example.commands.BlinkLight') def blink(speed, number): logging.info('Blinking device %s times.' % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info('Device is blinking.') time.sleep(delay) with SampleAssistant(lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # This will loop as long as assist() returns true # meaning that a follow on query for the user is # expected. If the once flag is set only one request # is performed no matter what assist() returns. # assist() can be thought of as a state continue_conversation while assistant.assist(): if once: break
def main(api_endpoint, credentials, device_model_id, device_id, lang, display, verbose, grpc_deadline, *args, **kwargs): # 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.') return # 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('com.example.commands.SearchCar') def search_cars(filter, param): print('SEARCH CARS\n' + 'FILTER: ' + filter + ', PARAM: ' + param) try: response = requests.get( 'http://*****:*****@assistant> %s' % response_text)
def main(project_id=None, device_model_id=None, device_id=None, api_endpoint=ASSISTANT_API_ENDPOINT, credentials=os.path.join(click.get_app_dir("google-oauthlib-tool"), "credentials.json"), device_config=os.path.join( click.get_app_dir("googlesamples-assistant"), "device_config.json"), lang="en-US", display=False, verbose=False, audio_sample_rate=audio_helpers.DEFAULT_AUDIO_SAMPLE_RATE, audio_sample_width=audio_helpers.DEFAULT_AUDIO_SAMPLE_WIDTH, audio_iter_size=audio_helpers.DEFAULT_AUDIO_ITER_SIZE, audio_block_size=audio_helpers.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE, audio_flush_size=audio_helpers.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE, grpc_deadline=DEFAULT_GRPC_DEADLINE, once=False, view=None, *args, **kwargs): # 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) audio_device = None # Configure audio source and sink. audio_source = audio_device = audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size, ) audio_sink = audio_device = audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size, ) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command("com.example.commands.SwitchView") def switch(name): view.show_frame(name) with SampleAssistant( lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler, view, ) as assistant: # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: click.pause(info="Press Enter to send a new request...") continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
record() response = detect_intent_audio(project_id, session_id, input_audio_path, lang) handle_response(response) if __name__ == "__main__": logging.basicConfig(level=logging.DEBUG) arduinoSerialData = serial.Serial(find_ports()[0], 9600) #Setup for the Google Assistant API with open(credentials, 'r') as f: #Grab those Credentials (must be in this directory) credentials = google.oauth2.credentials.Credentials(token=None, **json.load(f)) http_request = google.auth.transport.requests.Request() credentials.refresh(http_request) grpc_channel = google.auth.transport.grpc.secure_authorized_channel( #Request a grpc channel with those Credentials credentials, http_request, api_endpoint) logging.info('Connecting to %s', api_endpoint) device_handler = device_helpers.DeviceRequestHandler(device_id) audio = pyaudio.PyAudio() play_audio_file("startup.wav") signal.signal(signal.SIGINT, signal_handler) detector = snowboydecoder.HotwordDetector(model, sensitivity=mic_sensitivity) send('1.0.0') listen()
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, 'rb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_source = audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) if output_audio_file: audio_sink = audio_helpers.WaveSink( open(output_audio_file, 'wb'), sample_rate=audio_sample_rate, sample_width=audio_sample_width ) else: audio_sink = audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size ) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command('action.devices.commands.OnOff') def onoff(on): if on: logging.info('Turning device on') else: logging.info('Turning device off') with SampleAssistant(lang, device_model_id, device_id, conversation_stream, grpc_channel, grpc_deadline, device_handler) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: print("[joe debug]") if wait_for_user_trigger: click.pause(info='Press Enter to send a new request...') continue_conversation = assistant.assist() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break
def main(api_endpoint, credentials, project_id, device_model_id, device_id, device_config, lang, display, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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) # Configure audio source and sink. audio_device = None if input_audio_file: audio_source = audio_helpers.WaveSource( open(input_audio_file, "rb"), sample_rate=audio_sample_rate, sample_width=audio_sample_width, ) else: audio_source = audio_device = audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size, ) if output_audio_file: audio_sink = audio_helpers.WaveSink( open(output_audio_file, "wb"), sample_rate=audio_sample_rate, sample_width=audio_sample_width, ) else: audio_sink = audio_device = audio_device or audio_helpers.SoundDeviceStream( sample_rate=audio_sample_rate, sample_width=audio_sample_width, block_size=audio_block_size, flush_size=audio_flush_size, ) # Create conversation stream with the given audio source and sink. conversation_stream = audio_helpers.ConversationStream( source=audio_source, sink=audio_sink, iter_size=audio_iter_size, sample_width=audio_sample_width, ) 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) device_handler = device_helpers.DeviceRequestHandler(device_id) @device_handler.command("action.devices.commands.OnOff") def onoff(on): if on: logging.info("Turning device on") else: logging.info("Turning device off") @device_handler.command("com.example.commands.BlinkLight") def blink(speed, number): logging.info("Blinking device %s times." % number) delay = 1 if speed == "SLOWLY": delay = 2 elif speed == "QUICKLY": delay = 0.5 for i in range(int(number)): logging.info("Device is blinking.") time.sleep(delay) with SampleAssistant( lang, device_model_id, device_id, conversation_stream, display, grpc_channel, grpc_deadline, device_handler, ) as assistant: # If file arguments are supplied: # exit after the first turn of the conversation. if input_audio_file or output_audio_file: assistant.assist() return # If no file arguments supplied: # keep recording voice requests using the microphone # and playing back assistant response using the speaker. # When the once flag is set, don't wait for a trigger. Otherwise, wait. wait_for_user_trigger = not once while True: if wait_for_user_trigger: print("Press button to initiate a new request") dots.fill(0x00000F) # lite blue LEDs dots.show() while button.value: time.sleep(0.1) # red LEDs dots.fill(0xFF0000) dots.show() continue_conversation = assistant.assist() # LEDs off dots.fill(0x000000) dots.show() # wait for user trigger if there is no follow-up turn in # the conversation. wait_for_user_trigger = not continue_conversation # If we only want one conversation, break. if once and (not continue_conversation): break