Implement #128: runtime-editable config for default parameters and module settings

.gitignore

@@ -107,3 +107,4 @@ venv.bak/
 .vscode/
 vscode/
 *.code-workspace
+.vscode-*

.pylintrc

@@ -0,0 +1,3 @@
+[MESSAGES CONTROL]
+
+disable=C0103,C0114,C0115,C0116,W0613

lingua_franca/__init__.py

@@ -1,6 +1,15 @@
-from .internal import get_default_lang, set_default_lang, get_default_loc, \
-    get_active_langs, _set_active_langs, get_primary_lang_code, \
-    get_full_lang_code, resolve_resource_file, load_language, \
-    load_languages, unload_language, unload_languages, get_supported_langs
+### DO NOT CHANGE THIS IMPORT ORDER ###
+from .internal import get_active_langs, get_supported_locs, \
+    get_full_lang_code, get_supported_langs, get_default_loc, \
+    get_primary_lang_code
 
-from lingua_franca import config
+from .configuration import Config
+
+### END OF IMPORT ORDER ###
+
+from .internal import get_default_lang, set_default_lang, \
+    _set_active_langs, resolve_resource_file, \
+    load_language, load_languages, unload_language, unload_languages
+
+
+config = Config()

lingua_franca/bracket_expansion.py

@@ -172,4 +172,4 @@ def _expand_tree(self, tree):
 
     def expand_parentheses(self):
         tree = self._parse()
-        return self._expand_tree(tree)
+        return self._expand_tree(tree)

lingua_franca/configuration.py

@@ -0,0 +1,122 @@
+import json
+
+from lingua_franca import get_active_langs, get_supported_locs, \
+    get_supported_langs, get_primary_lang_code, get_full_lang_code, \
+    get_default_loc
+from lingua_franca.internal import resolve_resource_file
+
+default_global_values = \
+    {
+        'load_langs_on_demand': False
+    }
+
+
+class LangConfig(dict):
+    def __init__(self, lang_code):
+        super().__init__()
+        if lang_code not in get_supported_locs():
+            # DO NOT catch UnsupportedLanguageError!
+            # If this fails, we want to crash. This can *only* result from
+            # someone trying to override sanity checks upstairs. There are no
+            # circumstances under which this should fail and allow the program
+            # to continue.
+            lang_code = get_full_lang_code(lang_code)
+
+        resource_file = resolve_resource_file(f'text/{lang_code}/config.json')
+        try:
+            with open(resource_file, 'r', encoding='utf-8') as i_file:
+                default_values = json.load(i_file)
+            for k in default_values:
+                self[k] = default_values[k]
+        except (FileNotFoundError, TypeError):
+            pass
+
+
+class Config(dict):
+    def __init__(self):
+        super().__init__()
+        self['global'] = dict(default_global_values)
+        for lang in get_active_langs():
+            self.load_lang(lang)
+
+    def load_lang(self, lang):
+        if all((lang not in get_supported_locs(),
+                lang in get_supported_langs())):
+            if lang not in self.keys():
+                self[lang] = {}
+                self[lang]['universal'] = LangConfig(lang)
+
+            full_loc = get_full_lang_code(lang)
+        else:
+            full_loc = lang
+            lang = get_primary_lang_code(lang)
+
+        self[lang][full_loc] = LangConfig(full_loc)
+
+    def _find_setting(self, setting=None, lang=''):
+        if setting is None:
+            raise ValueError("lingua_franca.config requires "
+                             "a setting parameter!")
+
+        setting_available_in = []
+        possible_locs = []
+
+        while True:
+            if setting in self['global']:
+                setting_available_in.append('global')
+            if lang == 'global':
+                break
+
+            lang = lang or get_default_loc()
+
+            if lang in get_supported_langs():
+                possible_locs.append((lang, 'universal'))
+                possible_locs.append((lang, get_full_lang_code(lang)))
+
+            if lang in get_supported_locs():
+                primary_lang_code = get_primary_lang_code(lang)
+                possible_locs.append((primary_lang_code, 'universal'))
+                possible_locs.append(
+                    (primary_lang_code, get_default_loc(primary_lang_code)))
+                possible_locs.append((primary_lang_code, lang))
+
+            for place in possible_locs:
+                if setting in self[place[0]][place[1]]:
+                    setting_available_in.append(place)
+
+            break
+        try:
+            return setting_available_in[-1]
+        except IndexError:
+            return None
+
+    def get(self, setting=None, lang=''):
+        if lang != 'global':
+            if all((lang,
+                    get_primary_lang_code(lang) not in get_active_langs())):
+                raise ModuleNotFoundError(f"{lang} is not currently loaded")
+
+        try:
+            setting_location = self._find_setting(setting, lang)
+
+            if setting_location == 'global':
+                return self['global'][setting]
+            return self[setting_location[0]][setting_location[1]][setting]
+
+        except TypeError:
+            return None
+
+    def set(self, setting=None, value=None, lang='global'):
+        if lang == 'global':
+            if setting in self['global']:
+                self['global'][setting] = value
+                return
+
+        setting_location = self._find_setting(setting, lang if lang !=
+                                              'global' else get_default_loc())
+        if all((setting_location, setting_location != 'global')):
+            self[setting_location[0]][setting_location[1]][setting] = value
+            return
+
+        raise KeyError(
+            f"{setting} is not available as a setting for language: '{lang}'")

