a Sic@sdZddlZddlZddlZddlZddlZddlmZmZddl m Z ddl m Z ddl m Z ddl mZddl mZejeejeed ZGd d d ZeZGd d d eeZddZddZdS)zDefines the FlagValues class - registry of 'Flag' objects. Do NOT import this module directly. Import the flags package and use the aliases defined at the package level instead. N)GenericTypeVar)minidom) _exceptions)_flag)_helpers)_validators_classes_Tc@seZdZdZddZdddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd d!Zdd"d#Zd$d%Zd&d'Zd(d)Zd*d+Zd,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Zdd?Z!d@dAZ"dBdCZ#dDdEZ$dFdGZ%ddIdJZ&dKdLZ'dMdNZ(dOdPZ)dQdRZ*dSdTZ+dUdVZ,dWdXZ-dYdZZ.d[d\Z/d]d^Z0dd`daZ1dbdcZ2ddddeZ3ddfdgZ4ddhdiZ5djdkZ6dldmZ7ddodpZ8dqdrZ9dsdtZ:dudvZ;ddwdxZd}d~Z?dddZ@ddZAdS) FlagValuesaRegistry of :class:`~absl.flags.Flag` objects. A :class:`FlagValues` can then scan command line arguments, passing flag arguments through to the 'Flag' objects that it owns. It also provides easy access to the flag values. Typically only one :class:`FlagValues` object is needed by an application: :const:`FLAGS`. This class is heavily overloaded: :class:`Flag` objects are registered via ``__setitem__``:: FLAGS['longname'] = x # register a new flag The ``.value`` attribute of the registered :class:`~absl.flags.Flag` objects can be accessed as attributes of this :class:`FlagValues` object, through ``__getattr__``. Both the long and short name of the original :class:`~absl.flags.Flag` objects can be used to access its value:: FLAGS.longname # parsed flag value FLAGS.x # parsed flag value (short name) Command line arguments are scanned and passed to the registered :class:`~absl.flags.Flag` objects through the ``__call__`` method. Unparsed arguments, including ``argv[0]`` (e.g. the program name) are returned:: argv = FLAGS(sys.argv) # scan command line arguments The original registered :class:`~absl.flags.Flag` objects can be retrieved through the use of the dictionary-like operator, ``__getitem__``:: x = FLAGS['longname'] # access the registered Flag object The ``str()`` operator of a :class:`absl.flags.FlagValues` object provides help for all of the registered :class:`~absl.flags.Flag` objects. cCsi|jd<t|jd<i|jd<i|jd<i|jd<d|jd<d|jd<d|jd <ttt|jd <d |jd <d|jd <d|jd<dS)N__flags __hiddenflags__flags_by_module__flags_by_module_id__key_flags_by_moduleF__flags_parsed__unparse_flags_called __set_unknown__banned_flag_namesT__use_gnu_getopt__use_gnu_getopt_explicitly_set__is_retired_flag_func)__dict__set frozensetdirr selfrR/var/www/html/django/DPS/env/lib/python3.9/site-packages/absl/flags/_flagvalues.py__init__Ss          zFlagValues.__init__TcCs||jd<d|jd<dS)aSets whether or not to use GNU style scanning. GNU style allows mixing of flag and non-flag arguments. See http://docs.python.org/library/getopt.html#getopt.gnu_getopt Args: gnu_getopt: bool, whether or not to use GNU style scanning. rTrNr)r gnu_getoptrrrset_gnu_getopts zFlagValues.set_gnu_getoptcCs |jdS)Nrr rrrr is_gnu_getoptszFlagValues.is_gnu_getoptcCs |jdSNr r rrrr_flagsszFlagValues._flagscCs |jdS)zReturns the dictionary of module_name -> list of defined flags. Returns: A dictionary. Its keys are module names (strings). Its values are lists of Flag objects. r r rrrrflags_by_module_dictszFlagValues.flags_by_module_dictcCs |jdS)zReturns the dictionary of module_id -> list of defined flags. Returns: A dictionary. Its keys are module IDs (ints). Its values are lists of Flag objects. rr rrrrflags_by_module_id_dictsz"FlagValues.flags_by_module_id_dictcCs |jdS)zReturns the dictionary of module_name -> list of key flags. Returns: A dictionary. Its keys are module names (strings). Its values are lists of Flag objects. rr rrrrkey_flags_by_module_dictsz#FlagValues.key_flags_by_module_dictcCs|}||g|dS)a#Records the module that defines a specific flag. We keep track of which flag is defined by which module so that we can later sort the flags by module. Args: module_name: str, the name of a Python module. flag: Flag, the Flag instance that is key to the module. N)r& setdefaultappend)r module_nameflagflags_by_modulerrrregister_flag_by_modules z"FlagValues.register_flag_by_modulecCs|}||g|dS)zRecords the module that defines a specific flag. Args: module_id: int, the ID of the Python module. flag: Flag, the Flag instance that is key to the module. N)r'r)r*)r module_idr,Zflags_by_module_idrrrregister_flag_by_module_idsz%FlagValues.register_flag_by_module_idcCs*|}||g}||vr&||dS)zSpecifies that a flag is a key flag for a module. Args: module_name: str, the name of a Python module. flag: Flag, the Flag instance that is key to the module. N)r(r)r*)rr+r,Zkey_flags_by_module key_flagsrrrregister_key_flag_for_modules z'FlagValues.register_key_flag_for_modulecCsH|}|j}||d|kr"dS|j}|durD||d|krDdSdS)zChecks whether a Flag object is registered under long name or short name. Args: flag_obj: Flag, the Flag instance to check for. Returns: bool, True iff flag_obj is registered under long name or short name. NTF)r%nameget short_name)rflag_obj flag_dictr3r5rrr_flag_is_registereds zFlagValues._flag_is_registeredcCsP||rdS|||fD]&}|D]}||vr0||q4q0q$dS)aCleans up unregistered flags from all module -> [flags] dictionaries. If flag_obj is registered under either its long name or short name, it won't be removed from the dictionaries. Args: flag_obj: Flag, the Flag instance to clean up for. N)r8r&r'r(valuesremove)rr6r&Zflags_in_modulerrr,_cleanup_unregistered_flag_from_module_dictss  z7FlagValues._cleanup_unregistered_flag_from_module_dictscCs6t|ts|j}|dkr"tjd}t||gS)a1Returns the list of flags defined by a module. Args: module: module|str, the module to get flags from. Returns: [Flag], a new list of Flag instances. Caller may update this list as desired: none of those changes will affect the internals of this FlagValue instance. __main__r) isinstancestr__name__sysargvlistr&r4)rmodulerrrget_flags_for_modules  zFlagValues.get_flags_for_modulecCsXt|ts|j}|dkr"tjd}||}||gD]}||vr<||q<|S)a2Returns the list of key flags for a module. Args: module: module|str, the module to get key flags from. Returns: [Flag], a new list of Flag instances. Caller may update this list as desired: none of those changes will affect the internals of this FlagValue instance. r<r) r=r>r?r@rArDr(r4r*)rrCr1r,rrrget_key_flags_for_module s    z#FlagValues.get_key_flags_for_moduleNcCsb||}|dur|S|D]6\}}|D](}|j|jkr2|j|jkr2|Sq2q&|S)a~Return the name of the module defining this flag, or default. Args: flagname: str, name of the flag to lookup. default: Value to return if flagname is not defined. Defaults to None. Returns: The name of the module which registered the flag with this name. If no such module exists (i.e. no flag with this name exists), we return default. N)r%r4r&itemsr3r5)rflagnamedefaultregistered_flagrCflagsr,rrrfind_module_defining_flag(s   z$FlagValues.find_module_defining_flagcCsb||}|dur|S|D]6\}}|D](}|j|jkr2|j|jkr2|Sq2q&|S)azReturn the ID of the module defining this flag, or default. Args: flagname: str, name of the flag to lookup. default: Value to return if flagname is not defined. Defaults to None. Returns: The ID of the module which registered the flag with this name. If no such module exists (i.e. no flag with this name exists), we return default. N)r%r4r'rFr3r5)rrGrHrIr/rJr,rrrfind_module_id_defining_flagAs   z'FlagValues.find_module_id_defining_flagcCs||jd<dS)zAllow set default values for undefined flags. Args: setter: Method(name, value) to call to __setattr__ an unknown flag. Must raise NameError or ValueError for invalid name/value. rNr )rsetterrrr_register_unknown_flag_setterZsz(FlagValues._register_unknown_flag_setterc Csh|jd}|rXz||||WSttfyFtd||YntyVYn0t||dS)a Returns value if setting flag |name| to |value| returned True. Args: name: str, name of the flag to set. value: Value to set. Returns: Flag value on successful call. Raises: UnrecognizedFlagError IllegalFlagValueError rz"{1}" is not valid for --{0}N)r TypeError ValueErrorrIllegalFlagValueErrorformat NameErrorUnrecognizedFlagError)rr3valuerMrrr_set_unknown_flagcs    zFlagValues._set_unknown_flagc CsX|D]F\}}||jkr z |||<Wq tjyPtjj|||dYq 0q dS)zAppends flags registered in another FlagValues instance. Args: flag_values: FlagValues, the FlagValues instance from which to copy flags. )other_flag_valuesN)r%rFr3rDuplicateFlagError from_flag)r flag_values flag_namer,rrrappend_flag_values}s  zFlagValues.append_flag_valuescCs|D]}||qdS)zRemove flags that were previously appended from another FlagValues. Args: flag_values: FlagValues, the FlagValues instance containing flags to remove. N) __delattr__)rrZr[rrrremove_flag_valuesszFlagValues.remove_flag_valuesc Cs|}t|tjst|t|ts2td|s@tdd|vrRtd|||||vr|j s||j st \}}| ||krt |||krdStj|||j}t}|dur||vr|j s||j stj||||vr|||kr||||||<||vs<||js<|jsj||vrb|||krb||||||<|D]}||qndS)zRegisters a new flag variable.zFlag name must be a stringzFlag name cannot be empty z Flag name cannot contain a spaceN)r%r=rFlagrrQr>Error_check_method_name_conflictsallow_overrider"get_calling_module_object_and_namerKidrLrXrYr5raddusing_default_valuer;) rr3r,flrCr+r5Zflags_to_cleanupfrrr __setitem__sJ          zFlagValues.__setitem__cCst|jdS)zReturns list of names of all defined flags. Useful for TAB-completion in ipython. Returns: [str], a list of names of all defined flags. r )sortedrrrrr__dir__szFlagValues.__dir__cCs ||S)z,Returns the Flag object for the flag --name.r%rr3rrr __getitem__szFlagValues.__getitem__cCs|jd|dS)z Marks the flag --name as hidden.r N)rrfrnrrr _hide_flagszFlagValues._hide_flagcCs^|}||vrt|||jdvr.t||jdsB||jrL||jStd|dS)z3Retrieves the 'value' attribute of the flag --name.r rz4Trying to access flag --%s before flags were parsed.N)r%AttributeErrorrpresentrUrUnparsedFlagAccessError)rr3rhrrr __getattr__s zFlagValues.__getattr__cCs|jfi||i|S)z.Sets the 'value' attribute of the flag --name.)_set_attributes)rr3rUrrr __setattr__szFlagValues.__setattr__cKs|}t}|D]H\}}||jdvr4t|||vrR|||_||q|||q|D]}|||j d||_ qddS)zCSets multiple flag values together, triggers validators afterwards.r FN) r%rrFrrqrUrfrV_assert_validators validatorsrg)r attributesrhZ known_flagsr3rUrrrrus  zFlagValues._set_attributescCs2t}|D]}||jq||dS)zVerifies whether all flags pass validation. Raises: AttributeError: Raised if validators work with a non-existing flag. IllegalFlagValueError: Raised if validation fails for at least one validator. N)rr%r9updaterxrw)rZall_validatorsr,rrrvalidate_all_flagsszFlagValues.validate_all_flagsc Csg}t}t|dddD]}zHt|tjr<|j|vrZWqnt|tjrZ|t|j@rZWq||Wqt j y}zbt|tjr| |jnt|tjr| t|j| |}|d|t|fWYd}~qd}~00q|rt d|dS)aAsserts if all validators in the list are satisfied. It asserts validators in the order they were created. Args: validators: Iterable(validators.Validator), validators to be verified. Raises: AttributeError: Raised if validators work with a non-existing flag. IllegalFlagValueError: Raised if validation fails for at least one validator. cSs|jSN)Zinsertion_index) validatorrrrz/FlagValues._assert_validators..keyz%s: %sN )rrkr=rZSingleFlagValidatorr[ZMultiFlagsValidator flag_namesverifyrValidationErrorrfrzZprint_flags_with_valuesr*r>rQjoin)rrxmessagesZ bad_flagsr}emessagerrrrws,        .zFlagValues._assert_validatorscCs4|}||vrt|||}||=||dS)aDeletes a previously-defined flag from a flag object. This method makes sure we can delete a flag by using del FLAGS. E.g., flags.DEFINE_integer('foo', 1, 'Integer flag.') del flags.FLAGS.foo If a flag is also registered by its the other name (long name or short name), the other name won't be deleted. Args: flag_name: str, the name of the flag to be deleted. Raises: AttributeError: Raised when there is no registered flag named flag_name. N)r%rqr;)rr[rhr6rrrr]'s zFlagValues.__delattr__cCsB|}||vr |||dS||||||jdS)aChanges the default value of the named flag object. The flag's current value is also updated if the flag is currently using the default value, i.e. not specified in the command line, and not set by FLAGS.name = value. Args: name: str, the name of the flag to modify. value: The new default value. Raises: UnrecognizedFlagError: Raised when there is no registered flag named name. IllegalFlagValueError: Raised when value is not valid. N)r%rV _set_defaultrwrx)rr3rUrhrrr set_defaultEs  zFlagValues.set_defaultcCs ||vS)z3Returns True if name is a value (flag) in the dict.rmrnrrr __contains__[szFlagValues.__contains__cCst|jdSr$)lenrrrrr__len___szFlagValues.__len__cCs t|Sr|)iterr%rrrr__iter__bszFlagValues.__iter__Fc Cst|ttfrtd|s"td|d}|j|dddd}|||\}}|D](\}}t|t |} t j ||| dqT| | |g|S) aDParses flags from argv; stores parsed flags into this FlagValues object. All unparsed arguments are returned. Args: argv: a tuple/list of strings. known_only: bool, if True, parse and remove known flags; return the rest untouched. Unknown flags specified by --undefok are not returned. Returns: The list of arguments not parsed as options, including argv[0]. Raises: Error: Raised on any parsing error. TypeError: Raised on passing wrong type of arguments. ValueError: Raised on flag value parsing error. zbytesrOrPread_flags_from_files _parse_argsrget_flag_suggestionsrBrrTmark_as_parsedr{) rrA known_only program_nameargs unknown_flags unparsed_argsr3rUrrrr__call__es& zFlagValues.__call__cCs tddS)Nzcan't pickle FlagValuesrOrrrr __getstate__szFlagValues.__getstate__cCs tddS)Nz`FlagValues does not support shallow copies. Use absl.testing.flagsaver or copy.deepcopy instead.rrrrr__copy__szFlagValues.__copy__cCs(tt|}|jt|j||Sr|)object__new__typerrzcopydeepcopy)rmemoresultrrr __deepcopy__szFlagValues.__deepcopy__cCs||jd<dS)aLSets a function for checking retired flags. Do not use it. This is a private absl API used to check retired flags registered by the absl C++ flags library. Args: is_retired_flag_func: Callable(str) -> (bool, bool), a function takes flag name as parameter, returns a tuple (is_retired, type_is_bool). rNr )rZis_retired_flag_funcrrr_set_is_retired_flag_funcs z$FlagValues._set_is_retired_flag_funccsg}t}|jd}|}tD]Ddfdd}dsl|df|rfq(nqpdkr|r|dfqpdrdd}n dd}d |vr|d d\} n |d} | s|df|rq(nqp| d kr>||d d d D|dd d Dq(| | } | durr| j rjdurjdn|n\| drt | dkr| | dd} | dur| j rΈdurt d| } d|rD| durD|| \} } | s| dr|| dd\} } | o| } | rD| s6dur6|t d| q(| dur`| d| _q(|| fq(g}g}|D]P\} | dur|n0| |vrq|n |r|n|| fq||t||fS)aHelper function to do the main argument parsing. This function goes through args and does the bulk of the flag parsing. It will find the corresponding flag in our flag dictionary, and call its .parse() method on the flag value. Args: args: [str], a list of strings with the arguments to parse. known_only: bool, if True, parse and remove known flags; return the rest untouched. Unknown flags specified by --undefok are not returned. Returns: A tuple with the following: unknown_flags: List of (flag name, arg) for flags we don't know about. unparsed_args: List of arguments we did not parse. Raises: Error: Raised on any parsing error. ValueError: Raised on flag value parsing error. rNcs<zdurtnWSty6tdYn0dS)NzMissing value for flag )next StopIterationrrarargrrUrr get_values z)FlagValues._parse_args..get_value---r=undefokcss|]}|VqdSr|strip.0vrrr rz)FlagValues._parse_args..,css|]}d|VqdS)noNrrrrrrrtruerz does not take an argumentfalsezGFlag "%s" is retired and should no longer be specified. See go/totw/90.F)rrr%r startswithr*r#splitrzr4booleanrrPloggingerrorparsergextendrB)rrrZunparsed_names_and_argsrZretired_flag_funcr7rZarg_without_dashesr3r,ZnoflagZ is_retiredZis_boolrrrrrrs                    zFlagValues._parse_argscCs |jdS)z"Returns whether flags were parsed.rr rrrr is_parsed1szFlagValues.is_parsedcCsd|jd<dS)aExplicitly marks flags as parsed. Use this when the caller knows that this FlagValues has been parsed as if a ``__call__()`` invocation has happened. This is only a public method for use by things like appcommands which do additional command like parsing. TrNr rrrrr5szFlagValues.mark_as_parsedcCs<|D] }|q tdd|jd<d|jd<dS)zBUnparses all flags to the point before any FLAGS(argv) was called.z;unparse_flags() called; flags access will now raise errors.FrTrN)r%r9unparserinfor)rrirrr unparse_flags>s    zFlagValues.unparse_flagscCsdd|DS)z9Returns a dictionary that maps flag names to flag values.cSsi|]\}}||jqSr)rU)rr3r,rrr Jrz/FlagValues.flag_values_dict..)r%rFrrrrflag_values_dictHszFlagValues.flag_values_dictcCs|S)z*Returns a help string for all known flags.)get_helprrrr__str__LszFlagValues.__str__cCs|}|rHt|}tjd}||vr:|||g|}||||Sg}|}|rrt |t j }| |||d |SdS)aReturns a help string for all known flags. Args: prefix: str, per-line output prefix. include_special_flags: bool, whether to include description of SPECIAL_FLAGS, i.e. --flagfile and --undefok. Returns: str, formatted help message. rrN)r&rkr@rAr:_get_help_for_modulesr%r9 itertoolschainr SPECIAL_FLAGS_render_flag_listr)rprefixinclude_special_flagsr-modulesZ main_module output_linesr9rrrrPs     zFlagValues.get_helpcCsDg}|D]}||||q|r:|dtj||d|S)apReturns the help string for a list of modules. Private to absl.flags package. Args: modules: List[str], a list of modules to get the help string for. prefix: str, a string that is prepended to each generated help line. include_special_flags: bool, whether to include description of SPECIAL_FLAGS, i.e. --flagfile and --undefok. z absl.flagsr)_render_our_module_flags_render_module_flagsrrr%r9r)rrrrrrCrrrrns  z FlagValues._get_help_for_modulescCs8t|ts|j}|d||f||||ddS))Returns a help string for a given module.z %s%s: N)r=r>r?r*r)rrCrJrrrrrrs zFlagValues._render_module_flagscCs"||}|r|||||dS)rN)rDr)rrCrrrJrrrrs z#FlagValues._render_our_module_flagscCs"||}|r|||||dS)aJReturns a help string for the key flags of a given module. Args: module: module|str, the module to render key flags for. output_lines: [str], a list of strings. The generated help message lines will be appended to this list. prefix: str, a string that is prepended to each generated help line. N)rEr)rrCrrr1rrr_render_our_module_key_flagss z'FlagValues._render_our_module_key_flagscCsg}|||d|S)zDescribes the key flags of a module. Args: module: module|str, the module to describe the key flags for. Returns: str, describing the key flags of a module. r)rr)rrCZhelplistrrr module_helps  zFlagValues.module_helpcCs|tjdS)zvDescribes the key flags of the main module. Returns: str, describing the key flags of the main module. r)rr@rArrrrmain_module_helpszFlagValues.main_module_helprc CsB|}tj}dd|D}|i}|D] \}}||d|kr\||d|kr\q0||vrfq0d||<d} |jr| d|j7} |jr| d|j7} n| d|j7} | d7} |jr| |j7} tj | |d |d } |j r| d 7} | tj d |j |d d 7} |j j r2| d 7} | tj d|j j |d d 7} | | q0dS)NcSsg|]}|j|fqSrr3)rr,rrr rz0FlagValues._render_flag_list..rrz-%s,z --[no]%s:z--%s:r_r)indentfirstline_indentrz (default: %s))rz(%s))r%rrsortr4r5rr3help text_wrapdefault_as_strparsersyntactic_helpr*) rflaglistrrrhZ special_flZflagsetr3r,ZflaghelprrrrsD     zFlagValues._render_flag_listcCs||}|dur|S|SdS)zReturns the value of a flag (if not None) or a default value. Args: name: str, the name of a flag. default: Default value to use if the flag value is None. Returns: Requested flag value or default. N)rt)rr3rHrUrrrget_flag_values zFlagValues.get_flag_valuecCsFt|trB|drdS|dkr$dS|dr2dS|dkr>dSdSdS)z@Checks whether flag_string contain a --flagfile= directive. --flagfile=r --flagfile -flagfile= -flagfiler)r=r>r)rZ flag_stringrrr_is_flag_file_directives   z"FlagValues._is_flag_file_directivecCs^|dr&tj|tddS|drLtj|tddStd|dS)aReturns filename from a flagfile_str of form -[-]flagfile=filename. The cases of --flagfile foo and -flagfile foo shouldn't be hitting this function, as they are dealt with in the level above this function. Args: flagfile_str: str, the flagfile string. Returns: str, the filename from a flagfile_str of form -[-]flagfile=filename. Raises: Error: Raised when illegal --flagfile is provided. rNrzHit illegal --flagfile type: %s)rospath expanduserrrrra)rZ flagfile_strrrr_extract_filenames   zFlagValues._extract_filenamec Cs&|sgS|durg}||vr2tjd|fgS||g}g}zt|d}Wn2ty}ztd|WYd}~n d}~00||}Wdn1s0Y|D]b}| rq| ds| drq| |r | |}|j ||d} || q||q||S)aReturns the useful (!=comments, etc) lines from a file with flags. Args: filename: str, the name of the flag file. parsed_file_stack: [str], a list of the names of the files that we have recursively encountered at the current depth. MUTATED BY THIS FUNCTION (but the original value is preserved upon successfully returning from function call). Returns: List of strings. See the note below. NOTE(springer): This function checks for a nested --flagfile= tag and handles the lower file recursively. It returns a list of all the lines that _could_ contain command flags. This is EVERYTHING except whitespace lines and comments (lines starting with '#' or '//'). NzAWarning: Hit circular flagfile dependency. Ignoring flagfile: %s rz#ERROR:: Unable to open flagfile: %s#z//)parsed_file_stack)r@stderrwriter*openIOErrorrCantOpenFlagFileError readlinesisspacerrr_get_flag_file_linesrrpop) rfilenamerZ line_listZflag_line_listfile_objZe_msglineZ sub_filenameZincluded_flagsrrrrsD &   zFlagValues._get_flag_file_linesc Cs*|}g}|r|d}|dd}||r|dks<|dkrh|sJtdtj|d}|dd}n ||}|||q| ||dkrq| ds|s|j d sqqd |vr|r|d ds| }| d}||vr||js|d}|dd}| |q|r&|||S) aProcesses command line args, but also allow args to be read from file. Args: argv: [str], a list of strings, usually sys.argv[1:], which may contain one or more flagfile directives of the form --flagfile="./filename". Note that the name of the program (sys.argv[0]) should be omitted. force_gnu: bool, if False, --flagfile parsing obeys the FLAGS.is_gnu_getopt() value. If True, ignore the value and always follow gnu_getopt semantics. Returns: A new list which has the original list combined with what we read from any flagfile(s). Raises: IllegalFlagValueError: Raised when --flagfile is provided with no argument. This function is called by FLAGS(argv). It scans the input list for a flag that looks like: --flagfile=. Then it opens , reads all valid key and value pairs and inserts them into the input list in exactly the place where the --flagfile arg is found. Note that your application's flags are still defined the usual way using absl.flags DEFINE_flag() type functions. Notes (assuming we're getting a commandline of some sort as our input): * For duplicate flags, the last one we hit should "win". * Since flags that appear later win, a flagfile's settings can be "weak" if the --flagfile comes at the beginning of the argument sequence, and it can be "strong" if the --flagfile comes at the end. * A further "--flagfile=" CAN be nested in a flagfile. It will be expanded in exactly the spot where it is found. * In a flagfile, a line beginning with # or // is a comment. * Entirely blank lines _should_ be ignored. rrNrrz--flagfile with no argumentrrrr)rrrQrrrrrrr*rrr%lstripr) rrArZ rest_of_argsZnew_argvZ current_argZ flag_filenamerhr3rrrrTsB'           z FlagValues.read_flags_from_filescCsZt|}d}|D]<\}}t|ddd}|D]}|jdur4||d7}q4q|S)aReturns a string with the flags assignments from this FlagValues object. This function ignores flags whose value is None. Each flag assignment is separated by a newline. NOTE: MUST mirror the behavior of the C++ CommandlineFlagsIntoString from https://github.com/gflags/gflags. Returns: str, the string with the flags assignments from this FlagValues object. The flags are ordered by (module_name, flag_name). rcSs|jSr|r)rirrrr~rz.FlagValues.flags_into_string..rNr)rkr&rFrU serialize)rZ module_flagssZunused_module_namerJr,rrrflags_into_strings   zFlagValues.flags_into_stringcCs<t|d}||Wdn1s.0YdS)aAppends all flags assignments from this FlagInfo object to a file. Output will be in the format of a flagfile. NOTE: MUST mirror the behavior of the C++ AppendFlagsIntoFile from https://github.com/gflags/gflags. Args: filename: str, name of the file. aN)rrr)rrout_filerrrappend_flags_into_files z!FlagValues.append_flags_into_filec Cs2t}|d}|||t|dtjt j dt j dj }|s^dt j d}n| dt j d}|t|d||t j d}|}t|}||D]J}dd ||D} | | D]&\} } | |v} || j||| d qq|p t j}||jd d d d |dS)aOutputs flag documentation in XML format. NOTE: We use element names that are consistent with those used by the C++ command-line flag library, from https://github.com/gflags/gflags. We also use a few new elements (e.g., ), but we do not interfere / overlap with existing XML elements used by the C++ library. Please maintain this consistency. Args: outfile: File object we write to. Default None means sys.stdout. ZAllFlagsprogramrr<z USAGE: %s [flags] z%susagecSsg|]}|j|fqSrr)rrirrrrrz7FlagValues.write_help_in_xml_format..)is_keyrzutf-8)rencodingN)rDocument createElement appendChildrcreate_xml_dom_elementrrbasenamer@rAr__doc__replacerEr&rBkeysr_create_xml_dom_elementstdoutr toprettyxmldecodeflush) routfiledocZall_flagZ usage_docr1r-Zall_module_namesr+Z flag_listZunused_flag_namer,r rrrwrite_help_in_xml_formatsH        z#FlagValues.write_help_in_xml_formatcCs\|jr dS|j}|dur|hn||h}|D],}||jdvr*tdj|t|jdq*dS)NrzCannot define a flag named "{name}". It conflicts with a method on class "{class_name}". To allow defining it, use allow_using_method_names and access the flag value with FLAGS['{name}'].value. FLAGS.{name} returns the method, not the flag value.)r3 class_name)allow_using_method_namesr5rr FlagNameConflictsWithMethodErrorrRrr?)rr3r,r5rr[rrrrbs z'FlagValues._check_method_name_conflicts)T)N)N)F)rT)r)r)r)r)N)T)N)Br? __module__ __qualname__rrr"r#r%r&r'r(r.r0r2r8r;rDrErKrLrNrVr\r^rjrlrorprtrvrur{rwr]rrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrbrrrrr 's+.          (  # ,          ' C S 4r c@s^eZdZdZdddZddZddZeZed d Z ed d Z ed dZ eddZ dS) FlagHolderaHolds a defined flag. This facilitates a cleaner api around global state. Instead of:: flags.DEFINE_integer('foo', ...) flags.DEFINE_integer('bar', ...) def method(): # prints parsed value of 'bar' flag print(flags.FLAGS.foo) # runtime error due to typo or possibly bad coding style. print(flags.FLAGS.baz) it encourages code like:: _FOO_FLAG = flags.DEFINE_integer('foo', ...) _BAR_FLAG = flags.DEFINE_integer('bar', ...) def method(): print(_FOO_FLAG.value) print(_BAR_FLAG.value) since the name of the flag appears only once in the source code. FcCs||_|j|_||_dS)aConstructs a FlagHolder instance providing typesafe access to flag. Args: flag_values: The container the flag is registered to. flag: The flag object for this flag. ensure_non_none_value: Is the value of the flag allowed to be None. N) _flagvaluesr3_name_ensure_non_none_value)rrZr,ensure_non_none_valuerrrr,szFlagHolder.__init__cCs tdt|jt|jdS)Nz^unsupported operand type(s) for ==: '{0}' and '{1}' (did you mean to use '{0}.value' instead?)rOrRrr?)rotherrrr__eq__?s zFlagHolder.__eq__cCstdt|jdS)Nz[bool() not supported for instances of type '{0}' (did you mean to use '{0}.value' instead?)r(rrrr__bool__Es zFlagHolder.__bool__cCs|jSr|)r%rrrrr3MszFlagHolder.namecCs0t|j|j}|jr,|dur,td|j|S)aReturns the value of the flag. If ``_ensure_non_none_value`` is ``True``, then return value is not ``None``. Raises: UnparsedFlagAccessError: if flag parsing has not finished. IllegalFlagValueError: if value is None unexpectedly. Nz!Unexpected None value for flag %s)getattrr$r%r&rrQ)rvalrrrrUQs zFlagHolder.valuecCs|j|jjS)z&Returns the default value of the flag.)r$r%rHrrrrrHbszFlagHolder.defaultcCst|j|jjS)zs6     q[