def reset_location(self, dummy=None): if not self.settings["tracking"]: self.emitter.emit( Message("configuration.patch", {"config": self.home_location})) conf = LocalConf(USER_CONFIG) conf['location'] = self.home_location conf.store()
def handle_change_lang_intent(self, message): lang = message.data.get("lang", self.lang) if self.validate_language(lang): if lang[:2] in self.lang_map and lang not in self.lang_map: lang = lang[:2] elif lang not in self.lang_map: for l in self.lang_map: if self.lang_map[l].lower() == lang.lower(): lang = l break lang_name = lang if lang_name in self.lang_map: lang_name = self.lang_map[lang_name] self.speak_dialog("new_lang", {"language": lang_name}) conf = LocalConf(USER_CONFIG) conf['lang'] = lang stt = self.config_core["stt"] stt["module"] = "google" if "google" not in stt: stt["google"] = {} if "credential" not in stt["google"]: stt["google"] = {"credential": {}} if "token" not in stt["google"]["credential"]: stt["google"][ "credential"] = "AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw" conf["stt"] = "google" tts = self.config_core["tts"] tts["module"] = "google" conf["tts"] = tts conf.store() self.emitter.emit(message.reply("mycroft.reboot", {})) else: self.speak_dialog("invalid_language", {"language": self.lang})
def from_ip_db(self, ip=None, update=True): self.log.info("Retrieving location data from ip database") ip = ip or self.get_ip() g = pygeoip.GeoIP(self.settings["geo_ip_db"]) data = g.record_by_addr(ip) or {} city = data.get("city", "") region_code = data.get("region_code", "") country_code = data.get("country_code", "") country_name = data.get("country_name", "") region = city longitude = data.get("longitude", "") latitude = data.get("latitude", "") timezone = data.get("time_zone", "") city_code = data.get("postal_code", "") data = self.build_location_dict(city, region_code, country_code, country_name, region, longitude, latitude, timezone, city_code) config = {"location": data, "address": city + ", " + country_name} if update: self.emitter.emit( Message("configuration.patch", {"config": config})) self.config_core["location"] = data conf = LocalConf(USER_CONFIG) conf['location'] = data conf.store() return config
def is_backend_disabled(): configs = [ LocalConf(DEFAULT_CONFIG), LocalConf(SYSTEM_CONFIG), LocalConf(USER_CONFIG) ] config = Configuration.load_config_stack(configs) return config["server"].get("disabled") or False
def __init__(self, path): self.path = path config = Configuration.get([ LocalConf(DEFAULT_CONFIG), LocalConf(SYSTEM_CONFIG), LocalConf(USER_CONFIG) ], cache=False) config_server = config.get("server") self.url = config_server.get("url") self.version = config_server.get("version") self.identity = IdentityManager.get()
def bind_engine(self, engine, priority=4): conf = LocalConf(USER_CONFIG) priority_skills = Configuration.get().get("skills", {}).get( "priority_skills", []) priority_skills.append(self._dir.split("/")[-1]) conf.store() self.priority = priority self.engine = engine self.config = engine.config self.register_messages(engine.name) self.register_fallback(self.handle_fallback, self.priority) self.finished_training_event = Event() self.finished_initial_train = False self.train_delay = self.config.get('train_delay', 4) self.train_time = get_time() + self.train_delay
def handle_rate_speech(self, message): from mycroft.configuration.config import (LocalConf, Configuration, USER_CONFIG) user_config = LocalConf(USER_CONFIG) LOG.info(str(user_config)) user_level = message.data.get('ratelevel') LOG.info(user_level) rate_var = self.get_rate_var(user_level) if (rate_var == "error"): self.speak_dialog("invalidInput", {'userLevel': user_level}) else: new_config = { "tts": { "mimic": { "duration_stretch": str(rate_var) } } } user_config.merge(new_config) user_config.store() LOG.info(str(LocalConf(USER_CONFIG))) self.bus.emit(Message('configuration.updated')) self.speak_dialog("rate.speech", {'rateLevel': user_level})
def from_wifi(self, update=True): if not self.settings["google_geolocate_key"]: self.speak("you need a google geolocation services api key " "in order to use wifi geolocation") self.log.error("you need a google geolocation services api key " "in order to use wifi geolocation") return {} lat, lon, accuracy = wifi_geolocate( api=self.settings["google_geolocate_key"], sudo=self.settings["wifi_sudo"]) LOG.info("\nlatitude: " + str(lat) + "\nlongitude: " + str(lon) + "\naccuracy (meters) : " + str(accuracy)) data = reverse_geolocate(lat, lon) data["accuracy"] = accuracy LOG.info("reverse geocoding data: " + str(data)) location = self.location.copy() location["address"] = data["address"] if data.get("zip"): location["city"]["code"] = data["zip"] else: location["city"]["code"] = data["city"] location["city"]["name"] = data["city"] location["city"]["state"]["name"] = data["state"] # TODO state code location["city"]["state"]["code"] = data["state"] location["city"]["state"]["country"]["name"] = data["country"] # TODO country code location["city"]["state"]["country"]["code"] = data["country"] location["coordinate"]["latitude"] = data["latitude"] location["coordinate"]["longitude"] = data["longitude"] timezone = get_timezone(data["latitude"], data["longitude"]) # TODO timezone name location["timezone"]["name"] = timezone location["timezone"]["code"] = timezone config = {"location": location} if update: self.emitter.emit( Message("configuration.patch", {"config": config})) self.config_core["location"] = location conf = LocalConf(USER_CONFIG) conf['location'] = location conf.store() return config
def handle_disable_precise_dev(self, message): from mycroft.configuration.config import (LocalConf, USER_CONFIG) for item in glob(expanduser('~/.mycroft/precise/precise-engine*')): self.log.info('Removing: {}...'.format(item)) if isdir(item): rmtree(item) else: os.remove(item) local_conf = LocalConf(USER_CONFIG) pconfig = local_conf.get('precise', {}) if pconfig.get('dist_url') == self.PRECISE_DEV_DIST_URL: del pconfig['dist_url'] if pconfig.get('model_url') == self.PRECISE_DEV_MODEL_URL: del pconfig['model_url'] local_conf.store() self.bus.emit(Message('configuration.updated')) self.speak_dialog('precise.devmode.disabled')
def handle_set_listener(self, message): from mycroft.configuration.config import (LocalConf, USER_CONFIG, Configuration) module = message.data['ListenerType'].replace(' ', '') module = module.replace('default', 'pocketsphinx') name = module.replace('pocketsphinx', 'pocket sphinx') if self.get_listener() == module: self.speak_dialog('listener.same', data={'listener': name}) return wake_word = Configuration.get()['listener']['wake_word'] new_config = {'hotwords': {wake_word: {'module': module}}} user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.bus.emit(Message('configuration.updated')) if module == 'precise': engine_folder = expanduser('~/.mycroft/precise/precise-engine') if not isdir(engine_folder): self.speak_dialog('download.started') return self.speak_dialog('set.listener', data={'listener': name})
def set_single_thread(self, update): new_config = {'padatious': {'single_thread': update}} user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.log.info('Setting padatious single_thread = ' + str(update)) self.bus.emit(Message('configuration.updated'))
def config(self, name, message): from mycroft.configuration.config import ( LocalConf, USER_CONFIG, Configuration ) module = "precise".replace(' ', '') module = module.replace('default', 'pocketsphinx') precise_file = self.select_precise_file(name, message) if precise_file == None: self.log.info("precise file "+name+" not found") return else: self.log.info("set precise file: "+precise_file) wake_word = name self.log.info("set precise WakeWord:"+name) new_config = {"listener": {"wake_word": name, "record_wake_words": "true"}, "hotwords": {wake_word: {"module": module, "threshold": "1e-90", "lang": self.lang,"local_model_file": precise_file}} } user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.bus.emit(Message('configuration.updated')) if module == 'precise': engine_folder = expanduser('~/.mycroft/precise/precise-engine') if not os.path.isdir(engine_folder): self.speak_dialog('download.started') return self.speak_dialog('end.calculating', data={'name': name})
def _disable_listen_beep(self): user_config = LocalConf(USER_CONFIG) if 'user_beep_setting' not in self.settings: # Save any current local config setting self.settings['user_beep_setting'] = ( user_config.get("confirm_listening", None)) # Disable in local config user_config.merge({"confirm_listening": False}) user_config.store() # Notify all processes to update their loaded configs self.bus.emit(Message('configuration.updated'))
def _sync_wake_beep_setting(self): """ Update "use beep" global config from skill settings. """ config = Configuration.get() use_beep = self.settings.get("use_listening_beep", False) if not config["confirm_listening"] == use_beep: # Update local (user) configuration setting new_config = {"confirm_listening": use_beep} user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.bus.emit(Message("configuration.updated"))
def save_upgrade_permission(self, ver): # Build version as float, e.g. [18,8,999] as 18.8 float_ver = ver[0] + ver[1] / 10 # assumes minor is <= 9 new_conf_values = {"max_allowed_core_version": float_ver} # Save under the user (e.g. ~/.mycroft/mycroft.conf) user_config = LocalConf(USER_CONFIG) user_config.merge(new_conf_values) user_config.store() # Notify all processes to update their loaded configs self.bus.emit(Message('configuration.updated'))
def _sync_wake_beep_setting(self): from mycroft.configuration.config import (LocalConf, USER_CONFIG, Configuration) config = Configuration.get() use_beep = self.settings.get("use_listening_beep") == "true" if not config['confirm_listening'] == use_beep: # Update local (user) configuration setting new_config = {'confirm_listening': use_beep} user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.emitter.emit(Message('configuration.updated'))
def _sync_wake_beep_setting(self): """ Update "use beep" global config from skill settings. """ from mycroft.configuration.config import (LocalConf, USER_CONFIG, Configuration) config = Configuration.get() use_beep = self.settings.get('use_listening_beep') is True if not config['confirm_listening'] == use_beep: # Update local (user) configuration setting new_config = {'confirm_listening': use_beep} user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.bus.emit(Message('configuration.updated'))
def _restore_listen_beep(self): if 'user_beep_setting' in self.settings: # Wipe from local config new_conf_values = {"confirm_listening": False} user_config = LocalConf(USER_CONFIG) if (self.settings["user_beep_setting"] is None and "confirm_listening" in user_config): del user_config["confirm_listening"] else: user_config.merge({"confirm_listening": self.settings["user_beep_setting"]}) user_config.store() # Notify all processes to update their loaded configs self.bus.emit(Message('configuration.updated')) del self.settings["user_beep_setting"]
def handle_set_listener(self, message): try: from mycroft.configuration.config import (LocalConf, USER_CONFIG, Configuration) module = message.data['ListenerType'].replace(' ', '') module = module.replace('default', 'pocketsphinx') name = module.replace('pocketsphinx', 'pocket sphinx') config = Configuration.get() if config['hotwords']['hey mycroft']['module'] == module: self.speak_dialog('listener.same', data={'listener': name}) return new_config = { 'precise': { 'dist_url': 'http://bootstrap.mycroft.ai/' 'artifacts/static/daily/' }, 'hotwords': { 'hey mycroft': { 'module': module } } } user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.emitter.emit(Message('configuration.updated')) if module == 'precise': exe_path = expanduser('~/.mycroft/precise/precise-stream') if isfile(exe_path): self.enclosure.mouth_text('Checking version...') version = check_output([exe_path, '-v'], stderr=STDOUT) if version.strip() == '0.1.0': os.remove(exe_path) self.enclosure.mouth_reset() else: self.speak_dialog('download.started') return self.speak_dialog('set.listener', data={'listener': name}) except (NameError, SyntaxError, ImportError): self.speak_dialog('must.update')
def handle_level_decrease(self, message): from mycroft.configuration.config import (LocalConf, USER_CONFIG) new_rate = self.curr_level + 0.10 if new_rate <= 2.0 and new_rate > 0.1: new_config = { "tts": { "mimic": { "duration_stretch": str(new_rate) } } } user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.curr_level = new_rate self.bus.emit(Message('configuration.updated')) self.speak_dialog('updatedLevel', {'directionChange': 'decreased'}) else: self.speak_dialog("invalidLevel")
def handle_use_precise_dev(self, message): from mycroft.configuration.config import (LocalConf, USER_CONFIG, Configuration) wake_word = Configuration.get()['listener']['wake_word'] new_config = { 'precise': { "dist_url": self.PRECISE_DEV_DIST_URL, "model_url": self.PRECISE_DEV_MODEL_URL }, 'hotwords': { wake_word: { 'module': 'precise', 'sensitivity': 0.5 } } } user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.bus.emit(Message('configuration.updated')) self.speak_dialog('precise.devmode.enabled')
def _update_config(self, config): from mycroft.configuration.config import (LocalConf, USER_CONFIG) user_config = LocalConf(USER_CONFIG) user_config.merge(config) user_config.store() self.bus.emit(Message('configuration.updated'))
from mycroft.configuration.config import LocalConf, DEFAULT_CONFIG from copy import deepcopy __config = LocalConf(DEFAULT_CONFIG) # Base config to use when mocking def base_config(): return deepcopy(__config) class Anything: """Class matching any object. Useful for assert_called_with arguments. """ def __eq__(self, other): return True
import mock from adapt.intent import IntentBuilder from os.path import join, dirname, abspath from re import error from datetime import datetime from mycroft.configuration import Configuration from mycroft.messagebus.message import Message from mycroft.skills.skill_data import load_regex_from_file, load_regex, \ load_vocab_from_file, load_vocabulary from mycroft.skills.core import MycroftSkill, load_skill, \ create_skill_descriptor, open_intent_envelope from mycroft.configuration.config import LocalConf, DEFAULT_CONFIG BASE_CONF = LocalConf(DEFAULT_CONFIG) class MockEmitter(object): def __init__(self): self.reset() def emit(self, message): self.types.append(message.type) self.results.append(message.data) def get_types(self): return self.types def get_results(self): return self.results
def save_wakewords(self): from mycroft.configuration.config import (LocalConf, USER_CONFIG, Configuration) record = Configuration.get()['listener']['record_wake_words'] if self.settings["savewakewords"] is True: free_mb = psutil.disk_usage('/')[2] / 1024 / 1024 if free_mb <= self.settings["min_free_disk"]: self.log.info("no space: deactivate recording") new_config = {"listener": {"record_wake_words": "true"}} user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() if record == "false": new_config = {"listener": {"record_wake_words": "true"}} self.log.info("set wake word recording") user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.settings.update else: if record == "true": new_config = {"listener": {"record_wake_words": "false"}} self.log.info("unset wake word recording") user_config = LocalConf(USER_CONFIG) user_config.merge(new_config) user_config.store() self.settings.update
def update_skills_config(self, config=None): conf = LocalConf(USER_CONFIG) conf['skills'] = config or self.skills_config conf.store() self.send_message("skills.config.updated")
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from copy import deepcopy from unittest.mock import Mock from msm import MycroftSkillsManager from msm.skill_repo import SkillRepo from mycroft.configuration.config import LocalConf, DEFAULT_CONFIG __CONFIG = LocalConf(DEFAULT_CONFIG) def base_config(): """Base config used when mocking. Preload to skip hitting the disk each creation time but make a copy so modifications don't mutate it. Returns: (dict) Mycroft default configuration """ return deepcopy(__CONFIG) def mock_msm(temp_dir):
def from_remote_ip(self, update=True): self.log.info("Retrieving location data from ip address api") if connected(): response = requests.get("https://ipapi.co/json/").json() response = json.loads(response) city = response.body.get("city") region_code = response.body.get("region_code") country = response.body.get("country") country_name = response.body.get("country_name") region = response.body.get("region") lon = response.body.get("longitude") lat = response.body.get("latitude") timezone = response.body.get("timezone") if timezone is None: timezone_data = self.location.get( "timezone", self.home_location.get("timezone", {})) else: timezone_data = { "code": timezone, "name": timezone, "dstOffset": 3600000, "offset": -21600000 } region_data = { "code": region_code, "name": region, "country": { "code": country, "name": country_name } } city_data = { "code": city, "name": city, "state": region_data, "region": region_data } coordinate_data = {"latitude": float(lat), "longitude": float(lon)} location_data = { "city": city_data, "coordinate": coordinate_data, "timezone": timezone_data } config = { "location": location_data, "address": city + ", " + country_name } if update: self.emitter.emit( Message("configuration.patch", {"config": config})) self.config_core["location"] = location_data conf = LocalConf(USER_CONFIG) conf['location'] = location_data conf.store() return config else: self.log.warning("No internet connection, could not update " "location from ip address") return {}