U
|
ß=®d 2 ã @ sb d dl mZ d dlZd dlZd dlZd dlZd dlZd dlm Z G dd dZ
|
G dd de Z dS )é )Ú annotationsN)Ú import_stringc @ sJ e Zd ZdZdddddddZdd d d d
|
d d Zd d dd ddZdS )ÚConfigAttributez(Makes an attribute forward to the configNÚstrzt.Callable | NoneÚNone)ÚnameÚ get_converterÚreturnc C s || _ || _d S ©N)Ú__name__r )Úselfr r © r úCd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\flask/config.pyÚ__init__ s zConfigAttribute.__init__út.Any)ÚobjÚownerr c C s0 |d kr | S |j | j }| jd k r,| |¡}|S r
|
)Úconfigr r )r r r Úrvr r r Ú__get__ s
|
|
zConfigAttribute.__get__)r Úvaluer c C s ||j | j< d S r
|
)r r )r r r r r r Ú__set__ s zConfigAttribute.__set__)N)N)r Ú
|
__module__Ú __qualname__Ú__doc__r r r r r r r r s r c sÐ e Zd ZdZd,dddd fdd Zd-dd
|
d
|
d d d Zd.ejdddd
|
dddZd/dd
|
d
|
dddZ dddddZ
|
d0dd d
|
d
|
d
|
d d d Z d1d d!d
|
d"d#d$Z d2dd
|
d
|
d%d&d'd(Z dd)d*d+Z ZS )3ÚConfigaÙ Works exactly like a dict but provides ways to fill it from files
|
or special dictionaries. There are two common patterns to populate the
|
config.
|
|
Either you can fill the config from a config file::
|
|
app.config.from_pyfile('yourconfig.cfg')
|
|
Or alternatively you can define the configuration options in the
|
module that calls :meth:`from_object` or provide an import path to
|
a module that should be loaded. It is also possible to tell it to
|
use the same module and with that provide the configuration values
|
just before the call::
|
|
DEBUG = True
|
SECRET_KEY = 'development key'
|
app.config.from_object(__name__)
|
|
In both cases (loading from any Python file or loading from modules),
|
only uppercase keys are added to the config. This makes it possible to use
|
lowercase values in the config file for temporary values that are not added
|
to the config or to define the config keys in the same file that implements
|
the application.
|
|
Probably the most interesting way to load configurations is from an
|
environment variable pointing to a file::
|
|
app.config.from_envvar('YOURAPPLICATION_SETTINGS')
|
|
In this case before launching the application you have to set this
|
environment variable to the file you want to use. On Linux and OS X
|
use the export statement::
|
|
export YOURAPPLICATION_SETTINGS='/path/to/config/file'
|
|
On windows use `set` instead.
|
|
:param root_path: path to which files are read relative from. When the
|
config object is created by the application, this is
|
the application's :attr:`~flask.Flask.root_path`.
|
:param defaults: an optional dictionary of default values
|
Nr z dict | Noner )Ú root_pathÚdefaultsr c s t |p i ¡ || _d S r
|
)Úsuperr r )r r r ©Ú __class__r r r K s zConfig.__init__FÚbool)Ú variable_nameÚsilentr c C s6 t j |¡}|s(|rdS td|d| j||dS )aù Loads a configuration from an environment variable pointing to
|
a configuration file. This is basically just a shortcut with nicer
|
error messages for this line of code::
|
|
app.config.from_pyfile(os.environ['YOURAPPLICATION_SETTINGS'])
|
|
:param variable_name: name of the environment variable
|
:param silent: set to ``True`` if you want silent failure for missing
|
files.
|
:return: ``True`` if the file was loaded successfully.
|
FzThe environment variable zv is not set and as such configuration could not be loaded. Set this variable and make it point to a configuration file)r# )ÚosÚenvironÚgetÚ RuntimeErrorÚ from_pyfile)r r" r# r r r r Ú from_envvarO s
|
ÿzConfig.from_envvarÚFLASK)Úloadszt.Callable[[str], t.Any])Úprefixr+ r c
|
C sº | d}t |}ttjD ]}| |¡s,q tj| }z ||}W n tk
|
rV Y nX ||d
}d|krv|| |< q | }| d¡^ }}|D ] } | |kr¢i || < || }q|||< q dS )a Load any environment variables that start with ``FLASK_``,
|
dropping the prefix from the env key for the config key. Values
|
are passed through a loading function to attempt to convert them
|
to more specific types than strings.
|
|
Keys are loaded in :func:`sorted` order.
|
|
The default loading function attempts to parse values as any
|
valid JSON type, including dicts and lists.
|
|
Specific items in nested dicts can be set by separating the
|
keys with double underscores (``__``). If an intermediate key
|
doesn't exist, it will be initialized to an empty dict.
|
|
:param prefix: Load env vars that start with this prefix,
|
separated with an underscore (``_``).
|
:param loads: Pass each string value to this function and use
|
the returned value as the config value. If any error is
|
raised it is ignored and the value remains a string. The
|
default is :func:`json.loads`.
|
|
.. versionadded:: 2.1
|
Ú_NÚ__T)ÚlenÚsortedr$ r% Ú
|
startswithÚ ExceptionÚsplit)
|
r r, r+ Z
|
len_prefixÚkeyr ÚcurrentÚpartsÚtailÚpartr r r Úfrom_prefixed_envg s,
|
|
|
|
|
zConfig.from_prefixed_env)Úfilenamer# r c
|
C s¼ t j | j|¡}t d¡}||_z4t|dd }tt |
|
¡ |d|j W 5 Q R X W nX t k
|
r¬ } z:|r|j t jt jt jfkrW Y ¢dS d|j d|_ W 5 d}~X Y nX | |¡ d S )
|
aT Updates the values in the config from a Python file. This function
|
behaves as if the file was imported as module with the
|
:meth:`from_object` function.
|
|
:param filename: the filename of the config. This can either be an
|
absolute filename or a filename relative to the
|
root path.
|
:param silent: set to ``True`` if you want silent failure for missing
|
files.
|
:return: ``True`` if the file was loaded successfully.
|
|
.. versionadded:: 0.7
|
`silent` parameter.
|
r Úrb)ÚmodeÚexecFú#Unable to load configuration file (ú)NT)r$ ÚpathÚjoinr ÚtypesÚ
|
ModuleTypeÚ__file__Úopenr= ÚcompileÚreadÚ__dict__ÚOSErrorÚerrnoÚENOENTÚEISDIRÚENOTDIRÚstrerrorÚ from_object)r r: r# ÚdÚ config_fileÚer r r r( § s
|
&
|
|
zConfig.from_pyfilez object | str)r r c C s: t |trt|}t|D ]}| ¡ rt||| |< qdS )a Updates the values from the given object. An object can be of one
|
of the following two types:
|
|
- a string: in this case the object with that name will be imported
|
- an actual object reference: that object is used directly
|
|
Objects are usually either modules or classes. :meth:`from_object`
|
loads only the uppercase attributes of the module/class. A ``dict``
|
object will not work with :meth:`from_object` because the keys of a
|
``dict`` are not attributes of the ``dict`` class.
|
|
Example of module-based configuration::
|
|
app.config.from_object('yourapplication.default_config')
|
from yourapplication import default_config
|
app.config.from_object(default_config)
|
|
Nothing is done to the object before loading. If the object is a
|
class and has ``@property`` attributes, it needs to be
|
instantiated before being passed to this method.
|
|
You should not use this function to load the actual configuration but
|
rather configuration defaults. The actual config should be loaded
|
with :meth:`from_pyfile` and ideally from a location not within the
|
package because the package might be installed system wide.
|
|
See :ref:`config-dev-prod` for an example of class-based configuration
|
using :meth:`from_object`.
|
|
:param obj: an import name or object
|
N)Ú
|
isinstancer r ÚdirÚisupperÚgetattr)r r r4 r r r rO Ä s
|
|
zConfig.from_objectTz$t.Callable[[t.IO[t.Any]], t.Mapping])r: Úloadr# Útextr c
|
C s t j | j|¡}z*t||r dnd}||}W 5 Q R X W nT tk
|
r } z6|rl|jtjtjfkrlW Y ¢dS d|j d|_ W 5 d}~X Y nX |
|
|¡S )a" Update the values in the config from a file that is loaded
|
using the ``load`` parameter. The loaded data is passed to the
|
:meth:`from_mapping` method.
|
|
.. code-block:: python
|
|
import json
|
app.config.from_file("config.json", load=json.load)
|
|
import tomllib
|
app.config.from_file("config.toml", load=tomllib.load, text=False)
|
|
:param filename: The path to the data file. This can be an
|
absolute path or relative to the config root path.
|
:param load: A callable that takes a file handle and returns a
|
mapping of loaded data from the file.
|
:type load: ``Callable[[Reader], Mapping]`` where ``Reader``
|
implements a ``read`` method.
|
:param silent: Ignore the file if it doesn't exist.
|
:param text: Open the file in text or binary mode.
|
:return: ``True`` if the file was loaded successfully.
|
|
.. versionchanged:: 2.3
|
The ``text`` parameter was added.
|
|
.. versionadded:: 2.0
|
Úrr; Fr> r? N) r$ r@ rA r rE rI rJ rK rL rN Ú from_mapping)r r: rW r# rX Úfr rR r r r Ú from_fileê s "
|
zConfig.from_filez t.Mapping[str, t.Any] | Noner )ÚmappingÚkwargsr c K sF i }|dk r| |¡ | |¡ | ¡ D ]\}}| ¡ r(|| |< q(dS )z¦Updates the config like :meth:`update` ignoring items with
|
non-upper keys.
|
|
:return: Always returns ``True``.
|
|
.. versionadded:: 0.11
|
NT)ÚupdateÚitemsrU )r r] r^ Zmappingsr4 r r r r rZ s
|
|
|
|
zConfig.from_mappingzdict[str, t.Any])Ú namespaceÚ lowercaseÚtrim_namespacer c C sT i }| ¡ D ]B\}}| |¡s q |r6|t|d
}n|}|rF| ¡ }|||< q |S )ai Returns a dictionary containing a subset of configuration options
|
that match the specified namespace/prefix. Example usage::
|
|
app.config['IMAGE_STORE_TYPE'] = 'fs'
|
app.config['IMAGE_STORE_PATH'] = '/var/app/images'
|
app.config['IMAGE_STORE_BASE_URL'] = 'http://img.website.com'
|
image_store_config = app.config.get_namespace('IMAGE_STORE_')
|
|
The resulting dictionary `image_store_config` would look like::
|
|
{
|
'type': 'fs',
|
'path': '/var/app/images',
|
'base_url': 'http://img.website.com'
|
}
|
|
This is often useful when configuration options map directly to
|
keyword arguments in functions or class constructors.
|
|
:param namespace: a configuration namespace
|
:param lowercase: a flag indicating if the keys of the resulting
|
dictionary should be lowercase
|
:param trim_namespace: a flag indicating if the keys of the resulting
|
dictionary should not include the namespace
|
|
.. versionadded:: 0.11
|
N)r` r1 r/ Úlower)r ra rb rc r ÚkÚvr4 r r r Ú get_namespace- s
|
|
zConfig.get_namespace)r c C s dt | j dt | ¡ dS )Nú<ú ú>)Útyper ÚdictÚ__repr__)r r r r rm X s zConfig.__repr__)N)F)r* )F)FT)N)TT)r r r r r r) Újsonr+ r9 r( rO r\ rZ rg rm Ú __classcell__r r r r r s$ + ÿÿ@ * û1 ÿ ÿ+r ) Ú
|
__future__r rJ rn r$ rB ÚtypingÚtZwerkzeug.utilsr r rl r r r r r Ú<module> s
|
