def setup_assistant(): # Load credentials. try: credentials = os.path.join( click.get_app_dir(common_settings.ASSISTANT_APP_NAME), common_settings.ASSISTANT_CREDENTIALS_FILENAME) global creds creds = auth_helpers.load_credentials( credentials, scopes=[ common_settings.ASSISTANT_OAUTH_SCOPE, common_settings.PUBSUB_OAUTH_SCOPE ]) except Exception as e: logging.error('Error loading credentials: %s', e) logging.error('Run auth_helpers to initialize new OAuth2 credentials.') return -1 # Create gRPC channel grpc_channel = auth_helpers.create_grpc_channel(ASSISTANT_API_ENDPOINT, creds) logging.info('Connecting to %s', ASSISTANT_API_ENDPOINT) # Create Google Assistant API gRPC client. global assistant assistant = embedded_assistant_pb2.EmbeddedAssistantStub(grpc_channel) return 0
def __init__(self, conversation_stream, channel, deadline_sec, conversation_stream_wav, nsrunning_nao, nsrunning_laptop, nsrunning_laptop_nao, nsdevice_name, nsconversation_contd, nsbehavior_proxy): print("enetered into contructor of assistant") self.running_nao = nsrunning_nao self.running_laptop = nsrunning_laptop self.running_laptop_nao = nsrunning_laptop_nao self.device_name = nsdevice_name self.conversation_contd = nsconversation_contd self.behavior_proxy = nsbehavior_proxy self.conversation_stream = None #self.conversation_stream = conversation_stream self.conversation_stream_sd = conversation_stream self.conversation_stream_wav = conversation_stream_wav self.conversation_state = None # Create Google Assistant API gRPC client. # Running from laptop or laptop connected with nao uses pb2_grpc.EmbeddedAssistantStub #Running in nao uses pb2.EmbeddedAssistantStub. if (self.running_laptop == self.device_name or self.running_laptop_nao == self.device_name): self.assistant = embedded_assistant_pb2_grpc.EmbeddedAssistantStub( channel) else: self.assistant = embedded_assistant_pb2.EmbeddedAssistantStub( channel) #self.assistant = embedded_assistant_pb2_grpc.EmbeddedAssistantStub(channel) self.deadline = deadline_sec print("end of the assisant")
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.EmbeddedAssistantStub(grpc_channel)
def _create_assistant(self): # Create gRPC channel grpc_channel = auth_helpers.create_grpc_channel( self.api_endpoint, self.creds) self.logger.info('Connecting to %s', self.api_endpoint) # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2.EmbeddedAssistantStub( grpc_channel)
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) # 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 # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2.EmbeddedAssistantStub( self.grpc_channel) # Stores an opaque blob provided in ConverseResponse that, # when provided in a follow-up ConverseRequest, # gives the Assistant a context marker within the current state # of the multi-Converse()-RPC "conversation". # This value, along with MicrophoneMode, supports a more natural # "conversation" with the Assistant. self.conversation_state_bytes = None # Stores the current volument percentage. # Note: No volume change is currently implemented in this sample self.volume_percentage = 80
def __init__(self, conversation_stream, channel, deadline_sec): self.conversation_stream = conversation_stream # Opaque blob provided in ConverseResponse that, # when provided in a follow-up ConverseRequest, # gives the Assistant a context marker within the current state # of the multi-Converse()-RPC "conversation". # This value, along with MicrophoneMode, supports a more natural # "conversation" with the Assistant. self.conversation_state = None # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2.EmbeddedAssistantStub(channel) self.deadline = deadline_sec
def init_grpc(self): try: creds = auth_helpers.load_credentials( credentials, scopes=[common_settings.ASSISTANT_OAUTH_SCOPE]) except Exception as e: logging.error('Error loading credentials: %s', e) logging.error( 'Run auth_helpers to initialize new OAuth2 credentials.') # Create gRPC channel grpc_channel = auth_helpers.create_grpc_channel( api_endpoint, creds, ssl_credentials_file=None, grpc_channel_options=None) logging.info('Connecting to %s', api_endpoint) # Create Google Assistant API gRPC client. self._assistant = embedded_assistant_pb2.EmbeddedAssistantStub( grpc_channel)
def initialize(self): self.ASSISTANT_API_ENDPOINT = 'embeddedassistant.googleapis.com' self.END_OF_UTTERANCE = embedded_assistant_pb2.ConverseResponse.END_OF_UTTERANCE self.DIALOG_FOLLOW_ON = embedded_assistant_pb2.ConverseResult.DIALOG_FOLLOW_ON self.CLOSE_MICROPHONE = embedded_assistant_pb2.ConverseResult.CLOSE_MICROPHONE api_endpoint=self.ASSISTANT_API_ENDPOINT credentials=os.path.join(click.get_app_dir(common_settings.ASSISTANT_APP_NAME), common_settings.ASSISTANT_CREDENTIALS_FILENAME) verbose=False self.audio_sample_rate=common_settings.DEFAULT_AUDIO_SAMPLE_RATE self.audio_sample_width=common_settings.DEFAULT_AUDIO_SAMPLE_WIDTH self.audio_iter_size=common_settings.DEFAULT_AUDIO_ITER_SIZE self.audio_block_size=common_settings.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE self.audio_flush_size=common_settings.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE self.grpc_deadline=common_settings.DEFAULT_GRPC_DEADLINE # Load credentials. try: creds = auth_helpers.load_credentials(credentials, scopes=[common_settings.ASSISTANT_OAUTH_SCOPE]) except Exception as e: self.error('Error loading credentials: %s', e) self.error('Run auth_helpers to initialize new OAuth2 credentials.') return # Create gRPC channel grpc_channel = auth_helpers.create_grpc_channel(api_endpoint, creds, ssl_credentials_file="", grpc_channel_options="") self.log('Connecting to google') # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2.EmbeddedAssistantStub(grpc_channel) # 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) self.conversation_state_bytes = None self.volume_percentage = 70 self.listen_state(self.startGH,self.args["activation_boolean"],new="on") self.log("App started. now listening to Homeassistant input")
def __init__(self): self.api_endpoint = Assistant.ASSISTANT_API_ENDPOINT self.credentials = os.path.join( click.get_app_dir(common_settings.ASSISTANT_APP_NAME), common_settings.ASSISTANT_CREDENTIALS_FILENAME) self.verbose = False self.audio_sample_rate = common_settings.DEFAULT_AUDIO_SAMPLE_RATE self.audio_sample_width = common_settings.DEFAULT_AUDIO_SAMPLE_WIDTH self.audio_iter_size = common_settings.DEFAULT_AUDIO_ITER_SIZE self.audio_block_size = common_settings.DEFAULT_AUDIO_DEVICE_BLOCK_SIZE self.audio_flush_size = common_settings.DEFAULT_AUDIO_DEVICE_FLUSH_SIZE self.grpc_deadline = common_settings.DEFAULT_GRPC_DEADLINE # 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.creds = auth_helpers.load_credentials( self.credentials, scopes=[common_settings.ASSISTANT_OAUTH_SCOPE]) # Create gRPC channel grpc_channel = auth_helpers.create_grpc_channel( self.api_endpoint, self.creds) self.logger.info('Connecting to %s', self.api_endpoint) # Create Google Assistant API gRPC client. self.assistant = embedded_assistant_pb2.EmbeddedAssistantStub( grpc_channel) # Stores an opaque blob provided in ConverseResponse that, # when provided in a follow-up ConverseRequest, # gives the Assistant a context marker within the current state # of the multi-Converse()-RPC "conversation". # This value, along with MicrophoneMode, supports a more natural # "conversation" with the Assistant. self.conversation_state_bytes = None # Stores the current volument percentage. # Note: No volume change is currently implemented in this sample self.volume_percentage = 50
def main(api_endpoint, credentials, verbose, input_audio_file, output_audio_file, audio_sample_rate, audio_sample_width, audio_iter_size, audio_block_size, audio_flush_size, 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> """ # Setup logging. logging.basicConfig(level=logging.DEBUG if verbose else logging.INFO) # Load credentials. try: creds = auth_helpers.load_credentials( credentials, scopes=[common_settings.ASSISTANT_OAUTH_SCOPE] ) except Exception as e: logging.error('Error loading credentials: %s', e) logging.error('Run auth_helpers to initialize new OAuth2 credentials.') return # Create gRPC channel grpc_channel = auth_helpers.create_grpc_channel( api_endpoint, creds, ssl_credentials_file=kwargs.get('ssl_credentials_for_testing'), grpc_channel_options=kwargs.get('grpc_channel_option') ) logging.info('Connecting to %s', api_endpoint) # Create Google Assistant API gRPC client. assistant = embedded_assistant_pb2.EmbeddedAssistantStub(grpc_channel) # 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, ) # Interactive by default. wait_for_user_trigger = True # If file arguments are supplied, don't wait for user trigger. if input_audio_file or output_audio_file: wait_for_user_trigger = False # Stores an opaque blob provided in ConverseResponse that, # when provided in a follow-up ConverseRequest, # gives the Assistant a context marker within the current state # of the multi-Converse()-RPC "conversation". # This value, along with MicrophoneMode, supports a more natural # "conversation" with the Assistant. conversation_state_bytes = None # Stores the current volument percentage. # Note: No volume change is currently implemented in this sample volume_percentage = 50 while True: if wait_for_user_trigger: click.pause(info='Press Enter to send a new request...') conversation_stream.start_recording() logging.info('Recording audio request.') # This generator yields ConverseRequest to send to the gRPC # Google Assistant API. def gen_converse_requests(): converse_state = None if conversation_state_bytes: logging.debug('Sending converse_state: %s', conversation_state_bytes) converse_state = embedded_assistant_pb2.ConverseState( conversation_state=conversation_state_bytes, ) config = embedded_assistant_pb2.ConverseConfig( audio_in_config=embedded_assistant_pb2.AudioInConfig( encoding='LINEAR16', sample_rate_hertz=int(audio_sample_rate), ), audio_out_config=embedded_assistant_pb2.AudioOutConfig( encoding='LINEAR16', sample_rate_hertz=int(audio_sample_rate), volume_percentage=volume_percentage, ), converse_state=converse_state ) # The first ConverseRequest must contain the ConverseConfig # and no audio data. yield embedded_assistant_pb2.ConverseRequest(config=config) for data in conversation_stream: # Subsequent requests need audio data, but not config. yield embedded_assistant_pb2.ConverseRequest(audio_in=data) def iter_converse_requests(): for c in gen_converse_requests(): assistant_helpers.log_converse_request_without_audio(c) yield c conversation_stream.start_playback() # This generator yields ConverseResponse proto messages # received from the gRPC Google Assistant API. for resp in assistant.Converse(iter_converse_requests(), grpc_deadline): assistant_helpers.log_converse_response_without_audio(resp) if resp.error.code != code_pb2.OK: logging.error('server error: %s', resp.error.message) break if resp.event_type == END_OF_UTTERANCE: logging.info('End of audio request detected') conversation_stream.stop_recording() if resp.result.spoken_request_text: logging.info('Transcript of user request: "%s".', resp.result.spoken_request_text) logging.info('Playing assistant response.') if len(resp.audio_out.audio_data) > 0: conversation_stream.write(resp.audio_out.audio_data) if resp.result.spoken_response_text: logging.info( 'Transcript of TTS response ' '(only populated from IFTTT): "%s".', resp.result.spoken_response_text) if resp.result.conversation_state: conversation_state_bytes = resp.result.conversation_state if resp.result.volume_percentage != 0: volume_percentage = resp.result.volume_percentage logging.info('Volume should be set to %s%%', volume_percentage) if resp.result.microphone_mode == DIALOG_FOLLOW_ON: wait_for_user_trigger = False logging.info('Expecting follow-on query from user.') elif resp.result.microphone_mode == CLOSE_MICROPHONE: wait_for_user_trigger = True logging.info('Finished playing assistant response.') conversation_stream.stop_playback() # If file arguments are supplied, end the conversation. if input_audio_file or output_audio_file: break conversation_stream.close()
def _make_service(self, channel): return embedded_assistant_pb2.EmbeddedAssistantStub(channel)