def detect_intent_texts_with_location(project_id, location_id, session_id, texts, language_code): """Returns the result of detect intent with texts as inputs. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient( client_options={ "api_endpoint": f"{location_id}-dialogflow.googleapis.com" }) session = ( f"projects/{project_id}/locations/{location_id}/agent/sessions/{session_id}" ) print(f"Session path: {session}\n") for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) print("=" * 20) print(f"Query text: {response.query_result.query_text}") print( f"Detected intent: {response.query_result.intent.display_name} (confidence: {response.query_result.intent_detection_confidence,})\n" ) print(f"Fulfillment text: {response.query_result.fulfillment_text}\n")
def send_message(self, text, user_id, language_code="en"): session_client = dialogflow.SessionsClient() session = session_client.session_path(self.PROJECT_ID, user_id) print("Session path: {}\n".format(session)) text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent( request={"session": session, "query_input": query_input} ) print("=" * 20) print( "Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, ) ) print(response.query_result) return response.query_result.intent.display_name
def text_message(update, context): project_id = context.bot_data['project_id'] text = update.message.text user_id = update.message.chat_id session_id = "tg-id" + str(user_id) session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) text_input = dialogflow.TextInput(text=text, language_code="ru") query_input = dialogflow.QueryInput(text=text_input) try: response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) response = response.query_result.fulfillment_text context.bot.send_message(chat_id=update.effective_chat.id, text=response) except Exception: logger.exception("Error")
def detect_intent_texts(session_id, text): '''Connects to DialogFlow using the environment variables 'DF_LANGUAGE_CODE' to determine the language code, 'DF_CREDENTIALS' for authentication. Credentials need to be stored as an environment variable. Before doing so, line-breaks need to be removed, and double-quotes turned into single-quotes. ''' try: language_code = os.environ['DF_LANGUAGE_CODE'] credentials = os.environ['DF_CREDENTIALS'] credentials = ast.literal_eval(credentials) project_id = credentials['project_id'] cr = Credentials.from_service_account_info(credentials) session_client = dialogflow.SessionsClient(credentials=cr) session = session_client.session_path(project_id, session_id) print('Session path: {}\n'.format(session)) text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ 'session': session, 'query_input': query_input }) response = proto_message_to_dict(response.query_result) except Exception as e: response = 'DialogFlow error: ' + str(e) return response
def detect_intent_texts(project_id, session_id, texts, language_code="ru-RU"): """Returns the result of detect intent with texts as inputs. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) logger.info("Session path: {}\n".format(session)) for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) logger.info("=" * 20) logger.info("Query text: {}".format(response.query_result.query_text)) logger.info("Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, )) logger.info("Fulfillment text: {}\n".format( response.query_result.fulfillment_text)) if response.query_result.intent.is_fallback: return False return response.query_result.fulfillment_text
def detect_intent_texts(project_id, session_id, texts, language_code): """Returns the result of detect intent with texts as inputs. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) print('Session path: {}\n'.format(session)) for text in texts: text_input = dialogflow.TextInput( text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent( request={'session': session, 'query_input': query_input}) print('=' * 20) print('Query text: {}'.format(response.query_result.query_text)) print('Detected intent: {} (confidence: {})\n'.format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence)) print('Fulfillment text: {}\n'.format( response.query_result.fulfillment_text))
def detect_intent_texts(project_id, session_id, text, language_code): """Returns the result of detect intent from with texts as inputs and is the text fallback or not. Using the same `session_id` between requests allows continuation of the conversation.""" session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) text_input = dialogflow.TextInput( text=text, language_code=language_code, ) query_input = dialogflow.QueryInput( text=text_input ) response = session_client.detect_intent( request={"session": session, "query_input": query_input} ) text_result = response.query_result.fulfillment_text text_is_fallback = False if response.query_result.intent.is_fallback: text_is_fallback = True return text_result, text_is_fallback
def detect_intent_text(session_id, text): """Returns the result of detect intent with texts as inputs. Using the same `session_id` between requests allows continuation of the conversation.""" session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) print("Session path: {}\n".format(session)) text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) print("=" * 20) print("Query text: {}".format(response.query_result.query_text)) print("Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, )) print("Fulfillment text: {}\n".format( response.query_result.fulfillment_text)) return response.query_result.fulfillment_text
def detect_intent_texts(project_id, session_id, text, language_code): session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent( session=session, query_input=query_input) return response.query_result
def __init__(self, project_id='bot-test-303915', session_id=123456789): self.__project_id = project_id self.__session_id = session_id self.__session_client = dialogflow.SessionsClient() self.__session = self.__session_client.session_path(project_id, session_id) self.__courses = [] self.__attributes = [] self.__data = yaml.full_load(open('courses3.yaml'))
def detect_intent_stream(project_id, session_id, audio_file_path, language_code): """Returns the result of detect intent with streaming audio as input. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient() # Note: hard coding audio_encoding and sample_rate_hertz for simplicity. audio_encoding = dialogflow.AudioEncoding.AUDIO_ENCODING_LINEAR_16 sample_rate_hertz = 16000 session_path = session_client.session_path(project_id, session_id) print('Session path: {}\n'.format(session_path)) def request_generator(audio_config, audio_file_path): query_input = dialogflow.QueryInput(audio_config=audio_config) # The first request contains the configuration. yield dialogflow.StreamingDetectIntentRequest(session=session_path, query_input=query_input) # Here we are reading small chunks of audio data from a local # audio file. In practice these chunks should come from # an audio input device. with open(audio_file_path, 'rb') as audio_file: while True: chunk = audio_file.read(4096) if not chunk: break # The later requests contains audio data. yield dialogflow.StreamingDetectIntentRequest( input_audio=chunk) audio_config = dialogflow.InputAudioConfig( audio_encoding=audio_encoding, language_code=language_code, sample_rate_hertz=sample_rate_hertz) requests = request_generator(audio_config, audio_file_path) responses = session_client.streaming_detect_intent(requests=requests) print('=' * 20) for response in responses: print('Intermediate transcript: "{}".'.format( response.recognition_result.transcript)) # Note: The result from the last response is the final transcript along # with the detected content. query_result = response.query_result print('=' * 20) print('Query text: {}'.format(query_result.query_text)) print('Detected intent: {} (confidence: {})\n'.format( query_result.intent.display_name, query_result.intent_detection_confidence)) print('Fulfillment text: {}\n'.format(query_result.fulfillment_text))
def answer_to_user(self, update, context): session_client = dialogflow.SessionsClient() session = session_client.session_path(os.environ['GOOGLE_PROJECT_NAME'], f'tg-{update.message.chat_id}') text_input = dialogflow.TextInput(text=update.message.text, language_code='ru') query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={'session': session, 'query_input': query_input}) update.message.reply_text(response.query_result.fulfillment_text)
def detect_intent_texts(project_id, session_id, texts, language_code): session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) return response.query_result #.fulfillment_text
async def post_dialogflow(username: str, request: dict): text = request["text"] name = request["name"] session_client = dialogflow.SessionsClient() session = session_client.session_path('gitrich-9txq', str(uuid.uuid4())) text_input = dialogflow.TextInput(text=text, language_code='en') query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) params = response.query_result.parameters try: price = params["unit-currency"]["amount"] price = f"{price:.2f}" except TypeError: return ErrorResponseModel("Price not found within text", 400, "Please provide the price of the item") if params["foods"] != "": category = "Food & Drinks" else: category = "Entertainment" receipt = { "name": name, "amount": price, "items": {}, "category": category, "image": "", "date": datetime.now( pytz.timezone('Asia/Singapore')).strftime('%d/%m/%Y %H:%M:%S') } success, receipt = await add_receipt(username, receipt) if not (success): return ErrorResponseModel("Unexpected Error Occured", 400, "Please check request body again") return ResponseModel(receipt, 201, "Successfully uploaded adhoc receipt")
def detect_intent_with_sentiment_analysis(project_id, session_id, texts, language_code): """Returns the result of detect intent with texts as inputs and analyzes the sentiment of the query text. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session_path = session_client.session_path(project_id, session_id) print("Session path: {}\n".format(session_path)) for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) # Enable sentiment analysis sentiment_config = dialogflow.SentimentAnalysisRequestConfig( analyze_query_text_sentiment=True) # Set the query parameters with sentiment analysis query_params = dialogflow.QueryParameters( sentiment_analysis_request_config=sentiment_config) response = session_client.detect_intent( request={ "session": session_path, "query_input": query_input, "query_params": query_params, }) print("=" * 20) print("Query text: {}".format(response.query_result.query_text)) print("Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, )) print("Fulfillment text: {}\n".format( response.query_result.fulfillment_text)) # Score between -1.0 (negative sentiment) and 1.0 (positive sentiment). print("Query Text Sentiment Score: {}\n".format( response.query_result.sentiment_analysis_result. query_text_sentiment.score)) print("Query Text Sentiment Magnitude: {}\n".format( response.query_result.sentiment_analysis_result. query_text_sentiment.magnitude))
def detect_intent_texts(project_id, session_id, text, language_code): from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) if not response.query_result.intent.is_fallback: return response.query_result.fulfillment_text
def __init__(self, trans_obj: Translator, lang): self.lang = lang self.lang_to_code = supported_speech_langs() self.situation = "You are walking down the street during the last day of summer break before school \ starts again in the summer. You decide to go to a small food place around the corner.\ Your goal is to get through this meal and the conversation. \n" self.session_client = dialogflow.SessionsClient() #for the convo bot self.session = self.session_client.session_path("botlate", 123456) #sentiment client self.sent_client = language_v1.LanguageServiceClient() self.type_ = language_v1.Document.Type.PLAIN_TEXT self.trans_obj = trans_obj self.elem_counter = 0 self.convo_elems = self.load_convo_elems()
def detect_intent_with_texttospeech_response(project_id, session_id, texts, language_code): """Returns the result of detect intent with texts as inputs and includes the response in an audio format. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session_path = session_client.session_path(project_id, session_id) print("Session path: {}\n".format(session_path)) for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) # Set the query parameters with sentiment analysis output_audio_config = dialogflow.OutputAudioConfig( audio_encoding=dialogflow.OutputAudioEncoding. OUTPUT_AUDIO_ENCODING_LINEAR_16) request = dialogflow.DetectIntentRequest( session=session_path, query_input=query_input, output_audio_config=output_audio_config, ) response = session_client.detect_intent(request=request) print("=" * 20) print("Query text: {}".format(response.query_result.query_text)) print("Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, )) print("Fulfillment text: {}\n".format( response.query_result.fulfillment_text)) # The response's audio_content is binary. with open("output.wav", "wb") as out: out.write(response.output_audio) print('Audio content written to file "output.wav"')
def detect_intent_audio(project_id, session_id, audio_file_path, language_code): """Returns the result of detect intent with an audio file as input. Using the same `session_id` between requests allows continuation of the conversation.""" from google.cloud import dialogflow session_client = dialogflow.SessionsClient() # Note: hard coding audio_encoding and sample_rate_hertz for simplicity. audio_encoding = dialogflow.AudioEncoding.AUDIO_ENCODING_LINEAR_16 sample_rate_hertz = 16000 session = session_client.session_path(project_id, session_id) print("Session path: {}\n".format(session)) with open(audio_file_path, "rb") as audio_file: input_audio = audio_file.read() audio_config = dialogflow.InputAudioConfig( audio_encoding=audio_encoding, language_code=language_code, sample_rate_hertz=sample_rate_hertz, ) query_input = dialogflow.QueryInput(audio_config=audio_config) request = dialogflow.DetectIntentRequest( session=session, query_input=query_input, input_audio=input_audio, ) response = session_client.detect_intent(request=request) print("=" * 20) print("Query text: {}".format(response.query_result.query_text)) print("Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, )) print("Fulfillment text: {}\n".format( response.query_result.fulfillment_text))
def detect_intent_texts(text): project_id = 'esoteric-virtue-306011' session_id = '123456789' from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) text_input = dialogflow.TextInput(text=text, language_code='en-US') query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) return response.query_result
def detect_intent_texts(project_id, session_id, texts, language_code): """Returns the result of detect intent with texts as inputs. Using the same `session_id` between requests allows continuation of the conversation.""" # 건들지 않아도 되는 부분 시작 from google.cloud import dialogflow session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) print('Session path: {}\n'.format(session)) for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ 'session': session, 'query_input': query_input }) print('=' * 20) print('Query text: {}'.format(response.query_result.query_text)) print('Detected intent: {} (confidence: {})\n'.format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence)) print('Fulfillment text: {}\n'.format( response.query_result.fulfillment_text)) # 건들지 않아도 되는 부분 끝 # 인텐트 이름 [3] intent_name = response.query_result.intent.display_name # 여기에서 intent_name에 따른 기능 분리 [4] if (intent_name == "WriteToFirestore"): res = save_query_by_parameters( response.query_result.parameters) # [5] return res
def detect_intent_texts(project_id, session_id, texts, language_code): """Returns the result of detect intent with texts as inputs. Using the same `session_id` between requests allows continuation of the conversation.""" session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ 'session': session, 'query_input': query_input }) if not response.query_result.intent.is_fallback: return response.query_result.fulfillment_text
def detect_intent(text, session_id): if session_id == None: session_id = uuid.uuid4() session_client = dialogflow.SessionsClient() session = session_client.session_path(PROJECTID, session_id) text_input = dialogflow.TextInput(text=text, language_code='en') query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) print("=" * 20) print("Query text: {}".format(response.query_result.query_text)) print("Detected intent: {} (confidence: {})\n".format( response.query_result.intent.display_name, response.query_result.intent_detection_confidence, )) if response.query_result.all_required_params_present: display_name = response.query_result.intent.display_name if display_name == 'cases_intent' or display_name == 'facilities_intent': return ( True, response.query_result.parameters["location"]["street-address"], response.query_result.parameters["geo-city"], response.query_result.intent.display_name, session_id, ) #all required, street, city, intent, session_id return ( False, response.query_result.fulfillment_text, session_id, ) return ( False, response.query_result.fulfillment_text, session_id, ) #False, fulfillment_messsage, session_id
def detectEvent(self, session_id, event_name, payload): session_client = dialogflow.SessionsClient() session = session_client.session_path(self._project_id, session_id) parameters = Struct(fields={'value': Value(string_value=payload)}) js = self.safeParseJson(payload) if hasattr(js, 'items'): for key, value in js.items(): nKey = self.normilizeKeyDialogflow(key) parameters[nKey] = value event_input = dialogflow.EventInput(name=event_name, language_code='ru-RU', parameters=parameters) query_input = dialogflow.QueryInput(event=event_input) try: response = session_client.detect_intent(session=session, query_input=query_input) self.handleDialogflowResponse(response) except: print("error detect event") self._isEndConversation = True if not self._isEndConversation: self.playSound(self._wake_sound_file) print('event conversation continue') self.stopDetectHotword() self.runDetectIntent(session_id) else: print('event conversation finished') self.stopDetectIntent() self.runDetectHotword()
def answer_to_user(self, event): try: session_client = dialogflow.SessionsClient() session = session_client.session_path( os.environ['GOOGLE_PROJECT_NAME'], f'vk-{event.user_id}') text_input = dialogflow.TextInput(text=event.text, language_code='ru') query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ 'session': session, 'query_input': query_input }) if not response.query_result.intent.is_fallback: self.vk_api.messages.send( user_id=event.user_id, message=response.query_result.fulfillment_text, random_id=random.randint(1, 1000)) except InvalidArgument: self.vk_api.messages.send( user_id=event.user_id, message= 'Введена слишком длинная строка. Длинна строки не должна превышать 256 символов.', random_id=random.randint(1, 1000))
def detect_intent_texts(project_id, session_id, texts, language_code): from google.cloud import dialogflow import os os.environ[ "GOOGLE_APPLICATION_CREDENTIALS"] = "/home/reflect9/mysite/firstbot-iidr-e3bf3507f860.json" session_client = dialogflow.SessionsClient() session = session_client.session_path(project_id, session_id) responses = [] for text in texts: text_input = dialogflow.TextInput(text=text, language_code=language_code) query_input = dialogflow.QueryInput(text=text_input) response = session_client.detect_intent(request={ "session": session, "query_input": query_input }) responses.append({ "query": response.query_result.query_text, "intent": response.query_result.intent.display_name, "confidence": response.query_result.intent_detection_confidence, "answer": response.query_result.fulfillment_text }) return responses
def runDetectIntent(self, session_id): print("run detect intent") self._isIntentDetect = True session_client = dialogflow.SessionsClient() audio_encoding = dialogflow.AudioEncoding.AUDIO_ENCODING_LINEAR_16 sample_rate_hertz = 16000 language_code = 'ru-RU' session_id = '{}'.format(session_id) print("session #{}".format(session_id)) session_path = session_client.session_path(self._project_id, session_id) print('Session path: {}\n'.format(session_path)) def _audio_callback_intent(in_data, frame_count, time_info, status): if not self._is_playing: self._buff.put(in_data) return None, pyaudio.paContinue try: num_channels = 1 audio_format = pyaudio.paInt16 frame_length = 4096 audio_config = dialogflow.InputAudioConfig( audio_encoding=audio_encoding, language_code=language_code, sample_rate_hertz=sample_rate_hertz) self._pa = pyaudio.PyAudio() self._audio_stream = self._pa.open( rate=sample_rate_hertz, channels=num_channels, format=audio_format, input=True, frames_per_buffer=frame_length, input_device_index=self._input_device_index, stream_callback=_audio_callback_intent) self._audio_stream.start_stream() print("Waiting for command ...\n") def request_generator(audio_config): query_input = dialogflow.QueryInput(audio_config=audio_config) output_audio_config = dialogflow.OutputAudioConfig( audio_encoding=dialogflow.OutputAudioEncoding. OUTPUT_AUDIO_ENCODING_LINEAR_16) # The first request contains the configuration. yield dialogflow.StreamingDetectIntentRequest( session=session_path, query_input=query_input, single_utterance=True, output_audio_config=output_audio_config) while True: chunk = self._buff.get() if chunk is None: print("chunk none") return if not self._isIntentDetect: print("done intent") return yield dialogflow.StreamingDetectIntentRequest( input_audio=chunk) requests = request_generator(audio_config) responses = session_client.streaming_detect_intent(requests) print('=' * 20) self._isEndConversation = True for response in responses: self.handleDialogflowResponse(response) self.stopDetectIntent() if self._isEndConversation: print('end conversation') print("send mqtt end detectinetnt event") self._mqtt.publish(self._endDetectIntentEventTopic, "1") self.runDetectHotword() else: self.playSound(self._wake_sound_file) print('conversation continue') self.runDetectIntent(session_id) except KeyboardInterrupt: print('stopping ...') finally: if self._audio_stream is not None: self._audio_stream.stop_stream() self._audio_stream.close() # delete Porcupine last to avoid segfault in callback. if self._porcupine is not None: self._porcupine.delete()
import discord.ext.commands as commands from google.oauth2 import service_account from google.cloud import dialogflow import os import uuid import asyncio import json import config DIALOGFLOW_AUTH = json.loads(os.environ.get("DIALOGFLOW_AUTH")) session_client = dialogflow.SessionsClient( credentials=service_account.Credentials.from_service_account_info(DIALOGFLOW_AUTH)) DIALOGFLOW_PROJECT_ID = DIALOGFLOW_AUTH['project_id'] SESSION_LIFETIME = 10 * 60 # 10 minutes to avoid repeated false positives class DialogFlow(commands.Cog): def __init__(self, bot): self.bot = bot self.session_ids = {} async def process_message(self, message): if message.content.startswith(self.bot.command_prefix): return if not config.Misc.fetch("dialogflow_state"): return if not config.Misc.fetch("dialogflow_debug_state"): if not config.DialogflowChannels.fetch(message.channel.id): return roles = message.author.roles[1:] exceptionroles = config.DialogflowExceptionRoles.fetch_all()
from google.cloud import dialogflow from google.oauth2 import service_account from constants import GOOGLE_SERVICE_ACCOUNT_FILE_PATH, DEFAULT_DIALOGFLOW_LANGUAGE_CODE, DIALOGFLOW_PROJECT_ID credentials = service_account.Credentials.from_service_account_file( GOOGLE_SERVICE_ACCOUNT_FILE_PATH) session_client = dialogflow.SessionsClient(credentials=credentials) # Attempts to match an intent with given free text input def detect_intent_via_text(session_id, text): text_input = dialogflow.TextInput( text=text, language_code=DEFAULT_DIALOGFLOW_LANGUAGE_CODE) return __detect_intent(session_id, dialogflow.QueryInput(text=text_input)) # Attempts to match an intent with given event input def detect_intent_via_event(session_id, event): event_input = dialogflow.EventInput( name=event, language_code=DEFAULT_DIALOGFLOW_LANGUAGE_CODE) return __detect_intent(session_id, dialogflow.QueryInput(event=event_input)) def __detect_intent(session_id, query_input): session = session_client.session_path(DIALOGFLOW_PROJECT_ID, session_id) response = session_client.detect_intent(request={
def __init__(self, project_id, session_id=123456789): self.__project_id = project_id self.__session_id = session_id self.__session_client = dialogflow.SessionsClient() self.__session = self.__session_client.session_path(project_id, session_id)