File: //usr/lib/python3.6/site-packages/botocore/__pycache__/configloader.cpython-36.pyc
3
�T_l% � @ sr d dl Z d dlZd dlZd dlZd dlmZ d dlZdd� Zdd� Z dd� Z
dd
d �Z d d
� Z dd� Z
dd� ZdS )� N)�sixc G st g }g }xN| D ]F}y t |�}W n tjjk
r8 wY nX |j|jd�� |j|� qW t|�}t|�}||d< |S )a
Load and combine multiple INI configs with profiles.
This function will take a list of filesnames and return
a single dictionary that represents the merging of the loaded
config files.
If any of the provided filenames does not exist, then that file
is ignored. It is therefore ok to provide a list of filenames,
some of which may not exist.
Configuration files are **not** deep merged, only the top level
keys are merged. The filenames should be passed in order of
precedence. The first config file has precedence over the
second config file, which has precedence over the third config file,
etc. The only exception to this is that the "profiles" key is
merged to combine profiles from multiple config files into a
single profiles mapping. However, if a profile is defined in
multiple config files, then the config file with the highest
precedence is used. Profile values themselves are not merged.
For example::
FileA FileB FileC
[foo] [foo] [bar]
a=1 a=2 a=3
b=2
[bar] [baz] [profile a]
a=2 a=3 region=e
[profile a] [profile b] [profile c]
region=c region=d region=f
The final result of ``multi_file_load_config(FileA, FileB, FileC)``
would be::
{"foo": {"a": 1}, "bar": {"a": 2}, "baz": {"a": 3},
"profiles": {"a": {"region": "c"}}, {"b": {"region": d"}},
{"c": {"region": "f"}}}
Note that the "foo" key comes from A, even though it's defined in both
FileA and FileB. Because "foo" was defined in FileA first, then the values
for "foo" from FileA are used and the values for "foo" from FileB are
ignored. Also note where the profiles originate from. Profile "a"
comes FileA, profile "b" comes from FileB, and profile "c" comes
from FileC.
�profiles)� load_config�botocore�
exceptions�ConfigNotFound�append�pop�_merge_list_of_dicts)� filenamesZconfigsr �filenameZloadedZ
merged_configZmerged_profiles� r
�"/usr/lib/python3.6/configloader.py�multi_file_load_config s 0
r c C s< i }x2| D ]*}x$|j � D ]\}}||kr|||< qW q
W |S )N)�items)Z
list_of_dictsZ merged_dictsZ single_dict�key�valuer
r
r r
W s
r
c C s t | �}t|�S )a Parse a INI config with profiles.
This will parse an INI config file and map top level profiles
into a top level "profile" key.
If you want to parse an INI file and map all section names to
top level keys, use ``raw_config_parse`` instead.
)�raw_config_parse�build_profile_map)�config_filename�parsedr
r
r r ` s
r Tc C s& i }| }|dk �r"t jj|�}t jj|�}t jj|�sHtjjt|�d��t j
j j � }y|j
|g� W n0 t j
j jtfk
r� tjjt|�d��Y n�X x�|j� D ]~}i ||< xp|j|�D ]b}|j||�}|o�|jd��ry t|�}W n( tk
�r tjjt|�d��Y nX ||| |< q�W q�W |S )a� Returns the parsed INI config contents.
Each section name is a top level key.
:param config_filename: The name of the INI file to parse
:param parse_subsections: If True, parse indented blocks as
subsections that represent their own configuration dictionary.
For example, if the config file had the contents::
s3 =
signature_version = s3v4
addressing_style = path
The resulting ``raw_config_parse`` would be::
{'s3': {'signature_version': 's3v4', 'addressing_style': 'path'}}
If False, do not try to parse subsections and return the indented
block as its literal value::
{'s3': '
signature_version = s3v4
addressing_style = path'}
:returns: A dict with keys for each profile found in the config
file and the value of each key being a dict containing name
value pairs found in that profile.
:raises: ConfigNotFound, ConfigParseError
N)�path�
)�osr �
expandvars�
expanduser�isfiler r r �
_unicode_pathr ZmovesZ configparserZRawConfigParser�read�Error�UnicodeDecodeErrorZConfigParseErrorZsectionsZoptions�get�
startswith�
_parse_nested�
ValueError)r Zparse_subsections�configr ZcpZsectionZoption� config_valuer
r
r r n s2
r c C s4 t | tj�r| S tj� }|d kr(tj� }| j|d�S )N�replace)�
isinstancer Z text_type�sys�getfilesystemencoding�getdefaultencoding�decode)r Zfilesystem_encodingr
r
r r � s r c C sH i }x>| j � D ]2}|j� }|s q|jdd�\}}|j� ||j� < qW |S )N�=� )�
splitlines�strip�split)r& r �liner r r
r
r r# � s r# c
C s� t j| �}i }i }xx|j� D ]l\}}|jd�rnytj|�}W n tk
rR w Y nX t|�dkr�|||d < q |dkr�|||< q |||< q W ||d< |S )a� Convert the parsed INI config into a profile map.
The config file format requires that every profile except the
default to be prepended with "profile", e.g.::
[profile test]
aws_... = foo
aws_... = bar
[profile bar]
aws_... = foo
aws_... = bar
# This is *not* a profile
[preview]
otherstuff = 1
# Neither is this
[foobar]
morestuff = 2
The build_profile_map will take a parsed INI config file where each top
level key represents a section name, and convert into a format where all
the profiles are under a single top level "profiles" key, and each key in
the sub dictionary is a profile name. For example, the above config file
would be converted from::
{"profile test": {"aws_...": "foo", "aws...": "bar"},
"profile bar": {"aws...": "foo", "aws...": "bar"},
"preview": {"otherstuff": ...},
"foobar": {"morestuff": ...},
}
into::
{"profiles": {"test": {"aws_...": "foo", "aws...": "bar"},
"bar": {"aws...": "foo", "aws...": "bar"},
"preview": {"otherstuff": ...},
"foobar": {"morestuff": ...},
}
If there are no profiles in the provided parsed INI contents, then
an empty dict will be the value associated with the ``profiles`` key.
.. note::
This will not mutate the passed in parsed_ini_config. Instead it will
make a deepcopy and return that value.
Zprofile� r. �defaultr )�copy�deepcopyr r" �shlexr1 r$ �len)Zparsed_ini_configZ
parsed_configr Z final_configr �values�partsr
r
r r � s 3
r )T)r r7 r5 r) Zbotocore.compatr Zbotocore.exceptionsr r r
r r r r# r r
r
r
r �<module> s ?
=