%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /snap/certbot/current/lib64/python3.12/site-packages/__pycache__/
Upload File :
Create Path :
Current File : //snap/certbot/current/lib64/python3.12/site-packages/__pycache__/configargparse.cpython-312.pyc

�

�h�jH����dZddlZddlZddlZddlZddlZddlZddlZddlZddl	Z	ddl
Z
ddlZddlm
Z
ddlZddlZddlmZej$ej&ej(ej*ej,gZe
j0dk\rej3ej4�d�Znd�Zee�ZiZd4d�Zd4d	�ZGd
�dej@ejBejD�Z#Gd�d
e$�Z%Gd�de$�Z&Gd�de'�Z(Gd�de(�Z)Gd�de%�Z*Gd�de%�Z+Gd�de%�Z,	e	jZd�Z.e	jZde	j^��Z0ejbdd��d5d ��Z2d5d!�Z3d"�Z4d#�Z5Gd$�d%e%�Z6Gd&�d'e%�Z7Gd(�d)e%�Z8d*Z9d+Z:d,Z;d-Z<Gd.�d/ejz�Z=d0�Z>d4d1�Z?d2�Z@d3�ZAej�j|ej�_Ce>ej�_>ej�ZDej@Z ej�ZEej�ZFej�ZGej�ZHej�ZIej�ZJejDZ"ejBZ!ej�ZKej�ZLej�ZMej�ZNej�ZOej�ZPeZQeZReZSeZTeZUeZVe=ZWe=ZXej�j|ej�_Yej�j|ej�_Ze=j�e=_\e=j�e=_^e"Z_e Z`e#Zay)6z�
A drop-in replacement for `argparse` that allows options to also be set via config files and/or environment variables.

:see: `configargparse.ArgumentParser`, `configargparse.add_argument`
�N)�OrderedDict)�StringIO���	c�6�t|tj�S�N)�
isinstance�argparse�BooleanOptionalAction��actions �J/root/parts/certbot/install/lib/python3.12/site-packages/configargparse.py�<lambda>r!s��
���.�.�1��c��y)NF�r
s rrr%s�rc���|�d}|tvrtd|�dt|����|jdtj�|jdd�tdi|��t|<y)	z�Creates a global ArgumentParser instance with the given name,
    passing any args other than "name" to the ArgumentParser constructor.
    This instance can then be retrieved using get_argument_parser(..)
    N�defaultz=kwargs besides 'name' can only be passed in the first time. 'z!' ArgumentParser already exists: �formatter_class�conflict_handler�resolver)�_parsers�
ValueError�
setdefaultr�ArgumentDefaultsHelpFormatter�ArgumentParser��name�kwargss  r�init_argument_parserr!.sn���|����x���
�X�d�^�	
%�
�	
����'��)O�)O�P�
���(�)�4�#�-�f�-�H�T�Nrc�`�|�d}t|�dkDs|tvrt|fi|��t|S)aReturns the global ArgumentParser instance with the given name. The 1st
    time this function is called, a new ArgumentParser instance will be created
    for the given name, and any args other than "name" will be passed on to the
    ArgumentParser constructor.
    rr)�lenrr!rs  r�get_argument_parserr$Es7���|���
�6�{�Q��$�h�.��T�,�V�,��D�>�rc��eZdZdZy)� ArgumentDefaultsRawHelpFormatterzCHelpFormatter that adds default values AND doesn't do line-wrappingN��__name__�
__module__�__qualname__�__doc__rrrr&r&Ts��
N�rr&c�"�eZdZdZd�Zd�Zd�Zy)�ConfigFileParserzRThis abstract class can be extended to add support for new config file
    formatsc��td��)z3Returns a string describing the config file syntax.z*get_syntax_description(..) not implemented��NotImplementedError��selfs r�get_syntax_descriptionz'ConfigFileParser.get_syntax_descriptionbs��!�"N�O�Orc��td��)a\Parses the keys and values from a config file.

        NOTE: For keys that were specified to configargparse as
        action="store_true" or "store_false", the config file value must be
        one of: "yes", "no", "on", "off", "true", "false". Otherwise an error will be raised.

        Args:
            stream (io.IOBase): A config file input stream (such as an open file object).

        Returns:
            OrderedDict: Items where the keys are strings and the
            values are either strings or lists (eg. to support config file
            formats like YAML which allow lists).
        zparse(..) not implementedr/)r2�streams  r�parsezConfigFileParser.parsefs��"�"=�>�>rc��td��)a�Does the inverse of config parsing by taking parsed values and
        converting them back to a string representing config file contents.

        Args:
            items: an OrderedDict of items to be converted to the config file
                format. Keys should be strings, and values should be either strings
                or lists.

        Returns:
            Contents of config file as a string
        zserialize(..) not implementedr/�r2�itemss  r�	serializezConfigFileParser.serializews��"�"A�B�BrN�r(r)r*r+r3r6r:rrrr-r-^s���P�?�"Crr-c�$��eZdZdZd�fd�	Z�xZS)�_WriteOutConfigFileActionMixinaGRemembers the path this arg was given, on the parser that parsed it.

    The path can't just be read back out of the parsed namespace once parsing
    finishes: another arg sharing this one's dest could have put a value there,
    from a config file or anywhere else, and writing a config file overwrites
    the path it is given. Recording it as the arg is parsed means only this
    arg decides where that write goes.

    add_argument() puts this over whichever store action the program asked for,
    so an arg that does something of its own with the path still records it.
    c���tt|�||||�t|d�r.t	||j
|�|jt|�<yy)N�_write_out_config_file_paths)�superr=�__call__�hasattr�getattr�destr?�id)r2�parser�	namespace�values�
option_string�	__class__s     �rrAz'_WriteOutConfigFileActionMixin.__call__�sR���
�,�d�<��I�v�}�	
��6�9�:�<C��4�9�9�f�=�F�/�/��4��9�;rr	)r(r)r*r+rA�
__classcell__�rJs@rr=r=�s���
�
�
rr=c��eZdZdZy)�ConfigFileParserExceptionz'Raised when config file parsing failed.Nr'rrrrNrN�s��1rrNc��eZdZdZy)�!ConfigFileParserMissingDependencyz.Raised when an optional dependency is missing.Nr'rrrrPrP�s��8rrPc�"�eZdZdZd�Zd�Zd�Zy)�DefaultConfigFileParsera�
    Based on a simplified subset of INI and YAML formats. Here is the
    supported syntax

    .. code::

        # this is a comment
        ; this is also a comment (.ini style)
        ---            # lines that start with --- are ignored (yaml style)
        -------------------
        [section]      # .ini-style section names are treated as comments

        # how to specify a key-value pair (all of these are equivalent):
        name value     # key is case sensitive: "Name" isn't "name"
        name = value   # (.ini style)  (white space is ignored, so name = value same as name=value)
        name: value    # (yaml style)
        --name value   # (argparse style)

        # how to set a flag arg (eg. arg which has action="store_true")
        --name
        name
        name = True    # "True" and "true" are the same

        # how to specify a list arg (eg. arg which has action="append")
        fruit = [apple, orange, lemon]
        indexes = [1, 12, 35 , 40]

    c�
�d}|S)NzrConfig file syntax allows: key=value, flag=true, stuff=[a,b,c] (for details, see syntax at https://goo.gl/R74nmi).r�r2�msgs  rr3z.DefaultConfigFileParser.get_syntax_description�s��
B�	��
rc���t�}t|�D�]\}}|j�}|r|ddvs|jd�r�2t	j
d|�}|r�|j
d�}|j
d�}|j
d�}|j
d�}	|�
|�|d	k7rd
}n|�d}|jd�r'|jd
�r	tj|�}|||<��tdj|t|dd�|���|S#t$r?}
|ddjd�D�cgc]}|j���ncc}w}}Yd}
~
�sd}
~
wwxYw)Nr)�#�;�[z---zn^(?P<key>[^:=;#\s]+)\s*(?:(?P<equal>[:=\s])\s*([\'"]?)(?P<value>.+?)?\3)?\s*(?:\s[;#]\s*(?P<comment>.*?)\s*)?$�key�equal�value�comment� ��truerY�]�����,zUnexpected line {} in {}: {}rr5)r�	enumerate�strip�
startswith�re�match�group�endswith�json�loads�	Exception�splitrN�formatrC)r2r5r9�i�linerirZr[r\r]�e�elems            rr6zDefaultConfigFileParser.parse�sj���
�� ��(�!	�G�A�t��:�:�<�D��4��7�o�5�����9O���H�H�9��	�E���k�k�%�(�����G�,�����G�,���+�+�i�0���=�U�%6�5�C�<��E��]�"�E��#�#�C�(�U�^�^�C�-@�R� $�
�
�5� 1��#��c�
�/�2�9�9��7�6�6�8�<�d����;!	�D���%�R�:?��"�+�:K�:K�C�:P� Q�$����� Q�� Q�� Q��R�s$�D�	E$�%E�;E�E�E$c��t�}|j�D]�\}}t|t�r&ddj	tt|��zdz}ndj|�}t
|�|fD]%}d|vsd|vs�tdj||���|jdj||����|j�S)	NrY�, raz{}�
�
z�Config file values can't contain newlines, so {} = {} can't be written out in this config file format. Use a config_file_parser_class that supports multi-line values, such as YAMLConfigFileParser.z{} = {}
)rr9r
�list�join�map�strrpr�write�getvalue)r2r9�rrZr\�fields      rr:z!DefaultConfigFileParser.serialize�s����J���+�+�-�	4�J�C���%��&��d�i�i��C���8�8�3�>�����E�*��
�c�(�E�*�
���5�=�D�E�M�$�@�AG��s�E�@R�	��
�
�G�G�K�&�&�s�E�2�3�)	4�*�z�z�|�rNr;rrrrRrR�s���:�&�PrrRc�"�eZdZdZd�Zd�Zd�Zy)�ConfigparserConfigFileParserz,parses INI files using pythons configparser.c�
�d}|S)Na�Uses configparser module to parse an INI file which allows multi-line
        values.

        Allowed syntax is that for a ConfigParser with the following options:

            allow_no_value = False,
            inline_comment_prefixes = ("#",)
            strict = True
            empty_lines_in_values = False

        See https://docs.python.org/3/library/configparser.html for details.

        Note: INI file sections names are still treated as comments.
        rrTs  rr3z3ConfigparserConfigFileParser.get_syntax_descriptions��
