def detect_language_from_text(self, text): """ Detects _language from text. :param str text: text to be analyzed :rtype ActionResult :return: ActionResult with _language name as payload """ assert(isinstance(text, str)) lang_code = self._detect_language(text).lang return ActionResult(self._convert_lang_code_to_language(lang_code), SUCCESS)
def recognize_from_microphone(self): """ Returns action result with recognized text from the speech. Input speech is read from microphone. Raises RequestError or UnknownValueError. :rtype: ActionResult :return: ActionResult with recognized text from the speech """ audio = self._get_audio_from_microphone() speech = self._recognition_method(audio, language=self._language) result = ActionResult(speech, SUCCESS) return result
def get_complete_page(self, query): """ Returns wiki page that satisfy input query (complete page content) :param query: searching term (str) :return: """ try: page = wikipedia.page(query) return ActionResult(page.content, SUCCESS) except Exception as e: #return ActionResult(e, DEFAULT_EXCEPTION) pass
def _commit(self, service, method): """ Executes service method with arguments from [service_command_methods] dict. If some error occurs, calls exception handler. If service is None, returns ActionResult with fatal status. :param str service: service name :param str method: method name :rtype: ActionResult :return: ActionResult with SUCCESS - result of execution as payload, FAIL - customized exception message as payload or FATAL - blank message result. """ logger.info("-------- begin commit --------") service_inst = self._service_pool.get(service, None) command_result = None if service_inst is not None: if hasattr(service_inst, method): executor = getattr(service_inst, method) try: result = executor( **self._service_command_methods[service][method]) logger.debug("Output = {}".format(result)) command_result = result # TODO:handle fatal exception except Exception as e: message = ExceptionHandler.get_exception_message( e, self._language) command_result = ActionResult(message, FAIL, self._language) finally: logger.info("-------- end commit --------") #self._clear_all_params(service, method) return command_result else: logger.error("Fatal, service cannot be found.") message = ExceptionHandler.get_exception_message( VoiceAssistantException, self._language) #self._clear_all_params(service, method) return ActionResult(message, FATAL)
def open_social_network_page(self, nickname=None, social_network_url=FACEBOOK_BASE_URL): """ Opens social network page :param str nickname: user nickname :param str social_network_url: base url of wanted social network (FB, IG, TW, IN) :rtype ActionResult :return: Empty ActionResult with SUCCESS status """ assert (isinstance(nickname, str) and isinstance(social_network_url, str)) logger.debug("Calling open_social_network_page with params: [nickname = {}, social_network_url = {}].". format(nickname, social_network_url)) url = social_network_url + nickname + "/" self._browser_open(url) return ActionResult("", SUCCESS)
def listen_and_execute(self): """ Listen speech and convert it to text (if possible). Based on stt result, execute wanted command or returns the error message (through speak). :rtype: None :return: void method """ try: text_result = self._recognizer.recognize_from_microphone() except Exception as e: message = ExceptionHandler.get_exception_message(e, self._language) text_result = ActionResult(message, FAIL) self._reset_speaking_language_() self._reset_recognizer_language() if text_result is None or text_result.get_result() is None or text_result.get_status() == FAIL: output = self._get_output_speech(text_result) else: logger.debug("Speech recognition result = {}".format(text_result)) try: output = self._execute(text_result.get_result()) except Exception as e: output = (ExceptionHandler.get_exception_message(e, self._language), '') self._speak_out(message_prefix=output[0], output_message=output[1])
def brief_search(self, query, sentences=3): """ Get summary section of page that satisfy query. :param query: searching term (str) :param sentences: number of sentences that wikipedia summary should have (int) :return: ActionResult with the result from wikipedia page (or appropriate error message) """ logger.debug( "Calling wikipedia brief_search with [query = {}]".format(query)) if sentences > 10: raise ValueError( "Number of summary sentences can not be greater than 10.") summary = wikipedia.summary(query, sentences=sentences) logger.debug("Wikipedia summary = {}".format(summary)) return ActionResult(summary, SUCCESS)
def open_found_url_in_browser(self, query, tpe=""): """ Opens the found url in browser. :param str query: google search query string. Must not be URL-encoded :param str tpe: type_ of search, default=`all` :rtype ActionResult :return: Empty ActionResult with SUCCESS status """ assert (isinstance(query, str) and isinstance(tpe, str)) logger.debug("Calling open_found_url_in_browser with params: [query = {}, tpe = {}].".format(query, tpe)) url = self._get_first_search_result(query, tpe=tpe) #url = google_result.get_result() if url is not None: logger.debug("Found url = {}.".format(url)) self._browser_open(url=url) return ActionResult("", SUCCESS) else: raise GoogleSearchException
def translate_text(self, text=None, src_language="en", dest_language="en"): """ Translates text from src_language to dest_language.If text is `Mary had a little lamb`, src_language `en`, and dest_language is `sr`, resulting text has value: `Мери је имала мало јагње` :param str text: text for translation :param str src_language: _language code of text's _language :param str dest_language: target translation _language :rtype ActionResult :return: ActionResult with translated text as payload """ assert(isinstance(text, str) and isinstance(src_language, str) and isinstance(dest_language, str)) logger.debug("Calling translate_text with params: [text = {}, src_language = {}, dest_language = {}]". format(text, src_language, dest_language)) dest_language = self._get_appropriate_lang_code(dest_language) logger.debug("Language code = {}.".format(dest_language)) translated_text = self._translate(text, src_lang=src_language, dest_lang=dest_language) logger.debug("Raw translation object = {}".format(translated_text)) logger.debug("Translated text = {}".format(translated_text.text)) return ActionResult(translated_text.text, SUCCESS, language=dest_language)
def _execute_controller_method(self, method, command): """ Handle execution of command's method that is defined in controller. :param str method: method name :param dict command: command dictionary :rtype: ActionResult :return: command result """ executor = getattr(self, method) try: if command["has_args"]: command_result = eval('executor(' + command["arg_name"] + "=" + "'" + str(command["arg"]) + "')") else: command_result = executor() except Exception as e: language = self._language if self._language is not None else "en" message = ExceptionHandler.get_exception_message(e, language) command_result = ActionResult(message, FAIL, language) return command_result
def get_forecast_result(self, location, param="all", unit="celsius"): """ Returns weather forecast for location. :param location: location (str) - location which forecast we seek :param param: param (str); default = all - which weather parameter we want :param unit: unit(str); default = celsius - unit for temperature measurement, expected values are celsius, fahrenheit and kelvin :return: weather forecast in string format weather_param:value covered params:clouds, pressure, wind speed (mph), humidity, minimum temperature, maximum temperature,temperature detailed status """ logger.debug( "Calling get_forecast_result with params: [location = {}, param = {}, unit = {}]".format(str(location), \ str(param), str(unit))) weather_data = self._get_weather_at_location(location) logger.debug("Weather data results were fetched....") logger.debug("Raw forecast results = {}".format(str(weather_data))) forecast_output = self._get_forecast_in_readable_form( weather_data, param, **{"unit": unit}) logger.debug("Forecast in readable form:\n{}".format(forecast_output)) return ActionResult(forecast_output, SUCCESS)
def get_movie_details(self, title): """ Get movie details (full form) for movie with title [title]. :param title: Movie title (str) :return: Movie details (str) wrapped in ActionResult. """ assert (isinstance(title, str)) logger.debug("Get movie details. Params: [title = {}].".format(title)) movie = self._get_first_movie(title) if movie is not None: movie_id = self._get_movie_id(movie) logger.debug("Movie id = {}".format(movie_id)) movie_details = self._get_movie_by_id(movie_id) if movie_details != {}: movie_info = self._get_detailed_movie_info(movie_details) movie_info_rdbl_form = self._movie_info_to_str(movie_info) logger.debug("Complete movie info:\n{}".format(movie_info)) else: movie_info_rdbl_form = "Movie that you asked for cannot be found." logger.debug("Movie cannot be found....") return ActionResult(movie_info_rdbl_form, SUCCESS, language="en") else: return None
def get_top_movies(self, num=1): """ Returns brief movie info details about best movies by imdb. Number of movies is determined by [num] arg. This argument cannot be greater than 250. :param num: Number of top movies we seek. (int); in range [1,250] :return: movies info string wrapped in ActionResult; default speaking _language is english """ assert (isinstance(num, int)), "Value must be integer by type_." assert (num in range(1, 251)), "Value must be in range 1 to 250" # TODO:handle num when spoken in Serbian, it uses words, in english it uses numbers num = int(num) logger.debug( "Seeking for best movies by imdb. Params: [num = {}].".format(num)) top_movies = self._imdb.get_top250_movies()[:num] complete_info = "" for movie in top_movies: movie_id = self._get_movie_id(movie) logger.debug("Movie id = {}".format(movie_id)) movie_details = self._get_movie_by_id(movie_id) movie_info = self._get_brief_movie_info(movie_details) complete_info += self._movie_info_to_str(movie_info) + "\n" logger.debug("Complete movies info:\n{}".format(complete_info)) #NOTE:action result _language is set to english because imdb API results are in english return ActionResult(complete_info, SUCCESS, language="en")