/usr/lib/python3/dist-packages/__pycache__
Edit: /usr/lib/python3/dist-packages/__pycache__/configargparse.cpython-310.pyc (35655B)
o
=Xa @ s0 d Z ddlZddlZddlZddlZddlZddlZddlZddlm Z ddl
Z
ej dkr4ddl m
Z
nddl
m
Z
ejejejejejgZej dkrVeej dd Znd d ZeeZi Zd$d
d Zd$d d
ZG dd dejej ej Z G dd de Z G dd de!Z"G dd de Z#G dd de Z$G dd de Z%dZ&dZ'd Z(d Z)G d d d ej*Z*d d! Z+d"d# Z,ej-j+ej-_.e+ej-_+ej/Z/ej Z ej Z ejZej0Z0ej1Z1ej2Z2ej3Z3ej4Z4ej5Z5ej6Z6ej7Z7ej8Z8ej9Z9eZ:eZ;eZ
eZ?e*Z@e*ZAej-j+ej-_Bej-j+ej-_Ce*jDe*_Ee*jFe*_Ge ZHeZIe ZJdS )%z
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 C s t | tjS N)
isinstanceargparseBooleanOptionalActionaction r 0/usr/lib/python3/dist-packages/configargparse.py s r c C s dS )NFr r
r r r
r s c K sX | du rd} | t v rtd| t | f |dtj |dd tdi |t | < dS )zCreates 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(..)
Ndefaultzbkwargs besides 'name' can only be passed in the first time. '%s' ArgumentParser already exists: %sformatter_classconflict_handlerresolver )_parsers
ValueError
setdefaultr ArgumentDefaultsHelpFormatterArgumentParsernamekwargsr r r
init_argument_parser& s r c K s8 | du rd} t |dks| tvrt| 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.
Nr r )lenr r r r r r
get_argument_parser9 s
r c @ e Zd ZdZdS ) ArgumentDefaultsRawHelpFormatterzCHelpFormatter that adds default values AND doesn't do line-wrappingN__name__
__module__ __qualname____doc__r r r r
r H s r c @ ( e Zd ZdZdd Zdd Zdd ZdS ) ConfigFileParserzRThis abstract class can be extended to add support for new config file
formatsc C t d)z3Returns a string describing the config file syntax.z*get_syntax_description(..) not implementedNotImplementedErrorselfr r r
get_syntax_descriptionT s z'ConfigFileParser.get_syntax_descriptionc C r' )aH 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", "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 implementedr( )r+ streamr r r
parseX s zConfigFileParser.parsec C r' )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
z serialize(..) not implementedr( )r+ itemsr r r
serializei s zConfigFileParser.serializeNr! r" r# r$ r, r. r0 r r r r
r& P s
r& c @ r )ConfigFileParserExceptionz'Raised when config file parsing failed.Nr r r r r
r2 x s r2 c @ r% ) 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 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 r+ msgr r r
r, z.DefaultConfigFileParser.get_syntax_descriptionc C s@ t }t|D ]\}}| }|r |d dv s |dr qtd|}|r|d}|d}|d}|d} |d u rH|d urH|d krHd
}n|d u rNd }|d r|d
rzt |}W n t
y }
zdd |dd dD }W Y d }
~
nd }
~
ww | r| dd } |||< qt d
|t|dd||S )Nr )#;[z---zn^(?P[^:=;#\s]+)\s*(?:(?P[:=\s])\s*([\'"]?)(?P.+?)?\3)?\s*(?:\s[;#]\s*(?P.*?)\s*)?$keyequalvaluecomment truer: ]c S g | ]}| qS r strip.0elemr r r
z1DefaultConfigFileParser.parse.. ,z Unexpected line {} in {}: {}r r- )r enumeraterE
startswithrematchgroupendswithjsonloads Exceptionsplitr2 formatgetattr) r+ r- r/ ilinerQ r; r< r= r> er r r
r. s>
(
z DefaultConfigFileParser.parsec C sT t }| D ] \}}t|tr ddtt| d }|d|| q| S )Nr: , rB z{} = {}
)
r r/ r listjoinmapstrwriterX getvalue)r+ r/ rr; r= r r r
r0 s
z!DefaultConfigFileParser.serializeNr1 r r r r
r3 | s
$r3 c @ r% ) ConfigparserConfigFileParserz,parses INI files using pythons configparser.c C r4 )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.
r r5 r r r
r, s z3ConfigparserConfigFileParser.get_syntax_descriptionc
C s dd l }ddlm} |jddddddd}z || W n ty0 } ztd| d }~ww t }| D ]:}||
D ]1\}} | d d
d d
}
d |
v rmd
|
v rm|
d d } d| vrh||
||< q@|
||< q@|
||< q@q8|S )Nr ) literal_eval)=:F)r8 r9 T)
delimitersallow_no_valuecomment_prefixesinline_comment_prefixesstrictempty_lines_in_values Couldn't parse config file: %s
r?
r: rB {)
configparserastrf ConfigParser read_stringreadrV r2 r sectionsr/ replacerW ) r+ r- rs rf configr\ resultsectionkvmultiLine2SingleLineprelist_stringr r r
r. s8
z"ConfigparserConfigFileParser.parsec C sX dd l }dd l}|jddddd}d|i}|| | }|| |d | S )Nr F)r8 T)rj rl rm rn DEFAULT)rs ioru read_dictr rb seekrw )r+ r/ rs r rz r- r r r
r0 s
z&ConfigparserConfigFileParser.serializeNr1 r r r r
re s
#re c @ s2 e Zd ZdZdd Zdd Zdd Zd d d
Zd S )
YAMLConfigFileParserzdParses YAML config files. Depends on the PyYAML module.
https://pypi.python.org/pypi/PyYAML
c C r4 )NzThe config file uses YAML syntax and must represent a YAML 'mapping' (for details, see http://learn.getgrav.org/advanced/yaml).r r5 r r r
r, r7 z+YAMLConfigFileParser.get_syntax_descriptionc C s& zddl }W |S ty tdw )zjlazy-import PyYAML so that configargparse doesn't have to depend
on it unless this parser is used.r NzJCould not import yaml. It can be installed by running 'pip install PyYAML')yaml ImportErrorr2 )r+ r r r r
_load_yaml! s
z YAMLConfigFileParser._load_yamlc
C s | }z||}W n ty } ztd| d }~ww t|ts2tdt|ddt|jf t }|
D ]\}}t|t rG|||< q9|d u rLq9t |||< q9|S )Nro zThe config file doesn't appear to contain 'key: value' pairs (aka. a YAML mapping). yaml.load('%s') returned type '%s' instead of 'dict'.r r- )
r safe_loadrV r2 r dictrY typer! r r/ r^ ra )r+ r- r
parsed_objr\ r{ r; r= r r r
r. , s(
zYAMLConfigFileParser.parseFc C s | }t|}|j||dS )N)default_flow_style)r r dump)r+ r/ r r r r r
r0 F s z YAMLConfigFileParser.serializeNF)r! r" r# r$ r, r r. r0 r r r r
r s r command_lineenvironment_variables config_filedefaultsc @ s e Zd ZdZdd ZdddejfddZdddejdfdd Zd
d Z d d d
Z
dd Z dd Z dd Z
dd Zdd Zdd ZejfddZd d ZdS ) r zDrop-in replacement for `argparse.ArgumentParser` that adds support for
environment variables and ``.ini`` or ``.yaml-style`` config files.
c O s | dd}| dd}| dd}| dg }| dd}| d t}| d
g } | d d}
| d d
} | dg } | dd}
| dt| _|| _|| _|| _tjj | g|R i | |du rht | _
n| | _
|| _ || _ | r| j
| d|
| dd | r| j
| dd|
dd dS dS )aR
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_helpTadd_env_var_helpauto_env_var_prefixNdefault_config_files ignore_unknown_config_file_keysFconfig_file_parser_class args_for_setting_config_pathconfig_arg_is_requiredconfig_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 exitsconfig_file_open_funcr )destrequiredhelpis_config_file_arg"write_out_config_file_to_this_pathCONFIG_OUTPUT_PATH)r metavarr is_write_out_config_file_arg)popr3 open_config_file_open_func_add_config_file_help_add_env_var_help_auto_env_var_prefixr r __init___config_file_parser_default_config_files _ignore_unknown_config_file_keys add_argument)r+ argsr r r r r r r r r r r r r r r
r ] s\ :
zArgumentParser.__init__Nc C s4 | j ||||dd\}}|r| dd| |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)r namespaceconfig_file_contentsenv_varsignore_help_argszunrecognized arguments: %sr? )parse_known_argserrorr_ )r+ r r r r argvr r r
parse_args s
zArgumentParser.parse_argsFc s du r t jdd nt tr nt jD ]}|j |_q |r.dd D t _
rAdt f}d|ij
t < j durjD ]5}
|}|r~|js~|js~|js~|js~t|tjs~t|tjs~|d j} j | dd |_qIg }
d } fd
djD } | D ]F}
|
j}| }|
jst|
tjrd } |d r|d
rzt |}W n t y dd |dd dD }Y nw |
|
||7 }
q| r߈ |
n|
|
rt fdd| D j
t < t!dd jD }|od v pd v }fddjD }g }|dur%t"|}d|_#|g}n|s-$ }t%|D ]}z-zj&'|}W n t(yT } z )| W Y d}~nd}~ww W t*|dr`|+ n t*|drl|+ w w g }d } |, D ]`\}}||v r|| }
t- |
jj}nd}
j.pt- /|gj}|s| |
||7 }dt0|j#f }|j
vrt j
|< |
|fj
| |< |
r|
jst|
tjrd } qu| r߈ | q1| q1t }jD ]E}
|
j p|
jt1t2fv }t- |
jjs|r|
j3du s|
j3t4kst|
t5rq|
jr#|
jd }n|
j6}|
t|
j3f||< q|r9|j
t7< tj8j9 d\} fd djD } d d | D } j:| d d | fS ) 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
NrK c S s g | ]}|d vr|qS ))-h--helpr )rG argr r r
rI z3ArgumentParser.parse_known_args..r@ r -_Fc s6 g | ]}|j s|jr|jv rt |jjs|qS r )is_positional_argenv_varalready_on_command_lineoption_strings prefix_charsrG a)r r r+ r r
rI s
Tr: rB c S rC r rD rF r r r
rI ) rJ rL rM c s g | ] }|j | |j ffqS r )r r )r r r
rI 4 s c s s | ] }t |tjr|V qd S r )r r _HelpActionr r r r
8 s
z2ArgumentParser.parse_known_args..r r c s" i | ]
} |D ]}||q qS r )get_possible_config_keys)rG r
config_keyr* r r
> s
z3ArgumentParser.parse_known_args..z
method argclosez%s|%s)r r c s& g | ]}t |d drt |jdqS )r FN)rY r r )r r r
rI s
c S s g | ]}|d ur|qS r r r r r r
rI r )
exit_after);sysr r ra rW r^ _actionsr r r _source_to_settings_COMMAND_LINE_SOURCE_KEYr r r r r r _VersionActionr rE r ry uppernargs
_AppendActionrO rS rT rU rV convert_item_to_command_line_arg_ENV_VAR_SOURCE_KEYanyr r _open_config_filesreversedr r. r2 r hasattrr r/ r r 4get_command_line_key_for_unknown_config_file_setting_CONFIG_FILE_SOURCE_KEYOPTIONAL ZERO_OR_MOREr SUPPRESS#ACTION_TYPES_THAT_DONT_NEED_A_VALUEr _DEFAULTS_SOURCE_KEYr r write_config_file) r+ r r r r r r a_v_pairconfig_file_keysstripped_config_file_key env_var_argsr actions_with_env_var_valuesr r; r= supports_help_argskip_config_file_parsingknown_config_keysconfig_streamsr- config_itemsr\ config_argsdiscard_this_key
source_keydefault_settingscares_about_default_value unknown_argsoutput_file_pathsr )r r r r+ r
r s$
z ArgumentParser.parse_known_argsc C s | j S )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
)r r* r r r
get_source_to_settings_dict s z*ArgumentParser.get_source_to_settings_dictc C s |D ].}z| |d}W d n1 sw Y W q ty0 } ztd||d}~ww |rr| | j|}| j|}|D ] }| |d
}|| W d n1 sZw Y qBt dd
| |rt| d dS dS dS )a4 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 r] r ) r IOErrorr rX get_items_for_config_file_outputr r r0 rb printr_ exit) r+ parsed_namespacer r output_file_path output_filer\ r
file_contentsr r r
r s6
z ArgumentParser.write_config_filec C s" | | j}| jd d | }|S )aM Compute 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 )rE r )r+ r; key_without_prefix_charscommand_line_keyr r r
r s zCArgumentParser.get_command_line_key_for_unknown_config_file_settingc C sb t }| D ]\}}|tkrJ|d \}}| jD ]0}| |} | rH|jsHt||j| jrHt ||j
d}
|
durHt |
t rBt
|
}
|
|| d < qq|tkrr| D ] \} \}}
| |} | rpt ||j
d}
|
durp|
|| d < qRq|tr| D ]
\} \}}
|
|| < q{q|tkr| D ] \} \}}
| |} | rt ||j
d}
|
dur|
|| d < qq|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 )r r/ r r r r r r r rY r r boolra lowerr rO r r ) r+ source_to_settingsr config_file_itemssourcesettingsr existing_command_line_argsr r r= r; r r r
r sR
z/ArgumentParser.get_items_for_config_file_outputc s: g }|du r | |}n t|s|jd }|durt|tr| dv r9t|s/|| |S ||jd |S | dv rPt|sF |S ||jd |S t|tjrw|D ] t fdd|jD rhd}qX||jd gt
| 7 }|S | d ||f |S t|t r|duo|j
duot|tjpt|tjo|j
d
v pt|j
t
o|j
dk}|du st|tjr|D ]&}|rt|t r|| |D ] }|t| qq|d |t|f q|S |r|| |D ] }|t| q|S | d ||f |S t|tr|d ||f |S td
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
NrL )rA yes1r )falseno0rK c s g | ]} |qS r rO )rG sr r r
rI * s zCArgumentParser.convert_item_to_command_line_arg..zQUnexpected value for %s: '%s'. Expecting 'true', 'false', 'yes', 'no', '1' or '0')+*z%s=%szp%s can't be set to a list '%s' 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 appendr _CountActionr intr r^ r _StoreActionr ra r rX r ) r+ r r; r= r r accepts_list_and_has_nargs list_elemsub_elemr r r
r sx
/, (%
z/ArgumentParser.convert_item_to_command_line_argc sP g }t |ddr
|S |jD ] t fdd| jD r%| dd g7 }q
|S )a 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 Nc 3 s | ]
} d | V qdS )r Nr )rG cr r r
r ] s z:ArgumentParser.get_possible_config_keys..r )rY r r r )r+ r keysr r r
r N s
z'ArgumentParser.get_possible_config_keysc
C sf g }t tjt tjj| jD ]}|D ]
}|| | qqdd | jD }|s*|S |D ]}t j
| j dd}| | dd }t
|||_|j|d} | sOq,| \}
} t|
|jd} | s]q,tj| } z| | }
W n@ ty } z4t|jd kr|j\}}nt|}|D ]}z| W q ty Y qw | d
| |f W Y d}~nd}~ww ||
g7 }q,|S ) 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[IO]: open config files
c S g | ]
}t |d dr|qS r FrY r r r r
rI v s
z5ArgumentParser._open_config_files..F)r add_helpc S s d S r r )r+ messager r r
error_method s z7ArgumentParser._open_config_files..error_method)r Nr z)Unable to open config file: %s. Error: %s)r` globospath
expanduserr r r r r r r _add_actiontypes
MethodTyper r rY r rV r r ra r )r+ command_line_args config_filesfilesf user_config_file_arg_actionsr
arg_parserr$
parsed_argr r user_config_filer- r\ errnor6 r r r r
r b sZ
z!ArgumentParser._open_config_filesc C s t dtdtdtdi}t }| j D ]Q\}}|d}||d t|dd }| | | D ]0\}\}}|rF| d
|d
| q2t |t rS| d | q2t |t
rb| d d | q2q| S )
zReturns 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:
|r rK Nz {:<19}{}
rh z %s
r? )r r r r r r r/ rW tuplerb rX r ra r^ r_ rc )r+ source_key_to_display_value_maprd r r r; r r= r r r
format_values s(
z ArgumentParser.format_valuesc C s | | dS )zBPrints the format_values() string (to sys.stdout or another file).N)rb r8 )r+ filer r r
print_values s zArgumentParser.print_valuesc s d}d}d} j rl j}d jd } fdd jD }dd jD }|rl|s+|rld _ d}|d ||d d f 7 }d
d d |D }|rLd
| }|sP|rc|dd
t|ttd |g 7 }|d j 7 } j rdd jD } | D ]%\}
} | j
t krqyd|
} | j
sd| _
| | j
vr| j
| 7 _
d}d _ qy|s|rdg}
|rdg|
}
|rdg|
}
|dd|
7 }t
jd}t||}tj |dkrd| S d S )Nr@ Fr r c s@ g | ] }|j D ]} |r |jd ks|js|js||fqqS )r )r r r r r )rG r r r* r r
rI s z.ArgumentParser.format_help..c S r r r! r r r r
rI s
TzCArgs that start with '%s' (eg. %s) can also be set in a config filez or c s s | ] }|j r|j d V qdS )r N)r r r r r
r s z-ArgumentParser.format_help..zspecified via z (%s).r? c S s" g | ]
}t |d dr|j|fqS )r N)rY r r r r r
rI s
z [env var: %s]r zconfig file valueszenvironment variableszT If an arg is specified in more than one place, then commandline values override %s.z which override z
{}
)r r r r r_ r6 filterr r, r r r max_get_formatter_widthtextwrapfillr r format_helprX )r+ r6 added_config_file_helpadded_env_var_helpr ccconfig_settable_argsconfig_path_actionsconfig_arg_stringenv_var_actionsr r env_var_help_string
value_sources
text_widthr r* r
rB sr
zArgumentParser.format_helpr )r! r" r# r$ r r& environr r r r r r r r r r8 r stdoutr: rB r r r r
r X s. j
6
/LK r c O s | dd}| ddp| dd}| dd}| j|i |}|j |_||_||_||_|jr7|r7td|jrDt|t j
sDtd|jr]d}t|t j
sUt|d |r]t|d
|S ) aH
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
r Nr 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_methodr r r r r r r r r )r+ r r r r r r error_prefixr r r
r s6
r c sb g | D ]!}|r |d |v r d|v r | dd\}} | q | qt fdd|D S )zUtility method for checking if any of the potential_command_line_args is
already present in existing_args.
Returns:
bool: already on command line?
r rg rK c 3 s | ]}| v V qd S r r )rG
potential_arg arg_namesr r
r T s
z*already_on_command_line..)rW r r )existing_args_listpotential_command_line_argsr
arg_string
option_string explicit_argr rS r
r E s r r )Kr$ r rT r% r& rP r r* collectionsr r@ version_infor r _StoreTrueAction_StoreFalseActionr _StoreConstAction_AppendConstActionr r r r r6 r r r r RawTextHelpFormatterRawDescriptionHelpFormatterr objectr& rV r2 r3 re r r r r r r r r _ActionsContainerrP
HelpFormatter
ArgumentErrorArgumentTypeErrorActionFileType Namespace ONE_OR_MOREr REMAINDERr r initArgumentParsergetArgumentParser getArgParser getParserget_arg_parser
get_parser ArgParserParseradd_argaddr r. r parse_known RawFormatterDefaultsFormatterDefaultsRawFormatterr r r r
s
(RI; 99