Update config

sanic/app.py

@@ -1452,3 +1452,15 @@ async def __call__(self, scope, receive, send):
         self.asgi = True
         asgi_app = await ASGIApp.create(self, scope, receive, send)
         await asgi_app()
+
+
+
+    # -------------------------------------------------------------------- #
+    # Configuration
+    # -------------------------------------------------------------------- #
+    def update_config(self, config: Union[bytes, str, dict, Any]):
+    """Update app.config.  
+
+    Please refer to config.py: Config class: update_config method for documentation."""
+
+        self.config.update_config(config)

sanic/config.py

@@ -1,8 +1,19 @@
-import os
-import types
+from os import environ as os_environ
+
+from typing import Union, \
+                   Any
 
+from .utils import str_to_bool, \
+                   load_module_from_file_location
+
+# \/ \/ \/ \/
+# TODO: remove in version: 21.3
+import types
 from sanic.exceptions import PyFileError
 from sanic.helpers import import_string
+from warnings import warn
+# /\ /\ /\ /\ 
+
 
 
 SANIC_PREFIX = "SANIC_"
@@ -33,6 +44,7 @@
 }
 
 
+
 class Config(dict):
     def __init__(self, defaults=None, load_env=True, keep_alive=None):
         defaults = defaults or {}
@@ -56,27 +68,42 @@ def __getattr__(self, attr):
     def __setattr__(self, attr, value):
         self[attr] = value
 
+    # \/ \/ \/ \/
+    # TODO: remove in version: 21.3
     def from_envvar(self, variable_name):
         """Load a configuration from an environment variable pointing to
         a configuration file.
 
         :param variable_name: name of the environment variable
         :return: bool. ``True`` if able to load config, ``False`` otherwise.
         """
-        config_file = os.environ.get(variable_name)
+
+        warn("Using `from_envvar` method is deprecated and will be removed in v21.3, use `app.update_config` method instead.",
+             DeprecationWarning,
+             stacklevel=2)
+
+        config_file = os_environ.get(variable_name)
         if not config_file:
             raise RuntimeError(
                 "The environment variable %r is not set and "
                 "thus configuration could not be loaded." % variable_name
             )
         return self.from_pyfile(config_file)
+    # /\ /\ /\ /\ 
 
+    # \/ \/ \/ \/
+    # TODO: remove in version: 21.3
     def from_pyfile(self, filename):
         """Update the values in the config from a Python file.
         Only the uppercase variables in that module are stored in the config.
 
         :param filename: an absolute path to the config file
         """
+
+        warn("Using `from_pyfile` method is deprecated and will be removed in v21.3, use `app.update_config` method instead.",
+             DeprecationWarning,
+             stacklevel=2)
+
         module = types.ModuleType("config")
         module.__file__ = filename
         try:
@@ -93,7 +120,10 @@ def from_pyfile(self, filename):
 
         self.from_object(module)
         return True
+    # /\ /\ /\ /\ 
 
+    # \/ \/ \/ \/
+    # TODO: remove in version: 21.3
     def from_object(self, obj):
         """Update the values from the given object.
         Objects are usually either modules or classes.
@@ -114,18 +144,24 @@ def from_object(self, obj):
 
         :param obj: an object holding the configuration
         """
+
+        warn("Using `from_object` method is deprecated and will be removed in v21.3, use `app.update_config` method instead.",
+             DeprecationWarning,
+             stacklevel=2)
+
         if isinstance(obj, str):
             obj = import_string(obj)
         for key in dir(obj):
             if key.isupper():
                 self[key] = getattr(obj, key)
+    # /\ /\ /\ /\ 
 
     def load_environment_vars(self, prefix=SANIC_PREFIX):
         """
         Looks for prefixed environment variables and applies
         them to the configuration if present.
         """
-        for k, v in os.environ.items():
+        for k, v in os_environ.items():
             if k.startswith(prefix):
                 _, config_key = k.split(prefix, 1)
                 try:
@@ -135,23 +171,46 @@ def load_environment_vars(self, prefix=SANIC_PREFIX):
                         self[config_key] = float(v)
                     except ValueError:
                         try:
-                            self[config_key] = strtobool(v)
+                            self[config_key] = str_to_bool(v)
                         except ValueError:
                             self[config_key] = v
 
 
