• 源码解析Flask的配置文件


    在flask里,我们常在主文件中定义某些配置,比如:

    app.debug = True
    app.secret_key = 'helloworld!!'
    

    实际上,flask中默认可以进行可选的配置项有很多。

    如果在开发的过程中,把所有需要的配置项都定义在主文件中,就会造成整个程序的目录结构不合理,
    如果需要重写的flask配置项很多的时候,就可以把配置项用别的方式进行定义,然后导入使用
    

    flask的配置文件是一个flask.config.Config对象

    导入Config对象,可以发现Config对象继承字典,

    Config默认的配置有:

    default_config = ImmutableDict({
        'DEBUG':                                get_debug_flag(default=False),
        'TESTING':                              False,
        'PROPAGATE_EXCEPTIONS':                 None,
        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
        'SECRET_KEY':                           None,
        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
        'USE_X_SENDFILE':                       False,
        'LOGGER_NAME':                          None,
        'LOGGER_HANDLER_POLICY':               'always',
        'SERVER_NAME':                          None,
        'APPLICATION_ROOT':                     None,
        'SESSION_COOKIE_NAME':                  'session',
        'SESSION_COOKIE_DOMAIN':                None,
        'SESSION_COOKIE_PATH':                  None,
        'SESSION_COOKIE_HTTPONLY':              True,
        'SESSION_COOKIE_SECURE':                False,
        'SESSION_REFRESH_EACH_REQUEST':         True,
        'MAX_CONTENT_LENGTH':                   None,
        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
        'TRAP_BAD_REQUEST_ERRORS':              False,
        'TRAP_HTTP_EXCEPTIONS':                 False,
        'EXPLAIN_TEMPLATE_LOADING':             False,
        'PREFERRED_URL_SCHEME':                 'http',
        'JSON_AS_ASCII':                        True,
        'JSON_SORT_KEYS':                       True,
        'JSONIFY_PRETTYPRINT_REGULAR':          True,
        'JSONIFY_MIMETYPE':                     'application/json',
        'TEMPLATES_AUTO_RELOAD':                None,
    })
    

    通过查看Config对象的源码,可以知道flask的配置可以有以下几种方式

    1.在主文件中定义(通常使用的方式)

    app.debug = True
    app.secret_key = 'helloworld!!'
    

    由于Config对象继承了dict的方法和属性,所以还可以使用app.config.update(配置项)的方式导入配置项

    2.从环境变量中导入配置项

    导入配置项的方式:

    app.config.from_envvar("环境变量名称")
    

    from_envvar方法的源码:

    def from_envvar(self, variable_name, silent=False):
        
        rv = os.environ.get(variable_name)
        if not rv:
            if silent:
                return False
            raise RuntimeError('The environment variable %r is not set '
                               'and as such configuration could not be '
                               'loaded.  Set this variable and make it '
                               'point to a configuration file' %
                               variable_name)
        return self.from_pyfile(rv, silent=silent)
    

    可以看到,从环境变量中导入配置项的方法,就是从环境变量中找到并读取对应的py文件名称,然后内部调用from_pyfile方法处理读取到的内容得到配置

    3.从python文件中导入

    从python文件中获取配置项的方式:

    app.config.from_pyfile("python文件名称")
    

    例如,创建一个名为setting.py的文件

    setting.py文件的内容为:

    DEBUG=True
    

    然后使用app.config.from_pyfile("setting.py")的方式导入配置项

    from_pyfile方法的源码:

    def from_pyfile(self, filename, silent=False):
    
        filename = os.path.join(self.root_path, filename)
        d = types.ModuleType('config')
        d.__file__ = filename
        try:
            with open(filename, mode='rb') as config_file:
                exec(compile(config_file.read(), filename, 'exec'), d.__dict__)
        except IOError as e:
            if silent and e.errno in (errno.ENOENT, errno.EISDIR):
                return False
            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
            raise
        self.from_object(d)
        return True
    

    从py文件中导入配置项的过程中,读取参数中的python文件的内容,进行编译后exec方法执行,就得到所需要的配置项

    需要注意的是:

    python文件可以是绝对路径或者相对路径,如果是相对路径,则py文件必须放在root_path目录下,

    4.从对象中导入配置项

    from_object方法的源码:

    def from_object(self, obj):
    
        if isinstance(obj, string_types):
            obj = import_string(obj)
        for key in dir(obj):
            if key.isupper():
                self[key] = getattr(obj, key)
    

    从对象中导入配置项的过程中,首先判断所传入的对象名是否是字符串,然后调用import_string方法处理字符串形式的对象名

    import_string方法的源码:

    def import_string(import_name, silent=False):
    
        import_name = str(import_name).replace(':', '.')
        try:
            try:
                __import__(import_name)
            except ImportError:
                if '.' not in import_name:
                    raise
            else:
                return sys.modules[import_name]
    
            module_name, obj_name = import_name.rsplit('.', 1)
            try:
                module = __import__(module_name, None, None, [obj_name])
            except ImportError:
                module = import_string(module_name)
    
            try:
                return getattr(module, obj_name)
            except AttributeError as e:
                raise ImportError(e)
    
        except ImportError as e:
            if not silent:
                reraise(
                    ImportStringError,
                    ImportStringError(import_name, e),
                    sys.exc_info()[2])
    

    可以看到,import_string方法,实际上是对字符串形式的对象名执行rsplit方法,得到模块名和对象名

    在模块可以被正常导入之前,不停执行import_string方法,最后执行getattr方法从模块中获取对象名

    5.from_json:从json字符串中获取配置项

    from_json方法的源码:

    def from_json(self, filename, silent=False):
        
        filename = os.path.join(self.root_path, filename)
    
        try:
            with open(filename) as json_file:
                obj = json.loads(json_file.read())
        except IOError as e:
            if silent and e.errno in (errno.ENOENT, errno.EISDIR):
                return False
            e.strerror = 'Unable to load configuration file (%s)' % e.strerror
            raise
        return self.from_mapping(obj)
    
    

    从json文件中获取配置项,实际上就是对json文件执行json.loads方法,得到对象

    然后内部调用from_mapping方法处理所得到的对象

    6.from_mapping:从dict字典中获取配置项

    from_mapping方法的源码:

    def from_mapping(self, *mapping, **kwargs):
    
        mappings = []
        if len(mapping) == 1:
            if hasattr(mapping[0], 'items'):
                mappings.append(mapping[0].items())
            else:
                mappings.append(mapping[0])
        elif len(mapping) > 1:
            raise TypeError(
                'expected at most 1 positional argument, got %d' % len(mapping)
            )
        mappings.append(kwargs.items())
        for mapping in mappings:
            for (key, value) in mapping:
                if key.isupper():
                    self[key] = value
        return True
    

    把参数字典中的所有键值对添加到列表串,循环遍历列表,读取列表中每个元素的键和值

    如果键为大写,则key为配置选项,value为配置选项的值

    7.get_namespace:从名称空间中获取配置选项

    get_namespace源码:

    def get_namespace(self, namespace, lowercase=True, trim_namespace=True):
    
        rv = {}
        for k, v in iteritems(self):
            if not k.startswith(namespace):
                continue
            if trim_namespace:
                key = k[len(namespace):]
            else:
                key = k
            if lowercase:
                key = key.lower()
            rv[key] = v
        return rv
    

    get_namespace方法,是从指定的名称空间或前缀中进行匹配,返回包含配置项的子集的字典

    迭代当前对象,获取key和v,把key转换为小写格式,然后把key和v包含在一个字典中

  • 相关阅读:
    Photon Server 实现注册与登录(五) --- 服务端、客户端完整代码
    机器学习小白笔记系列——支持向量机
    机器学习小白笔记系列——条件随机场
    机器学习小白笔记系列——EM算法
    机器学习小白笔记系列——线性回归
    多元统计分析学习笔记——概论及数据描述知识点回顾
    ORACLE的SPFILE与PFILE
    简单的点餐系统
    Linux系统中CTG的安装,应用程序开发以及调试
    Netstat命令
  • 原文地址:https://www.cnblogs.com/renpingsheng/p/8735107.html
Copyright © 2020-2023  润新知