���
rc	�`�tjdddddd��}	|j|j��t
�}|j�D]�}||j�D]l\}}|jdd�jd	d�}d
|vr<d|vr8|jd
�d}	d
|	vr	tj|�||<�b|||<�h|||<�n��|S#t$r}td|z��d}~wwxYw#ttf$r }tdt|�zdz�|�d}~wwxYw)N)�=�:F)rWrXT)�
delimiters�allow_no_value�comment_prefixes�inline_comment_prefixes�strict�empty_lines_in_values�Couldn't parse config file: %srwr^rxrYrar�{�Error evaluating list: �;. Put quotes around your text if it's meant to be a string.)�configparser�ConfigParser�read_string�readrnrNr�sectionsr9�replacero�ast�literal_evalr�SyntaxErrorr|)
r2r5�configrs�result�section�k�v�multiLine2SingleLine�prelist_strings
          rr6z"ConfigparserConfigFileParser.parse'se���*�*�!� �'�$.��"'�

��	R����v�{�{�}�-�
������(�	5�G��w��-�-�/�
5���1�'(�y�y��s�';�'C�'C�D�#�'N�$��.�.�3�:N�3N�%9�%?�%?��%D�Q�%G�N��.�0�%�(+�(8�(8�9M�(N�F�1�I�%9��q�	� 4�F�1�I�%
5�	5�(�
��3�	R�+�,L�q�,P�Q�Q��	R��!+�K�8�%�";� 9�"%�a�&�!)�"_�!`�#�$%�	%��%�s/�C�5C>�	C;�(C6�6C;�>D-�
D(�(D-c���tjdddd��}d|i}|j|�t�}|j	|�|jd�|j
�S)NF)rWT)r�r�r�r��DEFAULTr)r�r��	read_dictrr}�seekr�)r2r9r�r5s    rr:z&ConfigparserConfigFileParser.serializeOsb���*�*� �$*��"'�	
���E�"�������������V�����A���{�{�}�rNr;rrrr�r�s��6��"&�P
rr�c�*�eZdZdZd�Zd�Zd�Zdd�Zy)�YAMLConfigFileParserzdParses YAML config files. Depends on the PyYAML module.
    https://pypi.python.org/pypi/PyYAML
    c�
�d}|S)NzThe config file uses YAML syntax and must represent a YAML 'mapping' (for details, see http://learn.getgrav.org/advanced/yaml).rrTs  rr3z+YAMLConfigFileParser.get_syntax_descriptionds��
S�	��
rc��	ddl}	ddlm}ddlm}|||fS#t$rtd��wxYw#t$rddlm}ddlm}Y�4wxYw)zjlazy-import PyYAML so that configargparse doesn't have to depend
        on it unless this parser is used.rNzJCould not import yaml. It can be installed by running 'pip install PyYAML')�CSafeLoader)�CDumper)�
SafeLoader)�Dumper)�yaml�ImportErrorrPr�r�r�r�)r2r�r�r�s    r�
_load_yamlzYAMLConfigFileParser._load_yamlks^��	��	$�6�.�
�Z��'�'���	�3�F��
�	���	$�'�#�	$�s��0�-�A�Ac��|j�\}}}	|j||��}t	|t
�s0tdt
|dd��dt|�j�d���t�}|j�D],\}}	t	|	t�r|	||<�|	��t|	�||<�.|S#t$r}td|z��d}~wwxYw)N)�Loaderr�z_The config file doesn't appear to contain 'key: value' pairs (aka. a YAML mapping). yaml.load('rr5z') returned type 'z' instead of 'dict'.)
r��loadrnrNr
�dictrC�typer(rr9ryr|)
r2r5r�r��_�
parsed_objrsr�rZr\s
          rr6zYAMLConfigFileParser.parses���"�o�o�/���j�!�	R����6�*��=�J��*�d�+�+��6�6�8�4�d�:�6F�6O�6O�Q��
����$�*�*�,�	)�J�C���%��&�#��s�����!�%�j��s��
	)��
��)�	R�+�,L�q�,P�Q�Q��	R�s�B4�4	C�=C�Cc�h�|j�\}}}t|�}|j|||��S)N)�default_flow_styler�)r�r��dump)r2r9r�r�r�r�s      rr:zYAMLConfigFileParser.serialize�s7���/�/�+���a���U����y�y��3E�f�y�U�UrN�F)r(r)r*r+r3r�r6r:rrrr�r�_s����(�(�8Vrr�z1(^\"(?:\\.|[^\"\\])*\"$)|(^\'(?:\\.|[^\'\\])*\'$)z�(^\"\"\"(\s+)?(([^\"]|\"([^\"]|\"[^\"]))*(\"\"?)?)?(\s+)?(?:\\.|[^\"\\])?\"\"\"$)|(^\'\'\'(\s+)?(([^\']|\'([^\']|\'[^\']))*(\'\'?)?)?(\s+)?(?:\\.|[^\'\\])?\'\'\'$))�flags�T)�maxsize�typedc��ttj|��xs"|xrttj|��S)zt
    Detect whether a string is a quoted representation.

    :param triple: Also match tripple quoted strings.
    )�bool�_QUOTED_STR_REGEXri�_TRIPLE_QUOTED_STR_REGEX)�text�triples  r�	is_quotedr��s;���!�'�'��-�.���=�4�0�6�6�t�<�=�rc��t||��r+	tj|�}t|t�sJ�	|S|S#t