-def strtobool(val):
-    """
-    This function was borrowed from distutils.utils. While distutils
-    is part of stdlib, it feels odd to use distutils in main application code.
-
-    The function was modified to walk its talk and actually return bool
-    and not int.
-    """
-    val = val.lower()
-    if val in ("y", "yes", "t", "true", "on", "1"):
-        return True
-    elif val in ("n", "no", "f", "false", "off", "0"):
-        return False
-    else:
-        raise ValueError("invalid truth value %r" % (val,))
+    def update_config(self, config: Union[bytes, str, dict, Any]):
+    """Update app.config.  
+
+    Note:: only upper case settings are considered.  
+
+    You can upload app config by providing path to py file holding settings.  
+
+        # /some/py/file  
+        A = 1  
+        B = 2  
+
+        config.update_config("${some}/py/file")  
+
+    Yes you can put environment variable here, but they must be provided in format: ${some_env_var},  
+    and mark that $some_env_var is treated as plain string.  
+
+    You can upload app config by providing dict holding settings.  
+
+        d = {"A": 1, "B": 2}  
+        config.update_config(d)  
+
+    You can upload app config by providing any object holding settings,  
+    but in such case config.__dict__ will be used as dict holding settings.  
+
+        class C:  
+            A = 1  
+            B = 2  
+        config.update_config(C)"""
+
+        if isinstance(config, (bytes, str)):
+            config = load_module_from_file_location("config", location=config)
+
+        if not isinstance(config, dict):
+            config = config.__dict__
+
+        config = dict(filter(lambda i: i[0].isupper(), config.items()))
+
+        self.update(config)

sanic/exceptions.py

@@ -169,6 +169,11 @@ def __init__(self, message, status_code=None, scheme=None, **kwargs):
             }
 
 
+class LoadModuleFromFileLocationException(ImportError):
+    """Raised from within utils.py: load_module_from_file_location() function."""
+    pass
+
+
 def abort(status_code, message=None):
     """
     Raise an exception based on SanicException. Returns the HTTP response

sanic/utils.py

@@ -0,0 +1,70 @@
+from os import environ as os_environ
+from re import findall as re_findall
+from importlib.util import spec_from_file_location, \
+                           module_from_spec
+from .exceptions import LoadModuleFromFileLocationException
+from typing import Union
+
+
+
+def str_to_bool(val):
+    """Takes string and tries to turn it into bool as human would do.  
+
+    If val is in case insensitive ("y", "yes", "yep", "yup", "t", "true", "on", "enable", "enabled", "1") returns True.  
+    If val is in case insensitive ("n", "no", "f", "false", "off", "disable", "disabled", "0") returns False.  
+    Else Raise ValueError."""
+
+    val = val.lower()
+    if val in {"y", "yes", "yep", "yup", "t", "true", "on", "enable", "enabled", "1"}:
+        return True
+    elif val in {"n", "no", "f", "false", "off", "disable", "disabled", "0"}:
+        return False
+    else:
+        raise ValueError(f"Invalid truth value {val}")
+
+
+
+def load_module_from_file_location(name: str, location: Union[bytes, str], enc: str = "utf8", *args, **kwargs):
+    """Returns loaded module provided as a file path.  
+
+    :param name:  
+        The same as importlib.util.spec_from_file_location name param.  
+    :param args:  
+        Coresponds to importlib.util.spec_from_file_location location parameters,  
+        but with this differences:  
+        - It has to be of a string or bytes type.  
+        - You can also use here environment variables in format ${some_env_var}.  
+          Mark that $some_env_var will not be resolved as environment variable.  
+    :enc:  
+        If location parameter is of a bytes type, then use this encoding to decode it into string.  
+    :param args:  
+        Coresponds to the rest of importlib.util.spec_from_file_location parameters.  
+    :param kwargs:  
+        Coresponds to the rest of importlib.util.spec_from_file_location parameters.  
+
+    For example You can:  
+
+        some_module = load_module_from_file_location("some_module_name", "/some/path/${some_env_var})"""
+
+    # 1) Parse location.
+    if isinstance(location, bytes):
+        location = location.decode(enc)
+
+    # A) Check if location contains any environment variables in format ${some_env_var}.
+    env_vars_in_location = set(re_findall("\${(.+?)}", location))
+
+    # B) Check these variables exists in environment.
+    not_defined_env_vars = env_vars_in_location.difference(os_environ.keys())
+    if not_defined_env_vars:
+        raise LoadModuleFromFileLocationException(f"The following environment variables are not set: {', '.join(not_defined_env_vars)}")
+
+    # C) Substitute them in location.
+    for env_var in env_vars_in_location:
+        location = location.replace("${" + env_var + "}", os_environ[env_var])
+
+    # 2) Load and return module.
+    _mod_spec = spec_from_file_location(name, location, *args, **kwargs)
+    module = module_from_spec(_mod_spec)
+    _mod_spec.loader.exec_module(module)
+
+    return module