lingua_franca/format.py

@@ -21,14 +21,15 @@
 from warnings import warn
 from os.path import join
 
+from lingua_franca import config
 
 from lingua_franca.bracket_expansion import SentenceTreeParser
 from lingua_franca.internal import localized_function, \
     populate_localized_function_dict, get_active_langs, \
     get_full_lang_code, get_default_lang, get_default_loc, \
     is_supported_full_lang, _raise_unsupported_language, \
     UnsupportedLanguageError, NoneLangWarning, InvalidLangWarning, \
-    FunctionNotLocalizedError
+    FunctionNotLocalizedError, ConfigVar
 
 
 _REGISTERED_FUNCTIONS = ("nice_number",
@@ -241,7 +242,7 @@ def year_format(self, dt, lang, bc):
                                                'res/text'))
 
 
-@localized_function(run_own_code_on=[UnsupportedLanguageError])
+@localized_function(run_own_code_on=[UnsupportedLanguageError, TypeError])
 def nice_number(number, lang='', speech=True, denominators=None):
     """Format a float to human readable functions
 
@@ -255,12 +256,23 @@ def nice_number(number, lang='', speech=True, denominators=None):
     Returns:
         (str): The formatted string.
     """
+    args = locals()
+    if denominators:
+        try:
+            denominators.__iter__
+        except (AttributeError, TypeError):
+            try:
+                args[denominators] = range(*denominators)
+            except TypeError:
+                raise ValueError("nice_number(denominators) must be "
+                                 "iterable, or a valid param for range()")
+            nice_number(**args)
     return str(number)
 
 
 @localized_function()
-def nice_time(dt, lang='', speech=True, use_24hour=False,
-              use_ampm=False, variant=None):
+def nice_time(dt, lang='', speech=True, use_24hour=ConfigVar,
+              use_ampm=ConfigVar, variant=ConfigVar):
     """
     Format a time to a comfortable human format
 
@@ -281,7 +293,7 @@ def nice_time(dt, lang='', speech=True, use_24hour=False,
 
 
 @localized_function()
-def pronounce_number(number, lang='', places=2, short_scale=True,
+def pronounce_number(number, lang='', places=2, short_scale=ConfigVar,
                      scientific=False, ordinals=False):
     """
     Convert a number to it's spoken equivalent
@@ -321,8 +333,8 @@ def nice_date(dt, lang='', now=None):
     return date_time_format.date_format(dt, full_code, now)
 
 
-def nice_date_time(dt, lang='', now=None, use_24hour=False,
-                   use_ampm=False):
+def nice_date_time(dt, lang='', now=None, use_24hour=ConfigVar,
+                   use_ampm=ConfigVar):
     """
         Format a datetime to a pronounceable date and time
 
@@ -346,6 +358,11 @@ def nice_date_time(dt, lang='', now=None, use_24hour=False,
     full_code = get_full_lang_code(lang)
     date_time_format.cache(full_code)
 
+    if use_24hour is ConfigVar:
+        use_24hour = config.get(setting='use_24hour', lang=full_code)
+    if use_ampm is ConfigVar:
+        use_ampm = config.get(setting='use_ampm', lang=full_code)
+
     return date_time_format.date_time_format(dt, full_code, now, use_24hour,
                                              use_ampm)