403Webshell
Server IP : 37.9.174.138  /  Your IP : 216.73.216.117
Web Server : Apache
System : Linux vps6.backend.sk 6.12.100+deb13-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.12.100-1 (2026-07-30) x86_64
User : ftpuser ( 1001)
PHP Version : 8.4.24
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : ON  |  Pkexec : ON
Directory :  /lib/python3/dist-packages/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/__pycache__/configargparse.cpython-313.pyc
�

�:�d^����SrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK	r	SSK
r
SSKJr SSK
r
\	RS:�aSSKJr OSSKJr \R"\R$\R&\R(\R*/r\	RS:�a\R/\R05 SrOSr\"\5r0rS/S	jrS/S
jr"SS\R<\R>\R@5r!"S
S\"5r#"SS\$5r%"SS\#5r&"SS\#5r'"SS\#5r(\RR"S5r*\RR"S\RVS9r,\RZ"SSS9S0Sj5r.S0Sjr/Sr0S r1"S!S"\#5r2"S#S$\#5r3"S%S&\#5r4S'r5S(r6S)r7S*r8"S+S,\Rr5r9S-r:S.r;\RxRt\Rxl=\:\Rxl:\R|r>\R<r\R~r?\R�r@\R�rA\R�rB\R�rC\R�rD\R@r \R>r\R�rE\R�rF\R�rG\R�rH\R�rI\R�rJ\rK\rL\rM\rN\rO\rP\9rQ\9rR\RxRt\RxlS\RxRt\RxlT\9R�\9lV\9R�\9lX\ rY\rZ\!r[g)1z�
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)�r)�StringIO)r�	c�6�[U[R5$�N)�
isinstance�argparse�BooleanOptionalAction��actions �0/usr/lib/python3/dist-packages/configargparse.py�<lambda>rs��
�6�8�Ca�Ca�0b�c��g)NF�rs rrr!s��rc���UcSnU[;a[SU<S[U<35eURS[R5 URSS5 [S0UD6[U'g)	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 )sl���|����x����(�4�.�"�#�	#����'��)O�)O�P�
���(�)�4�#�-�f�-�H�T�Nrc�h�UcSn[U5S:�d
U[;a[U40UD6 [U$)z�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#<s7���|���
�6�{�Q��$�h�.��T�,�V�,��D�>�rc��\rSrSrSrSrg)� ArgumentDefaultsRawHelpFormatter�KzCHelpFormatter that adds default values AND doesn't do line-wrappingrN��__name__�
__module__�__qualname__�__firstlineno__�__doc__�__static_attributes__rrrr%r%Ks��N�rr%c�*�\rSrSrSrSrSrSrSrg)�ConfigFileParser�SzNThis abstract class can be extended to add support for new config file
formatsc��[S5e)z3Returns a string describing the config file syntax.z*get_syntax_description(..) not implemented��NotImplementedError��selfs r�get_syntax_description�'ConfigFileParser.get_syntax_descriptionWs��!�"N�O�Orc��[S5e)aParses 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): 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 implementedr2)r5�streams  r�parse�ConfigFileParser.parse[s��"�"=�>�>rc��[S5e)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 implementedr2)r5�itemss  r�	serialize�ConfigFileParser.serializels��"�"A�B�BrrN�	r(r)r*r+r,r6r:r>r-rrrr/r/Ss���P�?�"Crr/c��\rSrSrSrSrg)�ConfigFileParserException�{z'Raised when config file parsing failed.rNr'rrrrBrB{s��1rrBc�*�\rSrSrSrSrSrSrSrg)�DefaultConfigFileParser�a�
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�
�SnU$)NzrConfig file syntax allows: key=value, flag=true, stuff=[a,b,c] (for details, see syntax at https://goo.gl/R74nmi).r�r5�msgs  rr6�.DefaultConfigFileParser.get_syntax_description�s��E���
rc�j�[5n[U5GHJup4UR5nU(aUSS;dURS5(aM>[R
"SU5nU(a�UR
S5nUR
S5nUR
S5nUR
S5n	UcUb	US	:waS
nOUcSnURS5(a-URS
5(a[R"U5nU	(a!U	R5SSR5n	X�U'GM&[SRU[USS5U55e U$![aAn
USSRS5Vs/sHo�R5PM Os snfnnSn
A
N�Sn
A
ff=f)Nr)�#�;�[z---zn^(?P<key>[^:=;#\s]+)\s*(?:(?P<equal>[:=\s])\s*([\'"]?)(?P<value>.+?)?\3)?\s*(?:\s[;#]\s*(?P<comment>.*?)\s*)?$�key�equal�value�comment� ��truerN�]�����,zUnexpected line {} in {}: {}rr9)r�	enumerate�strip�
startswith�re�match�group�endswith�json�loads�	Exception�splitrB�format�getattr)r5r9r=�i�liner^rOrPrQrR�e�elems            rr:�DefaultConfigFileParser.parse�s����
�� ��(�G�A��:�:�<�D��4��7�o�5�����9O�9O���H�H�F�GK�M�E���k�k�%�(�����G�,�����G�,���+�+�i�0���=�U�%6�5�C�<��E��]�"�E��#�#�C�(�(�U�^�^�C�-@�-@�R� $�
�
�5� 1���%�m�m�o�a�b�1�7�7�9�G�"�c�
�/�0N�0U�0U�VW��F�F�H�5�t�1=�>�>�9)�<���%�R�:?��"�+�:K�:K�C�:P� Q�:P�$����:P�� Q�� Q���R�s$�7E'�'
F2�1F-�F!� F-�-F2c��[5nUR5H_up4[U[5(a%SSR	[[U55-S-nURSRX455 Ma UR5$)NrN�, rVz{} = {}
)
rr=r	�list�join�map�str�writere�getvalue)r5r=�rrOrQs     rr>�!DefaultConfigFileParser.serialize�sk���J���+�+�-�J�C��%��&�&��D�I�I�c�#�u�o�6�6�s�:��
�G�G�K�&�&�s�2�3�	(�
�z�z�|�rrNr@rrrrErEs���:�
"�HrrEc�*�\rSrSrSrSrSrSrSrg)�ConfigparserConfigFileParser��z,parses INI files using pythons configparser.c�
�SnU$)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.
        rrHs  rr6�3ConfigparserConfigFileParser.get_syntax_description�s��
���
rc	��SSKnSSKJn URSSSSSSS9nUR	UR55 [5nUR5H|nXGR5Hcup�U	RS	S
5RSS
5n
SU
;a2S
U
;a,U
RS5SnSU;aU"U
5Xh'MYX�U'M_X�U'Me M~ U$![an[SU-5eSnAff=f)Nr)�literal_eval)�=�:F)rLrMT)�
delimiters�allow_no_value�comment_prefixes�inline_comment_prefixes�strict�empty_lines_in_values�Couldn't parse config file: %s�
rS�
rNrV�{)
�configparser�astr|�ConfigParser�read_string�readrcrBr�sectionsr=�replacerd)r5r9r�r|�configri�result�section�k�v�multiLine2SingleLine�prelist_strings            rr:�"ConfigparserConfigFileParser.parse�s
���$��*�*� � �&�$-��"'�
+�
��	R����v�{�{�}�-�
������(�G���,�,�.���'(�y�y��c�':�'B�'B�4��'L�$��.�.�3�:N�3N�%9�%?�%?��%D�Q�%G�N��.�0�$0�1E�$F��	�$8�q�	� 4�1�I�/�)��
��%�	R�+�,L�q�,P�Q�Q��	R�s�C�
C8�%C3�3C8c���SSKnSSKnURSSSSS9nSU0nURU5 UR	5nURU5 UR
S5 UR5$)NrF)rLT)r�r�r�r��DEFAULT)r��ior��	read_dictrrr�seekr�)r5r=r�r�r�r9s      rr>�&ConfigparserConfigFileParser.serializesq�����*�*� �$*��"'�	+�
���E�"���������������V�����A���{�{�}�rrNr@rrrrwrw�s��6��"!�Frrwc�4�\rSrSrSrSrSrSrS	SjrSr	g)
�YAMLConfigFileParseriz\Parses YAML config files. Depends on the PyYAML module.
https://pypi.python.org/pypi/PyYAML
c�
�SnU$)NzThe config file uses YAML syntax and must represent a YAML 'mapping' (for details, see http://learn.getgrav.org/advanced/yaml).rrHs  rr6�+YAMLConfigFileParser.get_syntax_descriptions��S���
rc��SSKnSSKJn SSKJn XU4$![a [S5ef=f![a SSKJn SSKJn N5f=f)zblazy-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�ImportErrorrBr�r�r�r�)r5r�r�r�s    r�
_load_yaml�YAMLConfigFileParser._load_yaml$sa��	G��
	$�6�.�
��'�'���	G�+�-F�G�
G�	G���	$�'�#�	$�s��0�-�A	�A	c��UR5up#nURXS9n[	U[
5(d2[S[
USS5<S[U5R<S35e[5nUR5H2up�[	U	[5(aX�U'M U	cM%[U	5Xx'M4 U$![an[SU-5eSnAff=f)N)�Loaderr�z_The config file doesn't appear to contain 'key: value' pairs (aka. a YAML mapping). yaml.load('rr9z') returned type 'z' instead of 'dict'.)
r��loadrcrBr	�dictrf�typer(rr=rnrq)
r5r9r�r��_�
parsed_objrir�rOrQs
          rr:�YAMLConfigFileParser.parse6s���"�o�o�/���!�	R����6��=�J��*�d�+�+�+�����1�D��4D�4M�4M�-O�P�
P�
���$�*�*�,�J�C��%��&�&�#�s�����!�%�j���
-��
��%�	R�+�,L�q�,P�Q�Q��	R�s�B=�=
C�C�Cc�^�UR5up4n[U5nURXUS9$)N)�default_flow_styler�)r�r��dump)r5r=r�r�r�r�s      rr>�YAMLConfigFileParser.serializePs2���/�/�+�����U����y�y��f�y�U�UrrN�F)
r(r)r*r+r,r6r�r:r>r-rrrr�r�s����
(�$�4Vrr�z1(^\"(?:\\.|[^\"\\])*\"$)|(^\'(?:\\.|[^\'\\])*\'$)z�(^\"\"\"(\s+)?(([^\"]|\"([^\"]|\"[^\"]))*(\"\"?)?)?(\s+)?(?:\\.|[^\"\\])?\"\"\"$)|(^\'\'\'(\s+)?(([^\']|\'([^\']|\'[^\']))*(\'\'?)?)?(\s+)?(?:\\.|[^\'\\])?\'\'\'$))�flags�T)�maxsize�typedc��[[RU55=(d' U=(a [[RU55$)zi
Detect whether a string is a quoted representation. 

:param triple: Also match tripple quoted strings.
)�bool�_QUOTED_STR_REGEXr^�_TRIPLE_QUOTED_STR_REGEX)�text�triples  r�	is_quotedr�}s=���!�'�'��-�.�@�	�	>�D�1�7�7��=�>�@rc���[XS9(a1[R"U5n[U[5(deU$U$![
an[
SUSU35UeSnAff=f)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	rqrcr)r�r��sris    r�unquote_strr��st����%�	_�� � ��&�A��a��%�%�%�%����K���	_��J�4�&�PR�ST�RU�V�W�]^�^��	_�s�-A�
A#�A�A#c	��/n[R"U/SS9H3nUH*nUR[UR	5SS95 M, M5 [U5$)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�r[�tuple)�section_namer��row�as    r�parse_toml_section_namer��sO���G��z�z�<�.�C�8���A��N�N�;�q�w�w�y��?�@��9���>�rc���[U[5(a[U5OUnURUS5nU(dgUSSnU(a[	X25$[U[
5(dgU$)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.
rNrW)r	rqr��get�get_toml_sectionr�)�datar�r��itemdatas    rr�r��sd��
4>�g�s�3K�3K�&�w�/�QX�H��x�x����$�H������|�H����3�3��(�D�)�)���rc�>^�\rSrSrSrU4SjrSrSrSrSr	U=r
$)�TomlConfigParseri�a�
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 <>`_ for details. 
c�.>�[TU]5 Xlg)z?
:param sections: The section names bounded to the new parser.
N)�super�__init__r�)r5r��	__class__s  �rr��TomlConfigParser.__init__�s���	���� �
rc��U$rrr4s r�__call__�TomlConfigParser.__call__�����rc�b�SSKnURU5n[	5nUR
H^n[
X65nU(dMUR5H2up�[U	[5(aX�U'M U	cM%[U	5XX'M4  U$ U$![an[SU-5eSnAff=f)z3Parses the keys and values from a TOML config file.rNzCouldn't parse TOML file: %s)�tomlr�rcrBrr�r�r=r	rnrq)
r5r9r�r�rir�r�r�rOrQs
          rr:�TomlConfigParser.parse�s���	�	P��Y�Y�v�&�F�
����}�}�G�#�F�4�D��t�#'�*�*�,�J�C�!�%��.�.�&+�s�����&)�%�j���
#/���
�%��
��+�	P�+�,J�Q�,N�O�O��	P�s�B�
B.�B)�)B.c��g)NzConfig file syntax is Tom's Obvious, Minimal Language. See https://github.com/toml-lang/toml/blob/v0.5.0/README.md for details.rr4s rr6�'TomlConfigParser.get_syntax_descriptions��[r)r��r(r)r*r+r,r�r�r:r6r-�
__classcell__�r�s@rr�r��s#����8!���:\�\rr�c�>^�\rSrSrSrU4SjrSrSrSrSr	U=r
$)�IniConfigParseria�
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�:>�[TU]5 XlX lg)z�
:param sections: The section names bounded to the new parser.
:split_ml_text_to_list: Wether to convert multiline strings to list
N)r�r�r��split_ml_text_to_list)r5r�r�r�s   �rr��IniConfigParser.__init__2s���
	���� �
�%:�"rc��U$rrr4s rr��IniConfigParser.__call__;r�rc	�,�SSKnUR5nURUR55 [
5nUR5UR/-GHnX`R;aMX6R5H�upxUR5n	U	(dMU	RS5(a1U	RS5(a[R"U	5XW'Me[#U	5(a[%U	5XW'M�UR&(aMSUR)S5;a8U	R+S5V
s/sHo�(dM[%U
5PM sn
XW'M�X�U'M� GM U$![an[SU-5eSnAff=f![a n[S[!U5-S-5UeSnAff=f![an[[!U55UeSnAff=fs sn
f![an[[!U55UeSnAff=f)	z3Parses the keys and values from an INI config file.rNzCouldn't parse INI file: %srNrVzError evaluating list: z;. Put quotes around your text if it's meant to be a string.r�)r�r�r�r�rcrBrr��DEFAULTSECTr=r[r\r`r�r|rrqr�r�r��rstriprd)r5r9r�r�rir�r�r�r��strip_vrgs           rr:�IniConfigParser.parse>s���	��*�*�,��	O����v�{�{�}�-�
������(�L�,D�,D�+E�E�G��m�m�+����,�,�.����'�'�)�����%�%�c�*�*�w�/?�/?��/D�/D�c�$'�$4�$4�W�$=��	�
!��)�)�K�(3�G�(<�F�I�
�3�3�������8N�K�AH���t�AT�(Z�AT�A�XY���Q��AT�(Z�F�I�
%&�q�	�9/�F�@�
��K�	O�+�,I�A�,M�N�N��	O��"&�c�7�8Q�TW�XY�TZ�8Z�^[�9[�\�bc�c��c�� *�K�";�C��F�"C��J��K��)[��)�K�";�C��F�"C��J��K�sw�E6�F�:
G�0G/�
G*�G*� G/�6
F�F�F�
G� F;�;G�
G'�
G"�"G'�*G/�/
H�9H�Hc�6�SnUR(aUS-
nU$)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�rHs  rr6�&IniConfigParser.get_syntax_descriptionls+��v���%�%��H�
I�C��
r)r�r�r�r�s@rr�r�s#���)�V;��,�\�rr�c�>^�\rSrSrSrU4SjrSrSrSrSr	U=r
$)�CompositeConfigParseriuz�
Createa a config parser composed by others `ConfigFileParser`s.  

The composite parser will successively try to parse the file with each parser, 
until it succeeds, else raise execption with all encountered errors. 
c�d>�[TU]5 UVs/sH	o""5PM snUlgs snfr)r�r��parsers)r5�config_parser_types�pr�s   �rr��CompositeConfigParser.__init__}s+���
����%8�9�%8����%8�9����9s�-c��U$rrr4s rr��CompositeConfigParser.__call__�r�rc��/nURHnURU5s $ [SSR
SU5535e![a-nURS5 UR	U5 SnAMoSnAff=f)NrzError parsing config: rmc3�J# �UHn[[U55v� M g7fr)�reprrq)�.0ris  r�	<genexpr>�.CompositeConfigParser.parse.<locals>.<genexpr>�s���2P��A�4��A��<�<��s�!#)r�r:rcr�r�rBro)r5r9�errorsr�ris     rr:�CompositeConfigParser.parse�s�������A�
!��w�w�v��&��(�(����2P��2P�)P�(Q�R�T�	T���
!����A���
�
�a� � ��
!�s�A�
B�"A>�>Bc	��SnSn[UR5H?up4USUS-SU"URR5SUR	5S3-
nMA U$)Nc���UR5RS5RSS5RSS5RSS5nU(aUR5$S$)Nr��parserrTr��filez??)�lowerr[r��upper)�	classnamer[s  r�guess_format_name�GCompositeConfigParser.get_syntax_description.<locals>.guess_format_name�sV���O�O�%�+�+�C�0�8�8�����G�H�b�)�'�'�&�"�*=�
�$)�5�;�;�=�3�t�3rz2Uses multiple config parser settings (in order): 
rNrWz] r�z 
)rZr�r�r(r6)r5rrIrgrs     rr6�,CompositeConfigParser.get_syntax_description�sj��	4�
D��"�4�<�<�0�I�A��Q�q��s�e�2�/��0@�0@�0I�0I�J�K�2�f�Nk�Nk�Nm�Mn�nq�r�r�C�1��
r)r�r�r�s@rr�r�us"����:��	T�	�	rr��command_line�environment_variables�config_file�defaultsc���\rSrSrSrSrSSS\R4SjrSSS\RS4Sjr	Sr
SS	jrS
rSr
SrS
rSrSr\R&4SjrSrSrg)ri�z�Drop-in replacement for `argparse.ArgumentParser` that adds support for
environment variables and ``.ini`` or ``.yaml-style`` config files.
c��URSS5nURSS5nURSS5nURS/5nURSS5nURS	[5nURS
/5n	URSS5n
URSS
5nURS/5nURSS5n
URS[5UlX0lX@lXPl[RR"U/UQ70UD6 Uc[5Ul
OU"5Ul
X`lXplU	(aUR"U	SX�SS.6 U(aUR"USSU
SS.6 gg)a�Supports args of the `argparse.ArgumentParser` constructor
as \*\*kwargs, as well as the following additional args.

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 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"]

    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: []
    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_funcr)�dest�required�help�is_config_file_arg�"write_out_config_file_to_this_path�CONFIG_OUTPUT_PATH)r&�metavarr(�is_write_out_config_file_arg)�poprE�open�_config_file_open_func�_add_config_file_help�_add_env_var_help�_auto_env_var_prefixr
rr��_config_file_parser�_default_config_files� _ignore_unknown_config_file_keys�add_argument)r5�argsrrrrrrrr r!r"r#r$s              rr��ArgumentParser.__init__�s���t &�z�z�*@�$�G��!�:�:�&8�$�?��$�j�j�)>��E��%�z�z�*@�"�E��*0�*�*�-�u�+6�'�#)�:�:�.H�.E�$G� �'-�z�z�*�B�(0�$�!'���,D�e�!L��"(�*�*�-F�-?�#A��+1�:�:�.��,4�(�17���4�7%�2&�.�
'-�j�j�1H�$�&O��#�%9�"�!1��$7�!����(�(��?��?��?�$�+�'>�'@�D�$�'?�'A�D�$�%9�"�0O�-�'����;�-�/�#'�
)�,����?�9�,�;�-1�	
3�,rNc��URUUUUSS9upU(a#URSSRU5-5 U$)aSSupports 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)r8�	namespace�config_file_contents�env_vars�ignore_help_argszunrecognized arguments: %srS)�parse_known_args�errorro)r5r8r;r<r=�argvs      r�
parse_args�ArgumentParser.parse_argssN���*�*���!5��"�+�$�
����J�J�3�c�h�h�t�n�D�E��rFc	��Uc[RSSnO1[U[5(aUR	5nO[U5nURHnUR(+UlM U(aUVs/sHowS;dM
UPM nn[5Ul
U(a"S[U54nSU0UR['URGbURH�nURU5n	U	(dMUR(aM0UR(aMCUR(aMVUR (aMi[U["R$5(aM�[U["R&5(aM�U	SR)UR*5n
URU
-R-SS5R/5UlM� /nSnURVs/sHdnUR(aMUR(dM)URU;dM;[1XRUR*5(aMbUPMf n
nU
H�nURnXOnUR2(d[U["R45(aES	nUR7S
5(a-UR9S5(a[:R<"U5nX�RAX�U5-
nM� U(aX-nOX�-nU(aG[U
Vs/sHnURXdUR44PM! sn5UR[B'[ESUR55nU=(a SU;=(d SU;nURVVs0sHnURU5HnUU_M M! nnn/nUb[GU5nSUl$U/nOU(dURKU5n[MU5GH�nURNRQU5n[WUS5(aURY5 /nSnWR[5GHunnUU;a&UUn[1XRUR*5nO<SnUR\=(d' [1UUR_U5/UR*5nU(aMxUURAX�U5-
n[`<SURH<3nUUR;a[5URU'UU4URUU'U(aUR2(d"[U["R45(dGMS	nGM U(aUU-nGM�UU-nGM� [5nURH�nUR(+=(d UR2[b[d4;n[1XRUR*5(d=U(a6URfb)URf[h:Xd[U[j5(aM�UR(aURSnOURlnU[URf54UU'M� U(aUUR[n'["RpRsXUS9unnURVs/sH-n[uUSS5(dM[uX&RlS5PM/ n nU Vs/sH	ofcMUPM n nURwUU S	S9 UU4$s snfs snf![>a< USSR	S
5Vs/sHnUR)5PM Os snfnnGN�f=fs snfs snnf![Ra%nURU[U55 SnAGN�SnAff=f![WUS5(aURY5 ff=fs snfs snf)aFSupports 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
NrW)�-h�--helprTr�-r�FTrNrVrXrYc3�h# �UH(n[U[R5(dM$Uv� M* g7fr)r	r
�_HelpAction�rr�s  rr�2ArgumentParser.parse_known_args.<locals>.<genexpr>�s%��� M�$�!�
�1�h�6J�6J�(K�A�A�}�s�#2�	2rErFz
method arg�close�|)r8r;r-)�
exit_after)<�sysrAr	rqrdrn�_actions�option_strings�is_positional_argr�_source_to_settings�_COMMAND_LINE_SOURCE_KEYr3�get_possible_config_keys�env_varr)r-r
�_VersionActionrIr[�prefix_charsr�r�already_on_command_line�nargs�
_AppendActionr\r`rarbrc� convert_item_to_command_line_arg�_ENV_VAR_SOURCE_KEY�anyrr�_open_config_files�reversedr4r:rBr@�hasattrrLr=r6�4get_command_line_key_for_unknown_config_file_setting�_CONFIG_FILE_SOURCE_KEY�OPTIONAL�ZERO_OR_MOREr�SUPPRESS�#ACTION_TYPES_THAT_DONT_NEED_A_VALUEr&�_DEFAULTS_SOURCE_KEYrr?rf�write_config_file)!r5r8r;r<r=r>r��arg�a_v_pair�config_file_keys�stripped_config_file_key�env_var_argsrZ�actions_with_env_var_valuesr
rOrQrj�supports_help_arg�skip_config_file_parsing�
config_key�known_config_keys�config_streamsr9�config_itemsri�config_args�discard_this_key�
source_key�default_settings�cares_about_default_value�unknown_args�output_file_pathss!                                 rr?�ArgumentParser.parse_known_args(s��*�<��8�8�A�B�<�D�
��c�
"�
"��:�:�<�D���:�D����A�&'�&6�&6�"6�A����#'�G�4�C�6F�+F�C�4�D�G�$/�=�� ���d�4�j�)�H�BD�h��D�$�$�%=�>��$�$�0��]�]��#'�#@�#@��#C� �#�#�Q�Y�Y�Y�!�:M�:M�:M��+�+�+�q�/M�/M�/M��q�(�"9�"9�:�:��q�(�"6�"6�7�7�/?��/B�/H�/H��)�)�0+�,�!%�!:�!:�!9�":�;B�7�3��;L�U�U�W��I�#�����26�-�-�'\�-�Q��&�&�()�+,�9�9�()�9:���h�9N�()�/��6F�6F��HY�HY�Z�()�-�#�'\�2�F��.�.�C��M�E��|�|�z�&�(�2H�2H�I�I����#�#�C�(�(�U�^�^�C�-@�-@�R� $�
�
�5� 1��
�A�A��U�$�
$�L�2� ��&�D��&�D��<G�8�:�8���)�)�a�!�)�)�!4�5�6�8�:�=;�D�$�$�%8�9�
 � M��}�}� M�M��#4�$.��D�L�,�H��,�	!�?C�m�m�E�m�F�"�;�;�F�C�
�(��/�C�(�m��E����+��2�3�F�&�F�K�$�X�N�)�!�4�4�T�:�N��~�.�F�
#�#�7�7�=�=�f�E���6�7�+�+��L�L�N��K��E�*�0�0�2�
��U��+�+�.�s�3�F�'>��3�3�T�5F�5F�(H�$�"�F�'+�'L�'L�(/�/� �!�V�V�WZ�[�\� �-�-�/�%�(�'��4�#H�#H��U�$,�,�K�+B�F�K�K�!P�J�!��)A�)A�A�?J�}��0�0��<�AG���D�,�,�Z�8��=��6�<�<�"�6�8�+A�+A�B�B� $��-3�0��k�)��"�T�)��O/�T'�=���m�m�F�-3�-E�-E�)E�*9�����<� 8�8�
&�'��.C�.C�T�EV�EV�W�W�1��N�N�*��N�N�h�.��v�'J�K�K���(�(� �/�/��3�C� �+�+�C�)/��V�^�^�1D�(E� ��%�$� �=M�D�$�$�%9�:�#+�"9�"9�"J�"J��y�#K�#2��	�<�HL�}�}�S�}�!� '��+I�5� Q�>�W�Y����=�}��S�(9�K�(9�1�Q�(9��K����y�*;���M��,�&�&��gH��6'\��%�R�:?��"�+�:K�:K�C�:P� Q�:P�$�����:P�� Q�� Q��R��:��E�� -�
#��
�
�3�q�6�"�"��
#���6�7�+�+��L�L�N�,��zS��Ks��=	\?�
\?�5]�]�!]�3#]�]�]	�$&^�'&^�^�_6�8_6�_;�"_;�	 ^�)^�^�^�
_�'_�_�_�_�$_3c��UR$)a
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
)rSr4s r�get_source_to_settings_dict�*ArgumentParser.get_source_to_settings_dict�s���'�'�'rc�D�UH nURUS5nSSS5 M" U(a�UR	UR
U5nURRU5nUH/nURUS5nURU5 SSS5 M1 [SSRU5-5 U(aURS5 ggg!,(df   M�=f![an[SRXF55eSnAff=f!,(df   M�=f)aWrite 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 rmr)r0�IOErrorrre� get_items_for_config_file_outputrSr4r>rr�printro�exit)	r5�parsed_namespacer|rN�output_file_path�output_fileriru�
file_contentss	         rri� ArgumentParser.write_config_file�s��!2��
*��0�0�1A�3�G�;��H�G�!2���@�@��(�(�*:�<�L� �4�4�>�>�|�L�M�$5� ��0�0�1A�3�G�;��%�%�m�4�H�G�%6�
�)�D�I�I�6G�,H�H�I���	�	�!����H�G���
*� �!C�!J�!J�$�")�*�*��
*��H�G�s?�C$�C�C$�<D�
C!	�C$�!C$�$
D
�.D�D
�
D	c�f�URUR5nURSS-U-nU$)aCompute 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
r�)r[rX)r5rO�key_without_prefix_chars�command_line_keys    rrb�CArgumentParser.get_command_line_key_for_unknown_config_file_settings;��$'�9�9�T�->�->�#?� ��,�,�Q�/��1�4L�L���rc���[5nUR5GH�upEU[:Xa�USupgURH�nUR	U5n	U	(dMUR
(aM0[
UURUR5(dMX[X(RS5n
U
cMs[U
[5(a[U
5R5n
X�U	S'M� M�U[:Xa[UR5HDunup�UR	U5n	U	(dM"[X(RS5n
U
cM=X�U	S'MF GM6UR!["5(a#UR5Hunup�X�U'M GMsU[$:XdGM�UR5HDunup�UR	U5n	U	(dM"[X(RS5n
U
cM=X�U	S'MF GM� U$)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
rTNr)rr=rTrPrUrRrYrQrXrfr&r	r�rqrr]r\rcrh)r5�source_to_settingsr��config_file_items�source�settingsr��existing_command_line_argsr
rlrQrOs            rr��/ArgumentParser.get_items_for_config_file_outputs���(�M�� 2� 8� 8� :��F��1�1�08���-��"�m�m�F�'+�'D�'D�V�'L�$�'�'��0H�0H�0H�/�0J�06�0E�0E�04�0A�0A�C�C�!(�(8�+�+�t� L�� �,�)�%��6�6�(+�E�
�(8�(8�(:��EJ�.>�q�.A�B�,��.�.�,4�N�N�,<�(�C��&�'+�'D�'D�V�'L�$�'�'� '�(8�+�+�t� L�� �,�EJ�.>�q�.A�B�-=��"�"�#:�;�;�,4�N�N�,<�(�C��&�-2�c�*�-=��/�/�,4�N�N�,<�(�C��&�'+�'D�'D�V�'L�$�'�'� '�(8�+�+�t� L�� �,�EJ�.>�q�.A�B�-=�5!;�@!� rc	�|�/nUcURU5nO[U5(dURSnUGbt[U[5(Ga^[U[
5(dS5eUR
5S;aD[U5(dURW5 U$URURS5 U$UR
5S;a4[U5(dU$URURS5 U$[U[R5(afUH@n[URVs/sHovRU5PM sn5(dM>SnMB XARS/[U5--
nU$URSU<S	U<S
35 U$[U[5(Ga�USL=(a� URSL=(a� [U[R 5=(d [U[R"5=(aF URS;=(d0 [UR[5=(a URS:�nUb[U[R"5(a~UHvn	U(aK[U	[5(a6URW5 U	Hn
UR[U
55 M MUURW<S[U	5<35 Mx U$U(a6URW5 UHn	UR[U	55 M U$URU<S
U<S35 U$[U[
5(aURW<SU<35 U$[%SR'[)U5U55es snf)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
NrXzCconfig parser should convert anything that is not a list to string.)rU�yes�on�1r)�false�no�off�0rWzUnexpected 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: {})rb�is_boolean_optional_actionrQr	rgrqrr�r
�_CountActionr^r\�intr@rnrZ�_StoreActionr[rrer�)r5r
rOrQr8r�rjr��accepts_list_and_has_nargs�	list_elem�sub_elems           rr\�/ArgumentParser.convert_item_to_command_line_argKsL�����>��I�I�#�N�
�.�f�5�5�#)�#8�#8��#<� ���*�V�5X�"Y�"Y��e�S�)�)�p�+p�p�)��{�{�}� :�:�1�&�9�9��K�K�!1�3�^��Y�K�K�� 5� 5�a� 8�9�X��W����"=�=�1�&�9�9��P��K�K�K�� 5� 5�a� 8�9�J��I�F�H�$9�$9�:�:��C��v�7L�7L�M�7L�!�N�N�1�-�7L�M�N�N� !�� ��.�.�q�1�2�S��Z�?�?��@��=�
�
�NQ�SX�Z�[�<��9��t�
$�
$�)/�t�);�*����TX�@X�*��f�h�&;�&;�<�j�
�6�S[�Si�Si�@j�*����
�*�b�z�&�,�,��/L�/a�QW�Q]�Q]�`a�Qa�
'��~��F�H�4J�4J�!K�!K�!&�I�1�j��D�6Q�6Q����$4�5�(1�H� �K�K��H�
�6�)2����0@�#�i�.�%Q�S�
"'�(��,����-�/�!&�I��K�K��Y��1�"'����
�
�RU�W\�^�_���
��s�
#�
#��K�K�$4�e�<�>�
���E�L�L��U��U�$�%�
%��?Ns�N9
c�^�/n[USS5(aU$URH3m[U4SjUR55(dM)UTSST/-
nM5 U$)z�This 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�L># �UHnTRSU-5v� M g7f)r�N)r\)r�crjs  �rr�:ArgumentParser.get_possible_config_keys.<locals>.<genexpr>�s#����B�0A�1�3�>�>�!�A�#�&�&�0A�s�!$r�)rfrQr^rX)r5r
�keysrjs   @rrU�'ArgumentParser.get_possible_config_keys�sc������6�9�4�@�@��K��(�(�C��B��0A�0A�B�B�B���Q�R��#��&��)��rc�"�/n[[R[[RRUR
55H,nUH#nUR
URU55 M% M. URVs/sHn[USS5(dMUPM nnU(dU$UH�n[R"URSS9nURU5 Sn	[R"X�5UlUR#US9n
U
(dMiU
up�[X�R$S5n
U
(dM�[RR	U
5n
URU
5nUW/-
nM� U$s snf![&a�n[)UR*5S:XaUR*unnO[-U5nUH%nUR/5 M![&a M#f=f UR!SU
<S	U<35 SnAN�SnAff=f)
aJTries 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[IO]: open config files
r)F)rX�add_helpc��grr)r5�messages  r�error_method�7ArgumentParser._open_config_files.<locals>.error_method�s��r)r8Nr�zUnable to open config file: z	. Error: )rp�glob�os�path�
expanduserr5r�r0rPrfr
rrX�_add_action�types�
MethodTyper@r?r&rcr"r8rqrL)r5�command_line_args�config_files�files�fr��user_config_file_arg_actionsr
�
arg_parserr��
parsed_argr;r��user_config_filer9ri�errnorIrs                   rr_�!ArgumentParser._open_config_files�s���������C����(:�(:�D�<V�<V�$W�X�E����#�#�D�$?�$?��$B�C��Y��}�}�(Q�$�!���3G��(O�A�}�	%�(Q�,���2�F�"�0�0�!�.�.�� �J�
�"�"�6�*�

�$�/�/��I�J��$�4�4�:K�4�L�J���%�L�I�&�y�+�+�t�D��#�� "�w�w�1�1�2B�C��
��4�4�5E�F�� 
�V�H�$�L�[3�^���k(Q��H�

��q�v�v�;�!�#�!"���J�E�3��a�&�C�#/�K��#�)�)�+��$�����$0�
�
�
�$�c�����

�sH�E=�!E=� F�
H�9H	�G�H	�
G&	�"H	�%G&	�&H	�	Hc�|�[S[S[S[S0n[	5nUR
R
5H�up4URS5nXS[USS5-nURU5 UR
5H�unupgU(a&URS	RUS
-U55 M5[U[5(aURSU-5 M`[U[5(dMwURSSRU5-5 M� M� UR5$)
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:
rMrrWNz  {:<19}{}
r~z  %s
rS)rTr]rcrhrrSr=rdr�rrrer	rqrnrors)r5�source_key_to_display_value_maprtr�r�rOr
rQs        r�
format_values�ArgumentParser.format_values�s��
%�&;��!;�#�%:� �-�	+
�'�
�J�� $� 8� 8� >� >� @��F��\�\�#�&�F�4�A�Y�?�%��q�r�
�BS�S�F�
�G�G�F�O�(0���(8�$��_�f���G�G�N�1�1�#�c�'�5�A�B�!�%��-�-�����5� 0�1�#�E�4�0�0�����3�8�8�E�?� :�;�)9�	!A��z�z�|�rc�B�URUR55 g)zBPrints the format_values() string (to sys.stdout or another file).N)rrr�)r5r
s  r�print_values�ArgumentParser.print_valuess���
�
�4�%�%�'�(rc�4�SnSnSnUR(Ga�URnSURS-nURVVs/sHjnURHVnURU5(dMURS:XaM-UR(aM@UR(aMSXv4PMX Ml nnnURVs/sHn[USS5(dMUPM n	nU(a�U(dU	(a�SUlSnUSU--
nS	RS
U	55n
U
(aSU
-n
U(dU
(a7USS	R[U5[[SU
/55-5--
nUS
URR5--
nUR(a�URVs/sH%n[USS5(dMUR U4PM' nnUHgup�UR"[$:XaMSU-n
UR"(dSUlX�R";dMIU=R"U
-
slSnSUlMi U(dU(a4S/nU(aS/U-nU(aS/U-nUSSRU5--
n['UR)5R*S5n[,R."X5n[0R2R5U5US:waSR7U5-$S-$s snnfs snfs snf)NrTFr�rr(r)Tz:Args that start with '%s' can also be set in a config filez or c3�d# �UH&oR(dMURSv� M( g7f)rN)rQrJs  rr�-ArgumentParser.format_help.<locals>.<genexpr>.s,���0F�0��4D�4D�1D��0@�0@��0C�0�s�0�0zspecified via z (%s).rSrVz   [env var: %s]rzconfig file valueszenvironment variablesz- In general, command-line values override %s.z which override �z
{}
)r1r5rXrPrQrUr&r)r-rfror��filterr4r6r2rVr(rf�max�_get_formatter�_width�textwrap�fillr
r�format_helpre)r5rI�added_config_file_help�added_env_var_helpr�ccr�rj�config_settable_args�config_path_actions�config_arg_string�env_var_actionsrV�env_var_help_string�
value_sources�
text_widths                rr��ArgumentParser.format_helps����!&��"���%�%�%�#'�#=�#=� ��4�$�$�Q�'�'�B�6:�m�m�$2�m��� � �IL�$(�$A�$A�!�$D�%-����6�!�%-�%&�%9�%9�%-��/�/�%-�S�H� �%-�m� �$2�
�
�
�#J��*+�!(��,@�%�!H�$%��
 �#J�$�)=�)<�-2��*�)-�&��(�+-�.�.��$*�K�K�0F�0�0F�%F�!�$�(8�;L�(L�%�'�+<��8�f�k�k�%�8L�2M�27��t�FW�EX�8Y�2Z�3[�'\�\�\�C��s�T�5�5�L�L�N�N�N���!�!�7;�}�}�?�}�!�")�!�Y��"=� .��	�	�1�~�}�O�?�-�
���6�6�X�%��&8�7�&B�#��v�v��A�F�&�f�f�4��F�F�1�1�F�)-�&�-2�D�*�.��!7�'�L�M�%�!5� 6�� F�
�!�!8� 9�M� I�
��B�"�'�'�
�6�8�
8�C���,�,�.�5�5�r�:�
��m�m�C�,���'�'�3�3�D�9�),�������%�<�	=�8:�<�	=��c$2��#J��(?s6�*L
�4L
�L
�L
�,L
�L�"L�8L�L)r1r2r3r0r4r5r6rSr�)r(r)r*r+r,r�r��environrBr?rrirbr�r\rUr_r�rO�stdoutr�r�r-rrrrr�s���h3�T!%�$�*.�2�:�:��4��!%��Z�Z�"�
s'�j(�$�: � -!�^K�Z�(I�V�<#&�*�*�)�9=rrc�~�URSS5nURSS5=(d URSS5nURSS5nUR"U0UD6nUR(+UlX6lXFlXVlUR(aU(a[S5eUR
(a*[U[R5(d[S5eUR(aDSn[U[R5(d[US	-5eU(a[US
-5eU$)a�
This method supports the same args as ArgumentParser.add_argument(..)
as well as the additional args below.

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, will cause
        configargparse to write all current commandline args to this file
        as config options and then exit.
        Default: False

Returns:
    argparse.Action: the new argparse action
rVNr)�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=True)r.�original_add_argument_methodrQrRrVr)r-rr	r
r�)r5r8rrVr)r-r
�error_prefixs        rr7r7Us,��2�j�j��D�)�G�����d�$� �'-�z�z��$�( ��$*�:�:�&��$.� ��
.�
.��
?��
?�F�#)�#8�#8�8�F���N� 2��*F�'�
���G��E�F�F�
� � ��F�H�<Q�<Q�)R�)R��*�+�	+�
�*�*�D���&�(�"7�"7�8�8��\�,F�F�G�G�� ��1J�"J�K�K��Mrc��^�/mUHQnU(a6USU;a-SU;a'URSS5upETRU5 M@TRU5 MS [U4SjU55$)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}rWc3�,># �UH	oT;v� M g7frr)r�
potential_arg�	arg_namess  �rr�*already_on_command_line.<locals>.<genexpr>�s�����8S�}��"�8S�s�)rdr�r^)�existing_args_list�potential_command_line_argsrX�
arg_string�
option_string�explicit_argr�s      @rrYrY�sv����I�(�
��*�Q�-�<�7�C�:�<M�*4�*:�*:�3��*B�'�M����]�+����Z�(�)���8S���rr)T)\r,r
r�r��	functoolsrar�r�r]rOr��collectionsrr��version_infor�r�_StoreTrueAction�_StoreFalseActionr��_StoreConstAction�_AppendConstActionrgr�rr�r�rr r#r�RawTextHelpFormatter�RawDescriptionHelpFormatterr%�objectr/rcrBrErwr��compiler��DOTALLr��	lru_cacher�r�r�r�r�r�r�rTr]rcrhrr7rY�_ActionsContainerr��Action�
ArgumentError�ArgumentTypeError�FileType�
HelpFormatter�MetavarTypeHelpFormatter�	Namespace�ONE_OR_MORErd�PARSER�	REMAINDERrfre�initArgumentParser�getArgumentParser�getArgParser�	getParser�get_arg_parser�
get_parser�	ArgParser�Parser�add_arg�addrBr:r?�parse_known�RawFormatter�DefaultsFormatter�DefaultsRawFormatterrrr�<module>rs����
�
�
����	�	�
��#�����v���!�(0�'@�'@����� 5� 5����� ;� ;�'=�#����v��'�.�.�x�/M�/M�N�!b��!5��&+�,O�&P�#���.�&�	��*�*��!�!��(�(�	�%C�v�%C�P2�	�2�O�.�O�dF�#3�F�R>V�+�>V�B�2�J�J� ;�<���:�:�'{�CE�CL�CL�	M�����S��-�@�.�@��&�&�"F\�'�F\�Pm�&�m�^#�,�#�L*��-��'��!��q
=�X�,�,�q
=�h6�r�,;C�:T�:T�:a�:a����7�*6����'�

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

Youez - 2016 - github.com/yon3zu
LinuXploit