$r}t
d|�d|���|�d}~wwxYw)a�
    Unquote a maybe quoted string representation.
    If the string is not detected as being a quoted representation, it returns the same string as passed.
    It supports all kinds of python quotes: ``"""``, ``'''``, ``"`` and ``'``.

    :param triple: Also unquote tripple quoted strings.
    :raises ValueError: If the string is detected as beeing quoted but literal_eval() fails to evaluate it as string.
        This would be a bug in the regex.
    �r�z+Error trying to unquote the quoted string: �: N)r�r�r�r
r|rnr)r�r��srss    r�unquote_strr��sq����f�%�	�� � ��&�A��a��%�%�%�
���K���	��=�d�V�2�a�S�I���
��	�s�';�	A�A�Ac��g}tj|gd��D]3}|D],}|jt|j	�d����.�5t|�S)u�
    Parse a TOML section name to a sequence of strings.

    The following names are all valid:

    .. python::

        "a.b.c"            # this is best practice -> returns ("a", "b", "c")
        " d.e.f "          # same as [d.e.f] -> returns ("d", "e", "f")
        " g .  h  . i "    # same as [g.h.i] -> returns ("g", "h", "i")
        ' j . "ʞ" . "l" '  # same as [j."ʞ"."l"], double or simple quotes here are supported. -> returns ("j", "ʞ", "l")
    �.)�	delimiterFr�)�csv�reader�appendr�rf�tuple)�section_namer��row�as    r�parse_toml_section_namer��s]���G��z�z�<�.�C�8�A���	A�A��N�N�;�q�w�w�y��?�@�	A�A���>�rc��t|t�rt|�n|}|j|d�}|sy|dd}|rt	||�St|t
�sy|S)z�
    Given some TOML data (as loaded with toml.load()), returns the requested section of the data.
    Returns ``None`` if the section is not found.
    rNrb)r
r|r��get�get_toml_sectionr�)�datar�r��itemdatas    rr�r�s`��
4>�g�s�3K�&�w�/�QX�H��x�x����$�H������|�H����(�3�3��(�D�)���rc�:��eZdZdZ�fd�Zd�Zd�Zd�Zd�Z�xZ	S)�TomlConfigParsera9
    Create a TOML parser bounded to the list of provided sections.

    Example::

        # this is a comment
        [tool.my-software] # TOML section table.
        # how to specify a key-value pair
        format-string = "restructuredtext" # strings must be quoted
        # how to set an arg which has action="store_true"
        warnings-as-errors = true
        # how to set an arg which has action="count" or type=int
        verbosity = 1
        # how to specify a list arg (eg. arg which has action="append")
        repeatable-option = ["https://docs.python.org/3/objects.inv",
                             "https://twistedmatrix.com/documents/current/api/objects.inv"]
        # how to specify a multiline text:
        multi-line-text = '''
            Lorem ipsum dolor sit amet, consectetur adipiscing elit.
            Vivamus tortor odio, dignissim non ornare non, laoreet quis nunc.
            Maecenas quis dapibus leo, a pellentesque leo.
            '''

    Note that the config file fragment above is also valid for the `IniConfigParser` class and would be parsed the same manner.
    Thought, any valid TOML config file will not be necessarly parsable with `IniConfigParser` (INI files must be rigorously indented whereas TOML files).

    See the `TOML specification <https://toml.io/en/>`_ for details.
    c�0��t�|��||_y)zO
        :param sections: The section names bounded to the new parser.
        N)r@�__init__r�)r2r�rJs  �rr�zTomlConfigParser.__init__1s���	���� ��
rc��|Sr	rr1s rrAzTomlConfigParser.__call__8����rc�
�	ddl}	|j	�}t|t�r|jd�}|j|�}t�}|jD]P}t||�}|s�|j�D],\}	}
t|
t�r|
||	<�|
��t!|
�||	<�.�R|S#t$r&	ddl}n#t$r}td�|�d}~wwxYwY��wxYw#t$r}td|z��d}~wwxYw)z3Parses the keys and values from a TOML config file.rNzUCould not import toml or tomllib. toml can be installed by running 'pip install toml'zutf-8zCouldn't parse TOML file: %s)�tomllibr��tomlrPr�r
�bytes�decodermrnrNrr�r�r9ryr|)r2r5r�rs�contentr�r�r�r�rZr\s           rr6zTomlConfigParser.parse;s!��		�"�	P��k�k�m�G��'�5�)�!�.�.��1���Z�Z��(�F�
����}�}�	1�G�#�F�G�4�D��#'�*�*�,�1�J�C��!�%��.�&+��s�����&)�%�j��s��
1�
	1��
��I�	�
����
�7�J�����
���	�� �	P�+�,J�Q�,N�O�O��	P�sM�B4�AC&�4	C#�>C�C#�	C�C�C�C#�"C#�&	D�/C=�=Dc��	y)NzConfig file syntax is Tom's Obvious, Minimal Language. See https://github.com/toml-lang/toml/blob/v0.5.0/README.md for details.rr1s rr3z'TomlConfigParser.get_syntax_descriptionfs
��
W�	
rc�H�	ddl}|js|j	t|��S|jd}t
|�}i}|}t|dd�D]\}}i||<||}�t|�||d<|j	|�S#t$rtd��wxYw)z�Serialize items to TOML format with section support.

        Note: Requires the 'toml' package for serialization (pip install toml).
        Python 3.11's tomllib only supports reading, not writing.
        rNzXThe 'toml' package is required for TOML serialization. Install it with: pip install tomlrc)r�r�rPr��dumpsr�r�re)	r2r9r�r�r�r��currentrqr�s	         rr:zTomlConfigParser.serializels���	���}�}��:�:�d�5�k�*�*��}�}�Q�'��*�<�8������#�H�S�b�M�2�	'�J�A�w�!�G�G���g�&�G�	'�!%�U��������z�z�&�!�!��/�	�3�4��
�	�s�B�B!�
r(r)r*r+r�rAr6r3r:rKrLs@rr�r�s"����:!��)�V
� "rr�c�:��eZdZdZ�fd�Zd�Zd�Zd�Zd�Z�xZ	S)�IniConfigParsera}
    Create a INI parser bounded to the list of provided sections.
    Optionaly convert multiline strings to list.

    Example (if split_ml_text_to_list=False)::

        # this is a comment
        ; also a comment
        [my-software]
        # how to specify a key-value pair
        format-string: restructuredtext
        # white space are ignored, so name = value same as name=value
        # this is why you can quote strings
        quoted-string = '	hello	mom...  '
        # how to set an arg which has action="store_true"
        warnings-as-errors = true
        # how to set an arg which has action="count" or type=int
        verbosity = 1
        # how to specify a list arg (eg. arg which has action="append")
        repeatable-option = ["https://docs.python.org/3/objects.inv",
                       "https://twistedmatrix.com/documents/current/api/objects.inv"]
        # how to specify a multiline text:
        multi-line-text =
            Lorem ipsum dolor sit amet, consectetur adipiscing elit.
            Vivamus tortor odio, dignissim non ornare non, laoreet quis nunc.
            Maecenas quis dapibus leo, a pellentesque leo.

    Example (if split_ml_text_to_list=True)::

        # the same rules are applicable with the following changes:
        [my-software]
        # how to specify a list arg (eg. arg which has action="append")
        repeatable-option = # Just enter one value per line (the list literal format can also be used)
            https://docs.python.org/3/objects.inv
            https://twistedmatrix.com/documents/current/api/objects.inv
        # how to specify a multiline text (you have to quote it):
        multi-line-text = '''
            Lorem ipsum dolor sit amet, consectetur adipiscing elit.
            Vivamus tortor odio, dignissim non ornare non, laoreet quis nunc.
            Maecenas quis dapibus leo, a pellentesque leo.
            '''
    c�>��t�|��||_||_y)z�
        :param sections: The section names bounded to the new parser.
        :param split_ml_text_to_list: Whether to convert multiline strings to list
        N)r@r�r��split_ml_text_to_list)r2r�r�rJs   �rr�zIniConfigParser.__init__�s���
	���� ��
�%:��"rc��|Sr	rr1s rrAzIniConfigParser.__call__�r�rc	���tj�}	|j|j��t
�}|j�tjgzD]�}||jvr�||j�D]�\}}|j�}|s�|jd�r+|jd�r	tj|�||<�Ut%|�r	t'|�||<�p|j(rCd|j+d�vr0	|j-d�D�	cgc]}	|	s�t'|	���c}	||<��|||<����|S#t$r}td|z��d}~wwxYw#tt f$r }tdt#|�zdz�|�d}~wwxYw#t$r}tt#|��|�d}~wwxYwcc}	w#t$r}tt#|��|�d}~wwxYw)z3Parses the keys and values from an INI config file.zCouldn't parse INI file: %sNrYrar�r�rw)r�r�r�r�rnrNrr��DEFAULTSECTr9rfrgrkr�r�rr�r|r�r�r��rstripro)
r2r5r�rsr�r�r�r��strip_vrqs
          rr6zIniConfigParser.parse�s����*�*�,��	O����v�{�{�}�-�
������(�L�,D�,D�+E�E�%	&�G��d�m�m�+���w��-�-�/�"
&���1��'�'�)�����%�%�c�*�w�/?�/?��/D�!�$'�$4�$4�W�$=��q�	�!��)�K�(3�G�(<�F�1�I�
�3�3�������8N�K�8?�
�
�d�8K�)�34�q��A��)�F�1�I�%&��q�	�E"
&�%	&�L�
��W�	O�+�,I�A�,M�N�N��	O��"'��4�!�7�5�!�!�f�%�[�\�� !�	!��!�� *�K�";�C��F�"C��J��K��)�� *�K�";�C��F�"C��J��K�sw�E�E/�'F!�G�)G�1
G�>G�	E,�E'�'E,�/F�>F�F�!	G�*F?�?G�G�	G/�G*�*G/c�,�d}|jr|dz
}|S)Nz�Uses configparser module to parse an INI file which allows multi-line values. See https://docs.python.org/3/library/configparser.html for details. This parser includes support for quoting strings literal as well as python list syntax evaluation. z{Alternatively lists can be constructed with a plain multiline string, each non-empty line will be converted to a list item.)r�rTs  rr3z&IniConfigParser.get_syntax_description�s/��
r�	�
�%�%��H�
�C��
rc
�b�tj�}|jr|jdnd}|dk7r$|tjk7r|j	|�|j�D]�\}}t
|t�rV|jr-|j||ddjd�|D��z��O|j||t|���l|j||t|����t�}|j|�|jd�|j�S)z3Serialize items to INI format with section support.rr�rwc3�2K�|]}t|����y�wr	)r|)�.0r�s  r�	<genexpr>z,IniConfigParser.serialize.<locals>.<genexpr>s����;R�q�C��F�;R�s�)r�r�r�r��add_sectionr9r
ryr��setrzr|rr}r�r�)r2r9r�r�rZr\r5s       rr:zIniConfigParser.serializes����*�*�,��,0�=�=�t�}�}�Q�'�i���9�$���9Q�9Q�)Q����|�,� �+�+�-�	:�J�C���%��&��-�-��J�J�$�c�4�$�)�)�;R�E�;R�2R�+R��
�J�J�|�S�#�e�*�=��
�
�<��c�%�j�9�	:�������V�����A���{�{�}�rr�rLs@rr�r��s#���)�V;��1�f�rr�c�:��eZdZdZ�fd�Zd�Zd�Zd�Zd�Z�xZ	S)�CompositeConfigParserz�
    Create a config parser composed by other ConfigFileParser instances.

    The composite parser will successively try to parse the file with each parser,
    until it succeeds, else raise exception with all encountered errors.
    c���t�|��|D�cgc]	}|���c}|_d}|jD]F}|st|t�rd}�|s�t|t
�s�,t
jdt���Hycc}w)NFTz�IniConfigParser was found before TomlConfigParser in parsers for CompositeConfigParser. This might lead to a TOML file being parsed as an INI file. Reorder the parsers.)�category)	r@r��parsersr
r�r��warnings�warn�
SyntaxWarning)r2�config_parser_types�p�seen_inirFrJs     �rr�zCompositeConfigParser.__init__/sx���
����=P�/Q����/Q������l�l�
	�F��
�6�?� C�����J�v�/?�@��
�
�B�+�	�
	��0Rs�Bc��|Sr	rr1s rrAzCompositeConfigParser.__call__@r�rc
�L�g}t|j�D]\}}	|j|�cStdd	j!d
�|D������#t$r�}t	|t
�r/t
jd|jj�d|���|j|�|t|j�dz
krM	|jd�n:#ttf$r(td|jj�d|�d��|�wxYwYd}~��d}~wwxYw)NzCannot use parser z without optional dependency: rbrzError parsing config with r�z?. Cannot try additional parsers because stream is not seekable.zError parsing config: rvc3�DK�|]}tt|�����y�wr	)�reprr|)r�rss  rr�z.CompositeConfigParser.parse.<locals>.<genexpr>]s����.L��t�C��F�|�.L�s� )rerr6rnr
rPrrrJr(r�r#r��AttributeError�OSErrorrNrz)r2r5�errorsrqrrss      rr6zCompositeConfigParser.parseCs/�����d�l�l�+�	!�D�A�q�
!��w�w�v��&�	!�.(�$�T�Y�Y�.L�V�.L�%L�$M�N�
�	
��)�
!��a�!B�C��M�M�,�Q�[�[�-A�-A�,B�C0�01�s�4���
�
�a� ��s�4�<�<�(�1�,�,�!����A���*�G�4�!�7�8����9M�9M�8N�b�QR�PS�T\�]�� !�!�!���
!�s0�A�	D#� A+D�C�D�7D�D�D#c	��d�}d}t|j�D]?\}}|d|dz�d||jj��d|j	��d�z
}�A|S)Nc���|j�jd�jdd�jdd�jdd�}|r|j�SdS)Nr�rFr_r��filez??)�lowerrfr��upper)�	classnamerfs  r�guess_format_namezGCompositeConfigParser.get_syntax_description.<locals>.guess_format_nameasS�����!���s�����2�&����2�&�����$�
�%*�5�;�;�=�3�t�3rz2Uses multiple config parser settings (in order): 
rYrbz] r�z 
)rerrJr(r3)r2rrUrqrFs     rr3z,CompositeConfigParser.get_syntax_description`st��	4�D��"�4�<�<�0�	u�I�A�v��Q�q�1�u�g�R� 1�&�2B�2B�2K�2K� L�M�R�PV�Pm�Pm�Po�Op�ps�t�t�C�	u��
rc�l�|jstd��|jdj|�S)z8Serialize items using the first parser in the composite.z.No parsers configured in CompositeConfigParserr)rrNr:r8s  rr:zCompositeConfigParser.serializeps4���|�|�+�@��
��|�|�A��(�(��/�/rr�rLs@rr�r�'s!�����"�
�:� 0rr��command_line�environment_variables�config_file�defaultsc���eZdZdZd�Zd�Zd�Zd�Zdddejfd�Z
dddejdfd	�Zd
�Zd�Z
d�Zd
�Zd�Zd�Zdd�Zd�Zd�Zd�Zd�Zd�Zd�Zej4fd�Zd�Zy)rz�Drop-in replacement for `argparse.ArgumentParser` that adds support for
    environment variables and ``.ini`` or ``.yaml-style`` config files.
    c���|jdd�}|jdd�}|jdd�}|jdg�}|jdd�}|jd	t�}|jd
g�}	|jdd�}
|jdd
�}|jdg�}|jdd�}
|jdt�}d|fd
|	fd|ffD]E\}}t|tt
f�r�t|t�rd|znd}t|�d|�d|����t|�D]F\}}t|tttjf�r�,t|�r�8td||fz��t|�std|����||_
||_||_||_d|vrU|d}t|t"�r@t%|t&j(�s&d|�d�}t%|t*�r|dz
}t|��t'j,j.|g|��i|��|�t�|_nTt|t*�r||_n<t|t"�rt%|t*�r
|�|_ntd|�d���||_||_|	r|j6|	d|
|dd��|r|j6|d d!|
dd"��t8j:d#krd|_yy)$a�Supports args of the `argparse.ArgumentParser` constructor
        as \*\*kwargs, as well as the following additional args.

        Keyword Arguments:
            add_config_file_help: Whether to add a description of config file
                syntax to the help message.
            add_env_var_help: Whether to add something to the help message for
                args that can be set through environment variables.
            auto_env_var_prefix: If set to a string instead of None, all config-
                file-settable options will become also settable via environment
                variables whose names are this prefix followed by the config
                file key, all in upper case. (eg. setting this to ``foo_`` will
                allow an arg like ``--my-arg`` to also be set via the FOO_MY_ARG
                environment variable)
            default_config_files: When specified, this list of config files will
                be parsed in order, with the values from each config file
                taking precedence over previous ones. This allows an application
                to look for config files in multiple standard locations such as
                the install directory, home directory, and/or current directory.
                Also, shell \* syntax can be used to specify all conf files in a
                directory. For example::

                    ["/etc/conf/app_config.ini",
                    "/etc/conf/conf-enabled/*.ini",
                    "~/.my_app_config.ini",
                    "./app_config.txt"]

                Path entries may be strings, ``os.PathLike`` objects (e.g.
                ``pathlib.Path``), or zero-argument callable functions that
                return an open file-like object containing config file
                contents. Any provided callable is invoked each time the parser opens
                config files, and the returned stream is closed by the parser
                after parsing. The callable must return a stream. This is useful
                for sourcing config from non-filesystem locations such as in-memory
                buffers, secrets managers, or HTTP responses.
            ignore_unknown_config_file_keys: If true, settings that are found
                in a config file but don't correspond to any defined
                configargparse args will be ignored. If false, they will be
                processed and appended to the commandline like other args, and
                can be retrieved using parse_known_args() instead of parse_args()
            config_file_open_func: function used to open a config file for reading
                or writing. Needs to return a file-like object.
            config_file_parser_class: configargparse.ConfigFileParser subclass
                which determines the config file format. configargparse comes
                with DefaultConfigFileParser and YAMLConfigFileParser.
            args_for_setting_config_path: A list of one or more command line
                args to be used for specifying the config file path
                (eg. ["-c", "--config-file"]). Default: []
            config_arg_is_required: When args_for_setting_config_path is set,
                set this to True to always require users to provide a config path.
            config_arg_help_message: the help message to use for the
                args listed in args_for_setting_config_path.
            args_for_writing_out_config_file: A list of one or more command line
                args to use for specifying a config file output path. If
                provided, these args cause configargparse to write out a config
                file with settings based on the other provided commandline args,
                environment variants and defaults, and then to exit.
                (eg. ["-w", "--write-out-config-file"]). Default: []
                These args can only be set on the command line. A config file
                key that names one is an error, and they can't have an env_var,
                since either would let whoever controls those overwrite an
                arbitrary file.
            write_out_config_file_arg_help_message: The help message to use for
                the args in args_for_writing_out_config_file.
        �add_config_file_helpT�add_env_var_help�auto_env_var_prefixN�default_config_files�ignore_unknown_config_file_keysF�config_file_parser_class�args_for_setting_config_path�config_arg_is_required�config_arg_help_messagezconfig file path� args_for_writing_out_config_file�&write_out_config_file_arg_help_messagezftakes the current command line args and writes them out to a config file at the given path, then exits�config_file_open_funcz (e.g. ['%s'])r_z must be a listz. Got: z�default_config_files[%d] must be a string, bytes, or os.PathLike path, or a callable that returns an open file-like object. Got: %rz-config_file_open_func must be callable. Got: rzCformatter_class must be a subclass of argparse.HelpFormatter. Got: r�z3 Perhaps you meant to use config_file_parser_class?z�config_file_parser_class must be a subclass of ConfigFileParser (such as DefaultConfigFileParser, YAMLConfigFileParser, etc.). Got: z+. Perhaps you meant to use formatter_class?r)rD�required�help�is_config_file_arg�"write_out_config_file_to_this_path�CONFIG_OUTPUT_PATH)rD�metavarr)�is_write_out_config_file_argr)�poprR�openr
ryr�r|�	TypeErrorrer��os�PathLike�callable�_config_file_open_func�_add_config_file_help�_add_env_var_help�_auto_env_var_prefixr��
issubclassr�
HelpFormatterr-rr��_config_file_parser�_default_config_files� _ignore_unknown_config_file_keys�add_argument�sys�version_info�
exit_on_error)r2�argsr rrrrr r!r"r#r$r%r&r'rr\�hintrq�entry�fcrUs                      rr�zArgumentParser.__init__�sM��J &�z�z�*@�$�G��!�:�:�&8�$�?��$�j�j�)>��E��%�z�z�*@�"�E��*0�*�*�-�u�+
�'�$*�:�:�&�(?�$
� �(.�z�z�2P�RT�'U�$�!'���,D�e�!L��"(�*�*�%�'9�#
��,2�:�:�.��,
�(�28���4�
%�2
�.�!'�
�
�+B�D� I��$�%9�:�
+�-I�J�
/�1Q�R�
�	V�K�D�%�
�e�d�E�]�3�3=�e�S�3I�'�%�/�r���$��e� T�U�U�	V�"�"6�7�	�H�A�u��u�s�E�2�;�;�&?�@�H�U�O��0�34�e�*�=���	��-�.��(�+��
�
'<��#�%9��"�!1���$7��!���&��)�*�B��"�d�#�J�r�8�;Q�;Q�,R�;=�?���b�"2�3��P�P�C���n�$����(�(��?��?��?�$�+�'>�'@�D�$�
�0�2B�
C�'?�D�$�
�0�$�
7�J�$�&6�=
�(@�'A�D�$��
,�	.��
�&:��"�0O��-�'��D���-�"�/�,�#'�
�,��D���1�9�,�;�-1�
����f�$�!%�D��%rc�(�d|vr|jd�S|j|�}|�|Sd}t|�D]-\}}|jt	|j
��s�+|}n|�|St
d�|jD��ryt|�S)aZFind the right index to insert config/env var args into the command line.

        Inserts before the ``--`` separator if present, before a subparser
        command so the parent parser sees injected args first, before the
        first optional arg, or at position 0 when a REMAINDER positional
        exists. Falls back to appending.
        �--Nc3�rK�|]/}|jxr|jtjk(���1y�wr	)�is_positional_arg�nargsr�	REMAINDER�r�r�s  rr�z7ArgumentParser._find_insertion_index.<locals>.<genexpr>Ts2����
�FG�A���A�A�G�G�x�/A�/A�$A�A�
�s�57r)	�index�_find_subcommand_indexrergr��prefix_chars�any�_actionsr#)r2rB�subcmd_index�	first_optrq�args      r�_find_insertion_indexz$ArgumentParser._find_insertion_index<s����4�<��:�:�d�#�#��2�2�4�8���#����	���o�	�F�A�s��~�~�e�D�$5�$5�6�7��	��	�� ����
�KO�=�=�
�
���4�y�rc���|jD]R}t|tj�s�|js�+t|�D]\}}||jvs�|ccSyy)z�Find where the subcommand is on the command line, if there is one.

        Args:
            args: the command line args.

        Returns:
            int or None: the index of the first arg naming a subcommand
        N)rQr
r�_SubParsersAction�choicesre)r2rBrrq�
arg_strings     rrNz%ArgumentParser._find_subcommand_index[s_���m�m�	�F��&�(�"<�"<�=�&�.�.�%.�t�_�!�M�A�z�!�V�^�^�3� ��!��	�rc��t|j�}|jD]6}||jvs�|jD]}||us�||jz
}��8|S)a�Find the option strings that, when already on the command line, mean
        an env var or config file value for the given action should be dropped.

        These are the action's own option strings plus those of every other
        action in the same mutually exclusive group, mirroring the conflicts
        argparse checks for. Without the latter, a config file value for one
        member of a group would clash with a different member given on the
        command line instead of being overridden by it (see issue #164).

        Args:
            action: the argparse.Action to find overriding option strings for.

        Returns:
            list[str]: the option strings
        )ry�option_strings�_mutually_exclusive_groups�_group_actions)r2rr[rj�other_actions     r�_option_strings_that_overridez,ArgumentParser._option_strings_that_overridemsp�� �f�3�3�4���4�4�	F�E���-�-�-�$)�$8�$8�F�L�#�6�1�&�,�*E�*E�E��F�	F�
�rNc��|j||||d��\}}|r?ddj|�z}|jr|j|�|St	d|��|S)a�Supports all the same args as the `argparse.ArgumentParser.parse_args()`,
        as well as the following additional args.

        Arguments:
            args: a list of args as in argparse, or a string (eg. "-x -y bla")
            config_file_contents: String. Used for testing.
            env_vars: Dictionary. Used for testing.

        Returns:
            argparse.Namespace: namespace
        F)rBrG�config_file_contents�env_vars�ignore_help_argszunrecognized arguments: %sr^N)�parse_known_argsrzrA�error�
ArgumentError)r2rBrGrarb�argvrUs       r�
parse_argszArgumentParser.parse_args�sr���*�*���!5��"�+�
�
��d��.����$��?�C��!�!��
�
�3����$�D�#�.�.��rFc	��|�tjdd}n,t|t�r|j	�}nt|�}|jD]}|j|_�|r|D�cgc]	}|dvs�|��}}t�|_
|r"dt|�f}d|i|jt<|j��|jD]�}|j|�}	|	s�|jr�$|jr�1|jr�>|j r�Kt|t"j$�r�ft|t"j&�r��|	dj)|j*�}
|j|
zj-dd�j/�|_��g}|jD�cgc]P}|jsB|jr6|j|vr(t1||j3|�|j*�s|��R}}|D]�}
|
j}||}|dk(r
|
j4r�&|
j4st|
t"j6�r8|j9d�r'|j;d	�r	t=j>|�}||jC|
||�z
}��|jE|�}|jG|d|jI��r|d||z||dz}|rEt|D�cgc]}|j|||jff��!c}�|jtJ<tMd
�|jD��}|xr
d|vxsd|v}|jD�
�cic]}
|j|
�D]}||
���}}
}g}|�tO|�}d|_(|dfg}n|s|jS|�}	tU|�D�]Y\}}	|jVjY|�}g}j_�D]�\}}||vr,||}
t1||j3|
�|j*�}n7d}
|j`xs't1||jc|�g|j*�}|dk(r|
r
|
j4r��|r��||jC|
||�z
}td�d|��}||jvrt�|j|<|
|f|j||<��|jE|�}|jG|d|z|jI��s��L|d||z||dz}��\	|D]"\}}	tg|d�r|ji��$	t�}|jD]�}
|
jxs|
j4tjtlfv} t1||
j|j*�s1| r/|
jn�#|
jntpk(st|
tr�r�}|
jr|
jd
}n|
jt}|
t|
jn�f||<��|r||jtv<t�|_<t"jzj}|||��\}}!|jxj�D�"cgc]}"|"�|"��}#}"|j�||#d��||!fScc}wcc}w#t@$r9|dd
j	d�D�cgc]}|j)���ncc}w}}Y��hwxYwcc}wcc}}
w#tZ$r%}|j]t|��Yd}~��Gd}~wwxYw#t@$rY��wxYw#|D]1\}}	tg|d�r|ji��$#t@$rY�/wxYwwxYwcc}"w)a�Supports all the same args as the `argparse.ArgumentParser.parse_args()`,
        as well as the following additional args.

        Arguments:
            args: a list of args as in argparse, or a string (eg. "-x -y bla")
            config_file_contents (str). Used for testing.
            env_vars (dict). Used for testing.
            ignore_help_args (bool): This flag determines behavior when user specifies ``--help`` or ``-h``. If False,
                it will have the default behavior - printing help and exiting. If True, it won't do either.

        Returns:
            tuple[argparse.Namespace, list[str]]: tuple namescpace, unknown_args
        Nrb)�-h�--helpr_r�-r�rYrarcrdzin an environment variablec3�VK�|]!}t|tj�s�|���#y�wr	)r
r�_HelpActionrLs  rr�z2ArgumentParser.parse_known_args.<locals>.<genexpr>s$���� 
��
�1�h�6J�6J�(K�A� 
�s�)�)rjrkz
method arg�|zin a config file (%s)�close)rBrGT)�
exit_after)Ar?rgr
r|roryrQr[rIr�_source_to_settings�_COMMAND_LINE_SOURCE_KEYr8�get_possible_config_keys�env_varr*r.r�_VersionActionrnrfrOr�r�already_on_command_liner_rJ�
_AppendActionrgrkrlrmrn� convert_item_to_command_line_argrU�"_reject_write_out_config_file_args�_reachable_parsers�_ENV_VAR_SOURCE_KEYrPrr�_open_config_files�reversedr;r6rNrer9r=�4get_command_line_key_for_unknown_config_file_setting�_CONFIG_FILE_SOURCE_KEYrBrp�OPTIONAL�ZERO_OR_MOREr�SUPPRESS�#ACTION_TYPES_THAT_DONT_NEED_A_VALUErD�_DEFAULTS_SOURCE_KEYr?rrdrH�write_config_file)$r2rBrGrarbrcr�rT�a_v_pair�config_file_keys�stripped_config_file_key�env_var_args�actions_with_env_var_valuesrrZr\rt�idx�supports_help_arg�skip_config_file_parsing�
config_key�known_config_keys�config_streamsr5�source_label�config_itemsrs�config_args�discard_this_key�
source_keyr��default_settings�cares_about_default_value�unknown_args�path�output_file_pathss$                                    rrdzArgumentParser.parse_known_args�s���*�<��8�8�A�B�<�D�
��c�
"��:�:�<�D���:�D����	7�A�&'�&6�&6�"6�A��	7��#'�G�C�3�6F�+F�C�G�D�G�$/�=�� ���d�4�j�)�H�BD�h��D�$�$�%=�>��$�$�0��]�]�
��#'�#@�#@��#C� �#��I�I��*�*��+�+��5�5�!�!�X�%<�%<�=�!�!�X�%9�%9�:�/?��/B�/H�/H��)�)�0�,��2�2�5M�M� ���c�*�����I�
�(���]�]�	'
���&�&��	�	��	�	�X�%�+��d�8�8��;�T�=N�=N��
�	'
�#�	'
�2�	V�F��.�.�C��S�M�E���{�v�|�|���|�|�z�&�(�2H�2H�I��#�#�C�(�U�^�^�C�-@�R� $�
�
�5� 1��
�D�A�A�&�#�u�U�U�L�!	V�$�(�(��.���2�2��6��8O�8O�8Q�
����:��,�t�C�D�z�9�D��<G�9����Y�Y��H�Q�Y�Y�$7� 8�9��=�D�$�$�%8�9� � 
��}�}� 
�
��$5�$
��D�L�,�H��,�	!��-�-�
��"�;�;�F�C�
��
���
��
��
����+��2�3�F�&�F�K�%�|�4�5�N�)�!�4�4�T�:�N�A	�(0��(@�6
A�$���'�#'�#;�#;�#A�#A�&�#I�L�
!��".�"4�"4�"6�&T�J�C���/�/�!2�3�!7��+B� � �>�>�v�F� �-�-�,�(�"&�� �A�A�	�6� $�$(�$]�$]�(+�%&�!"�
!%� 1� 1� �)���{�v�&�,�,� �+�#�t�'L�'L�"�C��(���4�(�&�
�&�T�-E�-E�E�CN�=�D�4�4�Z�@�EK�U�O��0�0��<�S�A�M&T�P�0�0��6���:�:��+�l�:��+�+�-��
 ���:��3�d�3�4�j�@�D�m6
A�v,�
�	�����v�w�/������
�'�=���m�m�	F�F��,�,�,�X�����<�@X�0X�
&�(��f�.C�.C�T�EV�EV�W�0��>�>�)��>�>�X�-��f�&I�J���(�(� �/�/��3�C� �+�+�C�)/��V�^�^�1D�(E� ��%�#	F�&�=M�D�$�$�%9�:�-8�M��)�"*�"9�"9�"J�"J��t�y�#K�#
��	�<�
�9�9�@�@�B�
����
�
��
�	
���y�*;���M��,�&�&��_H��D	'
��.%�R�:?��"�+�:K�:K�C�:P� Q�$����� Q�� Q�� Q�R����
��(1�'��J�J�s�1�v�&�&��'��x!�����	,�
�	�����v�w�/������ �����	
��H
s��,	Z$�6Z$�*AZ)�2Z.�*$[3� [8�2\?�[>� B\?�6B\?�	\?�$\/�?]:�.[0�
[%�$[0�/[0�>	\,�\'�!\?�'\,�,\?�/	\<�;\<�?	]7�	]&�%]7�&	]2	�/]7�1]2	�2]7c��|jS)ar
        If called after `parse_args()` or `parse_known_args()`, returns a dict that contains up to 4 keys corresponding
        to where a given option's value is coming from:
        - "command_line"
        - "environment_variables"
        - "config_file"
        - "defaults"
        Each such key, will be mapped to another dictionary containing the options set via that method. Here the key
        will be the option name, and the value will be a 2-tuple of the form (`argparse.Action` obj, `str` value).

        Returns:
            dict[str, dict[str, tuple[argparse.Action, str]]]: source to settings dict
        )rrr1s r�get_source_to_settings_dictz*ArgumentParser.get_source_to_settings_dict�s���'�'�'rc�,���j|�sydj�fd�|D��}|D]b}�j||�r+�j|j	dd�d�d|���y|s�C|d|vs�K�j|�d	|�d
��yy)a�Reject synthesized command line args that set a write-out-config-file arg.

        Config file entries and environment variables are turned into command
        line args and then parsed like any others, so either one's key or its
        value can end up naming an arg. A write-out-config-file arg overwrites
        the path it is given and then exits the program, so only the real
        command line may set one: otherwise whoever controls a config file the
        program reads could destroy an arbitrary file without the user passing
        any args at all. (This is also why get_possible_config_keys() keeps
        these args out of the keys a config file can set.)

        These args are checked against every parser reachable from this one,
        not just the one that looks like it will parse them. Which subcommand
        runs can't be told from the args: an option's value reads exactly like
        a subcommand name, and the synthesized args can name a subcommand
        themselves. So a config file may not name a write-out arg anywhere in
        the parser tree, which costs an error on a key named after one on a
        subcommand that wasn't going to run.

        Args:
            synthesized_args: command line args built from a config file or from
                environment variables, before they are added to the real ones.
            source_description: where they came from, for the error message.
            parsers: the parsers that could end up parsing them.

        Returns:
            bool: whether the args may be used. error() is meant to stop the
            program, but a program can override exit(), so this says so rather
            than counting on the call not returning.
        Tr_c3�r�K�|].}�jt|��r|jxsd���0y�w)r_N)�_write_out_config_file_args�_subparsers_of�fromfile_prefix_chars)r�rFr2s  �rr�zDArgumentParser._reject_write_out_config_file_args.<locals>.<genexpr>�s:�����(
���/�/��v�0F�G�
�(�(�.�B�.�(
�s�47r�rbrz* can only be set on the command line, not Fz can't be used z3, since it would read command line args from a file)r�rz�"_names_a_write_out_config_file_argrero)r2�synthesized_args�source_descriptionrr�rYs`     rrzz1ArgumentParser._reject_write_out_config_file_args�s����B�/�/��8��!#���(
�!�(
�!
��+�	�J��6�6�z�7�K��
�
�!�'�'��Q�/��2�4F�H����j��m�/D�D��
�
�%/�1C�E���	�"rc�N���t��fd��j|�D��S)a"Check whether a command line arg would set a write-out-config-file arg.

        Args:
            arg_string: a single command line arg.
            parsers: the parsers that could end up parsing it.

        Returns:
            bool: whether it names a write-out-config-file arg
        c3��K�|]6\}}|jD]"}t|d�j��|����$�8y�w)�_could_set_optionN)r[rCr�)r�rFrrIrYr2s    ��rr�zDArgumentParser._names_a_write_out_config_file_arg.<locals>.<genexpr>�sY�����
����!'�!6�!6�
��	
I�G�F�/��1G�1G�H��M�
�
�
�
�s�<?)rPr�)r2rYrs`` rr�z1ArgumentParser._names_a_write_out_config_file_arg�s,����
�#'�"B�"B�7�"K�

�
�	
rc��t|�S)a%Find this parser and every subparser these args could be handed to.

        A subparser is given the args this parser has put together and treats
        them as its own command line, and argparse parses it into this parser's
        namespace, so both what a subparser accepts and what it stores matter
        here. Subparsers that aren't ConfigArgParse parsers are walked through
        as well, since one of them can hold a subparser that is.

        Returns:
            list[argparse.ArgumentParser]: this parser and its subparsers
        )r�r1s rr{z!ArgumentParser._reachable_parsers�s���d�#�#rc
�r�|D��cgc]$}|jD]}t|dd�r||f���&c}}Scc}}w)a`Find the write-out-config-file args the given parsers define.

        Args:
            parsers: the parsers to look in.

        Returns:
            list: each such arg as an ``(argparse.ArgumentParser,
            argparse.Action)`` pair, since it's the parser an arg belongs to
            that decides which command line args can set it.
        r.F)rQrC)r2rrFrs    rr�z*ArgumentParser._write_out_config_file_argssO��"�
�� �/�/�
���v�=�u�E��V��
��
�	
��
s�)3c�����|k(ry�dk(ryt��dks�d�jvry�d�jv}�jdd�d}|r|n�}||k(s||k(ry�jj	|�jj	|��}|�|st|d	d�dk7ry|r�jxr|j|�S|j|�ryt|�dk7ry|�d�vr�jdd�dn�dd}|j|d�}|d
k(ryt��fd�|d|D��S)a�Check whether a command line arg could set the given option.

        This covers every form argparse accepts: the option on its own, with its
        value attached after an ``=`` (or, for a short option, straight after
        it), bundled with other short options, and abbreviated. Where argparse
        would need to look at the rest of the command line to decide, this says
        yes, since it is used to reject args that must not reach an option at
        all, and being wrong in that direction only costs an error message.

        Args:
            arg_string: a single command line arg.
            option_string: an option string of the option to look for.

        Returns:
            bool: whether the arg could set the option
        TrGF�rrbr�NrJrcc3��K�|]8}|dk7r1t�jj�d|z�dd�dk(���:y�w)r�rrJN)rC�_option_string_actionsr�)r��crYr2s  ��rr�z3ArgumentParser._could_set_option.<locals>.<genexpr>esN�����
���C�x�
�D�/�/�3�3�J�q�M�A�4E�F��QU�V��
�
�s�>A)
r#rOror�r�rC�allow_abbrevrg�find�all)	r2rYrI�is_long_option�bare_keyrZ�matched_action�bundledrMs	``       rr�z ArgumentParser._could_set_options����"��&�������z�?�Q��*�Q�-�t�7H�7H�"H��$�A��$�*;�*;�;���#�#�C��+�A�.��(�h�j���}�$��}�(<���4�4�8�8��d�1�1�5�5�c�:�
���%��g�n�g�t�D��I����$�$�F��)A�)A�#�)F�F��#�#�H�-�
��}���"���)�c�Z�.?�
���S�!�$�Q�'��A�B��	�
���]�1�-�.���B�;���
��V�e�_�
�
�	
rc��|r�|j|j|�}|jj|�}|D]/}	|j	|d�5}|j|�ddd��1tddj|�z�|r|jd�yyy#1swY�>xYw#t$r }tdj||���d}~wwxYw)a4Write the given settings to output files.

        Args:
            parsed_namespace: namespace object created within parse_known_args()
            output_file_paths: any number of file paths to write the config to
            exit_after: whether to exit the program after writing the config files
        �wNz Couldn't open {} for writing: {}zWrote config file to rvr)� get_items_for_config_file_outputrrr;r:r5r}�IOErrorrrp�printrz�exit)	r2�parsed_namespacer�rqr��
file_contents�output_file_path�output_filerss	         rr�z ArgumentParser.write_config_filels����
 �@�@��(�(�*:��L�!�4�4�>�>�|�L�M�$5�	
� ���4�4�(�#��9�$�#�)�)�-�8�9��	
�
�)�D�I�I�6G�,H�H�I���	�	�!���+�9�9����$�:�A�A�BR�TU�V�����s0�B-�B!�$B-�!B*	�&B-�-	C�6C�Cc�f�|j|j�}|jddz|z}|S)aMCompute a commandline arg key to be used for a config file setting
        that doesn't correspond to any defined configargparse arg (and so
        doesn't have a user-specified commandline arg key).

        Args:
            key: The config file key that was being set.

        Returns:
            str: command line key
        rr�)rfrO)r2rZ�key_without_prefix_chars�command_line_keys    rrzCArgumentParser.get_command_line_key_for_unknown_config_file_setting�s;��$'�9�9�T�->�->�#?� ��,�,�Q�/�!�3�6N�N���rc��t�}|j�D�]�\}}|tk(r�|d\}}|jD]�}|j	|�}	|	s�|j
r�$t
||j|j�s�Ft||jd�}
|
��`t|
t�rt|
�j�}
|
||	d<����|tk(rS|j�D]>\}\}}
|j	|�}	|	s�t||jd�}
|
��7|
||	d<�@��|j!t"�r"|j�D]
\}\}}
|
||<���K|t$k(s��V|j�D]>\}\}}
|j	|�}	|	s�t||jd�}
|
��7|
||	d<�@���|S)a�Converts the given settings back to a dictionary that can be passed
        to ConfigFormatParser.serialize(..).

        Args:
            source_to_settings: the dictionary described in parse_known_args()
            parsed_namespace: namespace object created within parse_known_args()
        Returns:
            OrderedDict: where keys are strings and values are either strings
            or lists
        r_Nr)rr9rsrQrtrIrwr[rOrCrDr
r�r|rr|rgr�r�)r2�source_to_settingsr��config_file_items�source�settingsr��existing_command_line_argsrr�r\rZs            rr�z/ArgumentParser.get_items_for_config_file_output�s���(�M�� 2� 8� 8� :�$	K��F�H��1�1�08���-��-�"�m�m�K�F�'+�'D�'D�V�'L�$�(� &� 8� 8�3�6�"�1�1� �-�-��!(�(8�&�+�+�t� L�� �,�)�%��6�(+�E�
�(8�(8�(:��EJ�-�.>�q�.A�B�K�"�.�.�,4�N�N�,<�K�(�C��&�%�'+�'D�'D�V�'L�$�'� '�(8�&�+�+�t� L�� �,�EJ�-�.>�q�.A�B�K��"�"�#:�;�,4�N�N�,<�3�(�C��&�%�-2�%�c�*�3��/�/�,4�N�N�,<�K�(�C��&�%�'+�'D�'D�V�'L�$�'� '�(8�&�+�+�t� L�� �,�EJ�-�.>�q�.A�B�K�?$	K�J!� rc�l�g}|�|j|�}nt|�s|jd}|��t|t�r�t|t
�sJd��|j
�dvr>t|�s|j�|S|j|jd�|S|j
�dvr.t|�s	|S|j|jd�|St|tj�r!||jdgt|�zz
}|S|jd|�d	|�d
��|St|t��r|duxr;|jdvxs+t|jt�xr|jdkD}|�t|tj�rm|D]f}|rCt|t�r3|j�|D]}|jt|����H|j�dt|�����h|S|r4|j�|D]}|jt|���|S|j|�d
|�d��|St|t
�r|j�d|���|Stdj!t#|�|���)a�Converts a config file or env var key + value to a list of
        commandline args to append to the commandline.

        Args:
            action: The argparse Action object for this setting, or None if this
                config file setting doesn't correspond to any defined
                configargparse arg.
            key: string (config file key or env var name)
            value: parsed value of type string or list

        Returns:
            list[str]: args
        NrczCconfig parser should convert anything that is not a list to string.)r`�yes�on�1r)�false�no�off�0rbzUnexpected value for z: 'zB'. Expecting 'true', 'false', 'yes', 'no', 'on', 'off', '1' or '0')�+�*r�z can't be set to a list 'zS' unless its action type is changed to 'append' or nargs is set to '*', '+', or > 1z&Unexpected value type {} for value: {})r�is_boolean_optional_actionr[r
r�r|rr�r�_CountAction�intreryrJrxrrpr�)	r2rrZr\rBr��accepts_list_and_has_nargs�	list_elem�sub_elems	         rryz/ArgumentParser.convert_item_to_command_line_arg�s������>��I�I�#�N�
�.�f�5�#)�#8�#8��#<� ���*��7�#
���s��
U�T�
U���{�{�}� :�:�1�&�9��K�K� 0�1�t��o�K�K�� 5� 5�a� 8�9�n��m����"=�=�1�&�9��f��a�K�K�� 5� 5�a� 8�9�`��_�F�H�$9�$9�:���.�.�q�1�2�S��Z�?�?��Z��W�
�
�GJ�E�S��V��O��t�
$�*0�t�);�*����
�*�H��v�|�|�S�1�F�f�l�l�Q�6F�
'�
�~��F�H�4J�4J�!K�!&�R�I�1�j��D�6Q����$4�5�(1�7�H� �K�K��H�
�6�7����/?��Y��$P�Q�
R�4��',����,�-�!&�0�I��K�K��I��/�0�"���
�
�
�E�	#������s�
#��K�K�#3�U�;�<���	�8�?�?��U��U�S��
rc���g}t|dd�r|S|jD]+�t�fd�|jD��s�"|�dd�gz
}�-|S)aThis method decides which actions can be set in a config file and
        what their keys will be. It returns a list of 0 or more config keys that
        can be used to set the given action's value in a config file.

        Returns:
            list[str]: keys
        r.Nc3�F�K�|]}�jd|z����y�w)r�N)rg)r�r�rTs  �rr�z:ArgumentParser.get_possible_config_keys.<locals>.<genexpr>;s�����D�Q�3�>�>�!�a�%�(�D�s�!r�)rCr[rPrO)r2r�keysrTs   @rrtz'ArgumentParser.get_possible_config_keys,sb������6�9�4�@��K��(�(�	'�C��D�$�2C�2C�D�D���Q�R��#��&��	'��rc
���g}	t|j�D�]\}}t|ttj
f�rmt
jtjjt	j|���D]$}|j|j|�|f��&��t|dt|��}	|�}|�t!d|�d���t#|d�r
t|dd�nd}	d|	xs||fz}
|j||
f�t#|d�r��
	|
|_��|j&D�cgc]}t|d	d
�s�|��}}|s|S|D]�}
t)j*|j,d
��}|j/|
�d�}t1j2||�|_|j7|�
�\}}t||
j8d�}|s��tjj|�}	|j|�}|j|f���|S#t$r}td|�d|���|�d}~wwxYw#t$r}td|�d|���|�d}~wwxYwcc}w#t$r*}|j5d|�dt|����Yd}~��d}~wwxYw#t:$r8|D]1\}}	t#|d�r|j=��$#t$rY�/wxYw�wxYw)a�Tries to parse config file path(s) from within command_line_args.
        Returns a list of opened config files, including files specified on the
        commandline as well as any default_config_files specified in the
        constructor that are present on disk.

        Args:
            command_line_args: List of all args

        Returns:
            list[tuple[io.IOBase, str]]: list of ``(stream, source_label)``
            pairs. The ``source_label`` is unique per entry (file path for
            path entries; ``"<entry_label>[<index>]"`` for callable entries),
            so different entries cannot collapse into a single source key in
            ``format_values()``.
        r(zdefault_config_files entry z raised while being called: Nz5 returned None; must return an open file-like object.rz%s[%d]z; returned a stream whose .name attribute could not be set: r*F)rO�add_helpc��yr	r)r2�messages  r�error_methodz7ArgumentParser._open_config_files.<locals>.error_method�s��r)rBzUnable to open config file: z	. Error: rp)rer<r
r|r2r3�globr��
expanduser�fspathr�r5rCr
rnrNr1rBrrQrrrO�_add_action�types�
MethodTypererdrD�
BaseExceptionrp)r2�command_line_args�config_filesrqrD�f�entry_labelr5rs�display_namer�r��user_config_file_arg_actionsr�
arg_parserr�rGr��user_config_file�cfs                    rr}z!ArgumentParser._open_config_files@s/��"��k	�%�d�&@�&@�A�-
%���5��e�c�2�;�;�%7�8�"�Y�Y�r�w�w�'9�'9�"�)�)�E�:J�'K�L�Q��$�+�+�T�-H�-H��-K�Q�,O�P�Q�#*�%��T�%�[�"I�K�!�!&����~�'�GR�U���#�6�6�2� ����5�!�!�
$,�|�/J�{�A�.N�#N�L�!�'�'���(>�?�"�6�6�2�%�*6�F�K�O-
%�d �=�=�,��G�A�7K�U�,S��,�(�,�0�#�#�6�"
@��&�4�4�!%�!2�!2�U��
��&�&�v�.�
�$)�#3�#3�L�*�#M�
� � *�:�:�@Q�:�R��	�1�#*�9�f�k�k�4�#H� �'��$&�7�7�#5�#5�6F�#G� ��!�8�8�9I�J�F��#�#�V�-=�$>�?�E"
@�H ���a%�!�7�,7��<�� !�!��!��8 )�%�";�.9�!�!=�#�$%�	%��%��,��F!���J�J�+�S��V�5�������
	�&�
���A���r�7�+����
�� �����	
�
�
	�s��B?J&�H%�AJ&�$I�+J&�<I+�I+�J&�B#J&�=I0�J&�%	I�.I�I�J&�	I(�I#�#I(�(J&�0	J#�9 J�J&�J#�#J&�&K'�8K�K'�	K!�K'� K!�!K'c�X�tdtdtdtdi}t	�}|j
j
�D]�\}}|jdd�}||dt|dd�z}|j|�|j
�D]�\}\}}|r%|jd	j|d
z|���0t|t�r|jd|z��Ut|t�s�f|jddj|�z�����|j�S)
z�Returns a string with all args and settings and where they came from
        (eg. commandline, config file, environment variable or default)

        Returns:
            str: source to settings string
        zCommand Line Args: zEnvironment Variables:
zConfig File (%s):
z
Defaults:
rorbrNz  {:<19}{}
r�z  %s
r^)rsr|r�r�rrrr9ror�r}rpr
r|ryrzr~)r2�source_key_to_display_value_maprr�r�rZrr\s        r�
format_valueszArgumentParser.format_values�s��
%�&;��!;�#�%:� �-�	+
�'�
�J���
%�
%�
+�
+�
-�	<�
����\�\�#�q�)�F�4�V�A�Y�?�%��q�r�
�BS�S�F�
�G�G�F�O�(0���(8�
<�$��_�f�e���G�G�N�1�1�#��)�U�C�D�!�%��-�����5� 0�1�#�E�4�0�����3�8�8�E�?� :�;�
<�	<� �z�z�|�rc�B�|j|j��y)zBPrints the format_values() string (to sys.stdout or another file).N)r}r�)r2rs  r�print_valueszArgumentParser.print_values�s���
�
�4�%�%�'�(rc�f��d}d}d}|j�rJ|j}d|jdz}|jD��cgc]O}|jD]>}|j|�r+|jdk(s|js|js||f��@�Q}}}|jD�cgc]}t|dd�s�|��}	}|r�|s|	r�d|_d}|d|zz
}d	jd
�|	D��}
|
rd|
z}
|s|
rEd��t�fd
�|D��}|dd	j|ttd|
g��z�zz
}|d|jj�zz
}|jr�|jD�cgc]}t|dd�s�|j |f�� }}|D]^\}
}|j"t$k(r�d|
z}|j"sd|_||j"vs�A|xj"|z
c_d}d|_�`|s|r*dg}|rdg|z}|rdg|z}|ddj|�zz
}t'|j)�j*d�}t-j.||�}t0j2j5|�|dk7rdj7|�zSdzScc}}wcc}wcc}w)Nr_Fr�rr)r*Tz:Args that start with '%s' can also be set in a config filez or c3�TK�|] }|js�|jd���"y�w)rN)r[rLs  rr�z-ArgumentParser.format_help.<locals>.<genexpr>s(����0�,-��HX�HX�A�$�$�Q�'�0�s�(�(zspecified via c���t|ttjf�r)	tjtj
|��St|dd�S#ttf$rt|�cYSwxYw)Nr(z
<callable>)
r
r|r2r3�fsdecoder�r1rr
rC)rss r�#_describe_default_config_file_entryzGArgumentParser.format_help.<locals>._describe_default_config_file_entry
sa��%�a�#�r�{�{�);�<�/�')�{�{�2�9�9�Q�<�'@� @� '�q�*�l�C�C��%.�z�#:�/�'+�A�w��/�s�'A�A4�3A4c3�.�K�|]}�|����y�wr	r)r�rsr�s  �rr�z-ArgumentParser.format_help.<locals>.<genexpr>s�����,��<�A�>�,�s�z (%s).r^ruz   [env var: %s]rzconfig file valueszenvironment variablesz- In general, command-line values override %s.z which override �z
{}
)r6r<rOrQr[rtrDr*r.rCrzr��filterr;r3r7rur)r��max�_get_formatter�_width�textwrap�fillrr�format_helprp)r2rU�added_config_file_help�added_env_var_helpr�ccr�rT�config_settable_args�config_path_actions�config_arg_string�described_files�env_var_actionsru�env_var_help_string�
value_sources�
text_widthr�s                 @rrzArgumentParser.format_help�s�����!&��"���%�%�#'�#=�#=� ��T�&�&�q�)�)�B����
$���+�+�
$���0�0��3��F�F�f�$��+�+��5�5��a��
$��
$� �
$� �=�=�#��G�A�7K�U�,S��#��#�$�)=�AT�-2��*�)-�&��P�����%+�K�K�0�1D�0�%�!�%�(8�;L�(L�%�'�+<�D�',�,�!5�,�'�O��8�f�k�k�'�%��t�>O�=P�0Q�*R�R�'���C��s�T�5�5�L�L�N�N�N���!�!�(,�
�
��#$���I�t�9T����A���O��.�	
3�
����6�6�X�%��&8�7�&B�#��v�v��A�F�&�a�f�f�4��F�F�1�1�F�)-�&�-2�D�*�	
3��!7�'�L�M�%�!5� 6�� F�
�!�!8� 9�M� I�
��B�"�'�'�
�6��
�C���,�,�.�5�5�r�:�
��m�m�C��,���&�&�2�2�4�8�$'�2�I�H�O�O�C� �
�	
�35�
�	
��_
$��#��Rs�AJ#�'J)�:J)�9J.�J.r�)r(r)r*r+r�rUrNr_r2�environrhrdr�rzr�r{r�r�r�rr�ryrtr}r�r?�stdoutr�rrrrrr�s����t&�l�>�$�2�4�d�R�Z�Z��@��!�����
o'�b(�"=�~
�($�
�$R
�h�@ � 1!�f[�z�(}�~�B!$�
�
�)�X
rrc��|jdd�}|jdd�xs|jdd�}|jdd�}|j|i|��}|rNt|tj�r4tt|�jtt|�fi�|_|j|_
||_||_||_
|jr
|rtd��|jr%t|tj�std��|jrZd}t|t�st|d	z��|rt|d
z��|rt|dz��|jrt|dz��|S)
a�
    This method supports the same args as ArgumentParser.add_argument(..)
    as well as the additional args below.

    Keyword Arguments:
        env_var: If set, the value of this environment variable will override
            any config file or default values for this arg (but can itself
            be overridden on the commandline). Also, if auto_env_var_prefix is
            set in the constructor, this env var name will be used instead of
            the automatic name.
        is_config_file_arg: If True, this arg is treated as a config file path
            This provides an alternative way to specify config files in place of
            the ArgumentParser(fromfile_prefix_chars=..) mechanism.
            Default: False
        is_write_out_config_file_arg: If True, this arg will be treated as a
            config file path, and, when it is specified on the command line,
            will cause configargparse to write all current commandline args to
            this file as config options and then exit. It can only be set on the
            command line: a config file key that names it is an error, and it
            can't be combined with env_var, nor be a positional arg, since a
            config file value would be indistinguishable from a path the user
            typed and could overwrite an arbitrary file.
            Default: False

    Returns:
        argparse.Action: the new argparse action
    ruNr*�is_config_filer.z*env_var can't be set for a positional arg.z9arg with is_config_file_arg=True must have action='store'z+arg with is_write_out_config_file_arg=True zmust have action='store'z'can't also have is_config_file_arg=Truezcan't also have env_var setzcan't be a positional arg)r/�original_add_argument_methodr
r�_StoreActionr�r(r=rJr[rIrur*r.r)r2rBr rur*r.r�error_prefixs        rr>r>?s~��:�j�j��D�)�G����$8�$�?��6�:�:��$�D��$*�:�:�.L�d�#S� �
.�T�
.�
.��
?��
?�F�#�
�6�8�;P�;P�(Q� ���L�!�!�
+�T�&�\�:��
���$*�#8�#8�8�F���F�N� 2�F��*F�F�'�
���G��E�F�F�
� � ��F�H�<Q�<Q�)R��T�U�U�
�*�*�D���&�"@�A��\�,F�F�G�G���\�,U�U�V�V���\�,I�I�J�J��#�#�
�\�,G�G�H�H��Mrc�D�|�
t�}t|�|vrgS|jt|��|g}t|dg�D]W}t	|�s�|j
j
�D],}t|tj�s�|t||�z
}�.�Y|S)aRFind a parser and every subparser reachable from it.

    Args:
        parser: the parser to start from.
        seen: ids of the parsers already visited, so that a subparser leading
            back to one of its own ancestors doesn't loop forever.

    Returns:
        list[argparse.ArgumentParser]: the parser and its subparsers
    rQ)r�rE�addrC�_dispatches_to_subparsersrXrHr
rrr�)rF�seenrr�	subparsers     rr�r��s����|��u��	�&�z�T���	��H�H�R��Z���h�G��&�*�b�1�?��$�V�,�#�^�^�2�2�4�
?�	��i��)@�)@�A��~�i��>�>�G�
?�?��Nrc���t|tj�ryt|dd�tjtj
fvxrtt|dd�t�S)a�Check whether an action hands the rest of the command line to a subparser.

    Nearly always this is an ``argparse._SubParsersAction``, but a program can
    register a class of its own for the job, so recognize the shape too: a
    mapping of subcommand names to parsers, taking the rest of the args.

    Args:
        action: the action to check.

    Returns:
        bool: whether it dispatches to subparsers
    TrJNrX)r
rrWrC�PARSERrKr�r
s rrr�s\���&�(�4�4�5���6�7�D�)�������.��=��W�V�Y��5�t�
<�=rc����g�|D]G}|r2|d|vr+d|vr'|jdd�\}}�j|��7�j|��It�fd�|D��S)z�Utility method for checking if any of the potential_command_line_args is
    already present in existing_args.

    Returns:
        bool: already on command line?
    rr�rbc3�&�K�|]}|�v���
y�wr	r)r��
potential_arg�	arg_namess  �rr�z*already_on_command_line.<locals>.<genexpr>�s������'4�
��"��s�)ror�rP)�existing_args_list�potential_command_line_argsrOrYrI�explicit_argr!s      @rrwrw�s}����I�(�)�
��*�Q�-�<�7�C�:�<M�*4�*:�*:�3��*B�'�M�<����]�+����Z�(�)���8S���rr	)T)br+rr�r�r��	functoolsrlr�r2rhr?r��collectionsrrr�ior�_StoreTrueAction�_StoreFalseActionr��_StoreConstAction�_AppendConstActionr�r@r�rr�r�rr!r$r�RawTextHelpFormatter�RawDescriptionHelpFormatterr&�objectr-r=rnrNrPrRr�r��compiler��DOTALLr��	lru_cacher�r�r�r�r�r�r�rsr|r�r�rr>r�rrw�_ActionsContainerr�Actionrf�ArgumentTypeError�FileTyper:�MetavarTypeHelpFormatter�	Namespace�ONE_OR_MOREr�rrKr�r��initArgumentParser�getArgumentParser�getArgParser�	getParser�get_arg_parser�
get_parser�	ArgParser�Parser�add_argrrhr6rd�parse_known�RawFormatter�DefaultsFormatter�DefaultsRawFormatterrrr�<module>rFs�����
��
����	�	�
��#����
���������������'�#����v��'�.�.�x�/M�/M�N�"��"6��&+�,O�&P�#���.�.�	��*�*��!�!��(�(�	�%C�v�%C�P�V��:2�	�2�9�(A�9�e�.�e�PI�#3�I�XDV�+�DV�N�2�B�J�J�W�X��%�2�:�:�Y�

�)�)�
������S��-��.���,�(�$y"�'�y"�xU�&�U�pP0�,�P0�h*��-��'��!��{
�X�,�,�{
�|%K�\�6=�,�8
���+�+�	���7�+7����'�

���� (� F� F���&�&�
��.�.�������&�&�
�#�<�<�����	�&�B�B���4�4���"�"������	�������	������$�$��*��'��"���	�%��
 �
��	�	��%-�%?�%?�%L�%L����"�!)�!;�!;�!H�!H�����%�0�0���+�<�<���*��1��7�r

Zerion Mini Shell 1.0
GEPRES Tracking

República de Moçambique

Ministério da Economia e Finanças