refactor/mutable_config (#13)

makes self.config_core a property, ensures we always get the latest mycroft.conf

Configuration is a singleton, keeps an internal cache and reacts to bus events. This does not repeatedly read from disk

Author: JarbasAl

mycroft/api/__init__.py

@@ -45,15 +45,22 @@ class Api:
 
     def __init__(self, path):
         self.path = path
+        self.identity = IdentityManager.get()
+        self.disabled = is_backend_disabled()
 
+    @property
+    def url(self):
         # Load the config, skipping the remote config since we are
         # getting the info needed to get to it!
-        config = Configuration.get(cache=False, remote=False)
-        config_server = config.get("server")
-        self.url = config_server.get("url")
-        self.version = config_server.get("version")
-        self.identity = IdentityManager.get()
-        self.disabled = is_backend_disabled()
+        config = Configuration.get(cache=False, remote=False).get("server", {})
+        return config.get("url")
+
+    @property
+    def version(self):
+        # Load the config, skipping the remote config since we are
+        # getting the info needed to get to it!
+        config = Configuration.get(cache=False, remote=False).get("server", {})
+        return config.get("version")
 
     def request(self, params):
         self.check_token()

mycroft/audio/audioservice.py

@@ -201,7 +201,6 @@ def __init__(self, bus):
                 bus: Mycroft messagebus
         """
         self.bus = bus
-        self.config = Configuration.get().get("Audio")
         self.service_lock = Lock()
 
         self.default = None
@@ -213,6 +212,10 @@ def __init__(self, bus):
         self._loaded = MonotonicEvent()
         self.load_services()
 
+    @property
+    def config(self):
+        return Configuration.get().get("Audio")
+
     def load_services(self):
         """Method for loading services.
 

mycroft/client/enclosure/base.py

@@ -30,15 +30,21 @@
 
 class Enclosure:
     def __init__(self):
-        # Load full config
-        config = Configuration.get()
-        self.lang = config['lang']
-        self.config = config.get("enclosure")
-        self.global_config = config
-
         # Create Message Bus Client
         self.bus = MessageBusClient()
 
+    @property
+    def lang(self):
+        return self.global_config.get("lang", "en-us")
+
+    @property
+    def config(self):
+        return self.global_config.get("enclosure") or {}
+
+    @property
+    def global_config(self):
+        return Configuration.get()
+
     def run(self):
         """Start the Enclosure after it has been constructed."""
         # Allow exceptions to be raised to the Enclosure Service

mycroft/client/speech/listener.py

@@ -258,15 +258,22 @@ def __init__(self, bus, watchdog=None, stt=None):
     def bind(self, stt):
         self.stt = stt
 
+    @property
+    def config_core(self):
+        return Configuration.get()
+
+    @property
+    def config(self):
+        self._config_hash = recognizer_conf_hash(self.config_core)
+        return self.config_core.get('listener')
+
+    @property
+    def lang(self):
+        return self.config_core.get('lang', "en-us")
+
     def _load_config(self):
         """Load configuration parameters from configuration."""
-        config = Configuration.get()
-        self.config_core = config
-        self._config_hash = recognizer_conf_hash(config)
-        self.lang = config.get('lang')
-        self.config = config.get('listener')
         rate = self.config.get('sample_rate')
-
         device_index = self.config.get('device_index')
         device_name = self.config.get('device_name')
         if not device_index and device_name:

mycroft/client/speech/mic.py

@@ -332,30 +332,9 @@ class ResponsiveRecognizer(speech_recognition.Recognizer):
     def __init__(self, loop, watchdog=None):
         self.loop = loop
         self._watchdog = watchdog or (lambda: None)  # Default to dummy func
-        self.config = Configuration.get()
-        listener_config = self.config.get('listener')
-        self.instant_listen = listener_config.get("instant_listen", False)
-        self.upload_url = listener_config['wake_word_upload']['url']
-        self.upload_disabled = listener_config['wake_word_upload']['disable']
-
-        self.overflow_exc = listener_config.get('overflow_exception', False)
 
         super().__init__()
         self.audio = pyaudio.PyAudio()
-        self.multiplier = listener_config.get('multiplier')
-        self.energy_ratio = listener_config.get('energy_ratio')
-
-        # Check the config for the flag to save wake words, utterances
-        # and for a path under which to save them
-        self.save_utterances = listener_config.get('save_utterances', False)
-        self.save_wake_words = listener_config.get('record_wake_words', False)
-        self.save_path = listener_config.get('save_path', gettempdir())
-        self.saved_wake_words_dir = join(self.save_path, 'mycroft_wake_words')
-        if self.save_wake_words:
-            os.makedirs(self.saved_wake_words_dir, exist_ok=True)
-        self.saved_utterances_dir = join(self.save_path, 'mycroft_utterances')
-        if self.save_utterances:
-            os.makedirs(self.saved_utterances_dir, exist_ok=True)
 
         # Signal statuses
         self._stop_signaled = False
@@ -366,22 +345,103 @@ def __init__(self, loop, watchdog=None):
         # identifier used when uploading wakewords to selene
         self._account_id = None
 
+    @property
+    def config(self):
+        return Configuration.get()
+
+    @property
+    def instant_listen(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get("instant_listen", False)
+
+    @property
+    def overflow_exc(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('overflow_exception', False)
+
+    @property
+    def upload_url(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config['wake_word_upload']['url']
+
+    @property
+    def upload_disabled(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config['wake_word_upload']['disable']
+
+    @property
+    def multiplier(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('multiplier')
+
+    @property
+    def energy_ratio(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('energy_ratio')
+
+    @property
+    def save_utterances(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('save_utterances', False)
+
+    @property
+    def save_wake_words(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('record_wake_words', False)
+
+    @property
+    def save_path(self):
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('save_path', gettempdir())
+
+    @property
+    def saved_wake_words_dir(self):
+        path = join(self.save_path, 'mycroft_wake_words')
+        if self.save_wake_words:
+            os.makedirs(path, exist_ok=True)
+        return path
+
+    @property
+    def saved_utterances_dir(self):
+        path = join(self.save_path, 'mycroft_utterances')
+        if self.save_wake_words:
+            os.makedirs(path, exist_ok=True)
+        return path
+
+    @property
+    def recording_timeout(self):
         # The maximum seconds a phrase can be recorded,
         # provided there is noise the entire time
-        self.recording_timeout = listener_config.get('recording_timeout', 10.0)
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('recording_timeout', 10.0)
+
+    @property
+    def recording_timeout_with_silence(self):
         # The maximum time it will continue to record silence
         # when not enough noise has been detected
-        self.recording_timeout_with_silence = listener_config.get('recording_timeout_with_silence', 3.0)
-        # mic meter settings, will write mic level to ipc, used by debug_cli
-        # NOTE: this writes a lot to disk, it can be problematic in a sd card if you don't use a tmpfs for ipc
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get('recording_timeout_with_silence', 3.0)
+
+    @property
+    def mic_level_file(self):
         ipc = get_ipc_directory()
         os.makedirs(ipc, exist_ok=True)
-        self.mic_level_file = os.path.join(ipc, "mic_level")
-        self.mic_meter_ipc_enabled = listener_config.get("mic_meter_ipc", True)
+        return os.path.join(ipc, "mic_level")
 
+    @property
+    def mic_meter_ipc_enabled(self):
+        # mic meter settings, will write mic level to ipc, used by debug_cli
+        # NOTE: this writes a lot to disk
+        # can be problematic in a sd card if you don't use a tmpfs for ipc
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get("mic_meter_ipc", True)
+
+    @property
+    def test_ww_sec(self):
         # The maximum audio in seconds to keep for transcribing a phrase
         # The wake word must fit in this time
-        self.test_ww_sec = listener_config.get("test_ww_sec", 3)
+        listener_config = self.config.get('listener') or {}
+        return listener_config.get("test_ww_sec", 3)
 
     @property
     def account_id(self):

mycroft/client/speech/service.py

@@ -51,7 +51,6 @@ def __init__(self, on_ready=on_ready, on_error=on_error,
         self.status = ProcessStatus('speech', callback_map=callbacks)
         self.status.set_started()
 
-        self.config = Configuration.get()
         self.bus = start_message_bus_client("VOICE")
         self.connect_bus_events()
         self.status.bind(self.bus)
@@ -60,6 +59,10 @@ def __init__(self, on_ready=on_ready, on_error=on_error,
         self.loop = RecognizerLoop(self.bus, watchdog)
         self.connect_loop_events()
 
+    @property
+    def config(self):
+        return Configuration.get()
+
     # loop events
     def handle_record_begin(self):
         """Forward internal bus message to external bus."""
@@ -188,7 +191,7 @@ def handle_stop(self, event):
     def handle_open(self):
         # TODO: Move this into the Enclosure (not speech client)
         # Reset the UI to indicate ready for speech processing
-        EnclosureAPI(bus).reset()
+        EnclosureAPI(self.bus).reset()
 
     def connect_loop_events(self):
         self.loop.on('recognizer_loop:utterance', self.handle_utterance)
@@ -229,7 +232,3 @@ def run(self):
         except Exception as e:
             self.status.set_error(e)
         self.status.set_stopping()
-
-
-if __name__ == "__main__":
-    main()

mycroft/gui/service.py

@@ -25,7 +25,6 @@
 
 class GUIService:
     def __init__(self):
-        self.global_config = Configuration.get()
         # Create Message Bus Client
         self.bus = MessageBusClient()
 
@@ -64,6 +63,10 @@ def __init__(self):
         self.bus.on("gui.event.send", self.on_gui_send_event)
         self.bus.on("gui.status.request", self.handle_gui_status_request)
 
+    @property
+    def global_config(self):
+        return Configuration.get()
+
     def create_gui_socket(self):
         import tornado.options
         LOG.info('Starting message bus for GUI...')

mycroft/skills/intent_services/adapt_service.py

@@ -175,21 +175,24 @@ class AdaptService:
     def __init__(self, config):
         self.config = config
 
-        self.lang = Configuration.get().get("lang", "en-us")
         langs = Configuration.get().get('secondary_langs') or []
         if self.lang not in langs:
             langs.append(self.lang)
 
         self.engines = {lang: IntentDeterminationEngine()
                         for lang in langs}
-        # Context related intializations
+        # Context related initializations
         self.context_keywords = self.config.get('keywords', [])
         self.context_max_frames = self.config.get('max_frames', 3)
         self.context_timeout = self.config.get('timeout', 2)
         self.context_greedy = self.config.get('greedy', False)
         self.context_manager = ContextManager(self.context_timeout)
         self.lock = Lock()
 
+    @property
+    def lang(self):
+        return Configuration.get().get("lang", "en-us")
+
     def update_context(self, intent):
         """Updates context with keyword from the intent.
 

mycroft/skills/intent_services/padatious_service.py

@@ -116,7 +116,6 @@ def __init__(self, bus, config):
         intent_cache = expanduser(self.padatious_config['intent_cache'])
         self._padaos = self.padatious_config.get("padaos_only", False)
 
-        self.lang = Configuration.get().get("lang", "en-us")
         langs = Configuration.get().get('secondary_langs') or []
         if self.lang not in langs:
             langs.append(self.lang)
@@ -157,6 +156,10 @@ def __init__(self, bus, config):
         self.registered_intents = []
         self.registered_entities = []
 
+    @property
+    def lang(self):
+        return Configuration.get().get("lang", "en-us")
+
     def train(self, message=None):
         """Perform padatious training.
 

mycroft/skills/mycroft_skill/mycroft_skill.py

@@ -139,9 +139,6 @@ def __init__(self, name=None, bus=None, use_settings=True, skill_id=""):
         self._bus = None
         self._enclosure = EnclosureAPI(bus)
 
-        #: Mycroft global configuration. (dict)
-        self.config_core = Configuration.get()
-
         self.settings = {}
         self._initial_settings = {}
         self.settings_write_path = None
@@ -183,6 +180,13 @@ def __init__(self, name=None, bus=None, use_settings=True, skill_id=""):
         if bus and skill_id:
             self._startup(bus, skill_id)
 
+    @property
+    def config_core(self):
+        """ reads mycroft.conf
+        contains and internal cache and integrates with the bus
+        """
+        return Configuration.get()
+
     @property
     def is_fully_initialized(self):
         return self._init_event.is_set()
@@ -366,7 +370,7 @@ def _core_lang(self):
         NOTE: this should be public, but since if a skill uses this it wont
         work in regular mycroft-core it was made private! Equivalent PRs in
         mycroft-core have been rejected/abandoned"""
-        return Configuration.get().get("lang", "en-us").lower()
+        return self.config_core.get("lang", "en-us").lower()
 
     @property
     def _secondary_langs(self):