xdZddlmZddlmZddlmZddlZddlZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd lm Z  dd lmZmZmZ ddlZe j(j+eej.ed Ze j4dddfdZe j4ddfdZe j4dfdZe j4fdZe j4fdZdZ e j4dfdZ!e j4ddfdZ"dde j4dfdZ#dde j4dfdZ$e j4ddfdZ%e j4dddfdZ&e j4dfdZ'de j4dfdZ(e j4ddfdZ)e j4dfdZ*dde j4dfdZ+dde j4dfd Z,e j4d!dfd"Z-e j4dddfd#Z.e j4dfd$Z/y#e$rYwxYw#e$rYwxYw)%zThis modules contains flags DEFINE functions. Do NOT import this module directly. Import the flags package and use the aliases defined at the package level instead. )absolute_import)division)print_functionN)_argument_parser) _exceptions)_flag) _flagvalues)_helpers) _validators)TextListAnycrj jfd}tj|||yy)zEnforces lower and upper bounds for numeric flags. Args: parser: NumericParser (either FloatParser or IntegerParser), provides lower and upper bounds, and help text to display. name: str, name of the flag flag_values: FlagValues. Ncx|7j|r&|dj}tj|y)Nz is not T)is_outside_boundssyntactic_helprValidationError)valuemessageparsers .platform/bq/third_party/absl/flags/_defines.pycheckerz5_register_bounds_validator_if_needed..checker<s:  v77>$)6+@+@A))'22  flag_values) lower_bound upper_boundr register_validator)rnamerrs` r$_register_bounds_validator_if_neededr 1s; #v'9'9'E ""4kJ(FrFc Nttj|||||fi||||S)aRegisters a generic Flag object. NOTE: in the docstrings of all DEFINE* functions, "registers" is short for "creates a new flag and registers it". Auxiliary function: clients should use the specialized DEFINE_ function instead. Args: parser: ArgumentParser, used to parse the flag arguments. name: str, the flag name. default: The default value of the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. serializer: ArgumentSerializer, the flag serializer instance. module_name: str, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. required: bool, is this a required flag. This must be used as a keyword argument. **args: dict, the extra keyword args that are passed to Flag __init__. Returns: a handle to defined flag. ) DEFINE_flagrFlag) rrdefaulthelpr serializer module_namerequiredargss rDEFINEr*Es2F  jjT7DADA;8 rc|r$|jtd|jz|}|||j<|r tjj |}nt j\}}|j|||jt|||r tj|j||jduxs|}tj|||S)aHRegisters a 'Flag' object with a 'FlagValues' object. By default, the global FLAGS 'FlagValue' object is used. Typical users will use one of the more specialized DEFINE_xxx functions, such as DEFINE_string or DEFINE_integer. But developers who need to create Flag objects themselves should use this function to register their flags. Args: flag: Flag, a flag that is key to the module. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: str, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. required: bool, is this a required flag. This must be used as a keyword argument. Returns: a handle to defined flag. Nz1Required flag --%s cannot have a non-None default)ensure_non_none_value)r$ ValueErrorrsysmodulesgetr "get_calling_module_object_and_nameregister_flag_by_moduleregister_flag_by_module_ididr mark_flag_as_requiredr FlagHolder)flagrr'r(fvmoduler,s rr"r"ms4$,,* HYY  ""TYY- [[__[ )F"EEGFK %%k48 ((FT: %%dii4<rc|tjvrt|gtj|y t|g|y#t$rt d|zwxYw)a1Declares one flag as key to the current module. Key flags are flags that are deemed really important for a module. They are important when listing help messages; e.g., if the --helpshort command-line flag is used, then only the key flags of the main module are listed (instead of all flags, as in the case of --helpfull). Sample usage: flags.declare_key_flag('flag_1') Args: flag_name: str, the name of an already declared flag. (Redeclaring flags as key, including flags implicitly key because they were declared in this module, is a no-op.) flag_values: FlagValues, the FlagValues instance in which the flag will be declared as a key flag. This should almost never need to be overridden. Raises: ValueError: Raised if flag_name not defined as a Python flag. rr>NrzNFlag --%s is undefined. To set a flag as a key flag first define it in Python.)r SPECIAL_FLAGSr@KeyErrorr-)r?rs rdeclare_key_flagrEsk.((((   ,4,B,B0;= ? E ? 24=> ???s AAct|tjstjd|dt |j |jDcgc]}|jc}||tjk(rTt tjDcgc]}tj|j!c}tj|yycc}wcc}w)aDeclares that all flags key to a module are key to the current module. Args: module: module, the module object from which all key flags will be declared as key flags to the current module. flag_values: FlagValues, the FlagValues instance in which the flags will be declared as key flags. This should almost never need to be overridden. Raises: Error: Raised when given an argument that is a module name (a string), instead of a module object. zExpected a module object, not .rrBN) isinstancetypes ModuleTyperErrorr@get_key_flags_for_module__name__rr FLAGS_MODULErC)r9rfrs radopt_module_key_flagsrPs FE,, -   6K LL";;FOOLML!qvvLM x$$$ 8@7M7MN7Mt   % * *7MN**#%%N Os C$Cctjdj}tj|\}}tj j t|y)aDeclares that the current module will not define any more key flags. Normally, the module that calls the DEFINE_xxx functions claims the flag to be its key flag. This is undesirable for modules that define additional DEFINE_yyy functions with its own flag parsers and serializers, since that module will accidentally claim flags defined by DEFINE_yyy as its key flags. After calling this function, the module disclaims flag definitions thereafter, so the key flags will be correctly attributed to the caller of DEFINE_yyy. After calling this function, the module will not be able to define any more flags. This function will affect all FlagValues objects. N)r. _getframe f_globalsr get_module_object_and_namedisclaim_module_idsaddr4)globals_for_callerr9_s rdisclaim_key_flagsrZsF}}Q'11112DE)&! ""2f:.rc xtj}tj}t||||||fd|i|S)z/Registers a flag whose value can be any string.r()rArgumentParserArgumentSerializerr*rr$r%rr(r)rr&s r DEFINE_stringr_sS  * * ,&224*          rc Jttj|||fi||||S)aRegisters a boolean flag. Such a boolean flag does not take an argument. If a user wants to specify a false value explicitly, the long option beginning with 'no' must be used: i.e. --noflag This flag will have a value of None, True or False. None is possible if default=None and the user does not specify the flag on the command line. Args: name: str, the flag name. default: bool|str|None, the default value of the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: str, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. required: bool, is this a required flag. This must be used as a keyword argument. **args: dict, the extra keyword args that are passed to Flag __init__. Returns: a handle to defined flag. )r"r BooleanFlag)rr$r%rr'r(r)s rDEFINE_booleanrb)s0B  gt4t4k; rc tj||}tj} t|||||| fd|i|} t |||| S)aRegisters a flag whose value must be a float. If lower_bound or upper_bound are set, then this flag must be within the given range. Args: name: str, the flag name. default: float|str|None, the default value of the flag. help: str, the help message. lower_bound: float, min value of the flag. upper_bound: float, max value of the flag. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: dict, the extra keyword args that are passed to DEFINE. Returns: a handle to defined flag. r(r)r FloatParserr]r*r rr$r%rrrr(r)rr&results r DEFINE_floatrgOsg:  ' ' [ A&224*          &'vtM -rc tj||}tj} t|||||| fd|i|} t |||| S)aRegisters a flag whose value must be an integer. If lower_bound, or upper_bound are set, then this flag must be within the given range. Args: name: str, the flag name. default: int|str|None, the default value of the flag. help: str, the help message. lower_bound: int, min value of the flag. upper_bound: int, max value of the flag. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: dict, the extra keyword args that are passed to DEFINE. Returns: a handle to defined flag. r(r)r IntegerParserr]r*r res rDEFINE_integerrj{sg:  ) )+{ C&224*          &'vtM -rc Lttj||||fi||||S)aRegisters a flag whose value can be any string from enum_values. Instead of a string enum, prefer `DEFINE_enum_class`, which allows defining enums from an `enum.Enum` class. Args: name: str, the flag name. default: str|None, the default value of the flag. enum_values: [str], a non-empty list of strings with the possible values for the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: str, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. required: bool, is this a required flag. This must be used as a keyword argument. **args: dict, the extra keyword args that are passed to Flag __init__. Returns: a handle to defined flag. )r"rEnumFlag)rr$ enum_valuesr%rr'r(r)s r DEFINE_enumrns/>  nnT7D+>> 8 rc Pttj||||fd|i||||S)a~Registers a flag whose value can be the name of enum members. Args: name: str, the flag name. default: Enum|str|None, the default value of the flag. enum_class: class, the Enum class with all the possible values for the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: str, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. case_sensitive: bool, whether to map strings to members of the enum_class without considering case. required: bool, is this a required flag. This must be used as a keyword argument. **args: dict, the extra keyword args that are passed to Flag __init__. Returns: a handle to defined flag. case_sensitive)r"r EnumClassFlag rr$ enum_classr%rr'rpr(r)s rDEFINE_enum_classrtsH<        (     X 77rc ztj}tjd}t||||||fd|i|S)akRegisters a flag whose value is a comma-separated list of strings. The flag value is parsed with a CSV parser. Args: name: str, the flag name. default: list|str|None, the default value of the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. ,r()r ListParserCsvListSerializerr*r^s r DEFINE_listrysU2  & & (&11#6*          rc ~tj|}tjd}t||||||fd|i|S)aTRegisters a flag whose value is a whitespace-separated list of strings. Any whitespace can be used as a separator. Args: name: str, the flag name. default: list|str|None, the default value of the flag. help: str, the help message. comma_compat: bool - Whether to support comma as an additional separator. If false then only whitespace is supported. This is intended only for backwards compatibility with flags that used to be comma-separated. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. ) comma_compat r()rWhitespaceSeparatedListParserListSerializerr*) rr$r%r{rr(r)rr&s rDEFINE_spaceseplistrsZ:  9 9 !&..s3*          rc Nttj|||||fi||||S)aIRegisters a generic MultiFlag that parses its args with a given parser. Auxiliary function. Normal users should NOT use it directly. Developers who need to create their own 'Parser' classes for options which can appear multiple times can call this module function to register their flags. Args: parser: ArgumentParser, used to parse the flag arguments. serializer: ArgumentSerializer, the flag serializer instance. name: str, the flag name. default: Union[Iterable[T], Text, None], the default value of the flag. If the value is text, it will be parsed as if it was provided from the command line. If the value is a non-string iterable, it will be iterated over to create a shallow copy of the values. If it is None, it is left as-is. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: A string, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. )r"r MultiFlag) rr&rr$r%rr'r(r)s r DEFINE_multirDs2P  oofj$FF; **rc xtj}tj}t||||||fd|i|S)a<Registers a flag whose value can be a list of any strings. Use the flag on the command line multiple times to place multiple string values into the list. The 'default' may be a single string (which will be converted into a single-element list) or a list of strings. Args: name: str, the flag name. default: Union[Iterable[Text], Text, None], the default value of the flag; see `DEFINE_multi`. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. r()rr\r]rr^s rDEFINE_multi_stringrqsS<  * * ,&224*          rc |tj||}tj} t|| ||||fd|i|S)aRegisters a flag whose value can be a list of arbitrary integers. Use the flag on the command line multiple times to place multiple integer values into the list. The 'default' may be a single integer (which will be converted into a single-element list) or a list of integers. Args: name: str, the flag name. default: Union[Iterable[int], Text, None], the default value of the flag; see `DEFINE_multi`. help: str, the help message. lower_bound: int, min values of the flag. upper_bound: int, max values of the flag. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. r()rrir]r rr$r%rrrr(r)rr&s rDEFINE_multi_integerrsXB  ) )+{ C&224*          rc |tj||}tj} t|| ||||fd|i|S)aRegisters a flag whose value can be a list of arbitrary floats. Use the flag on the command line multiple times to place multiple float values into the list. The 'default' may be a single float (which will be converted into a single-element list) or a list of floats. Args: name: str, the flag name. default: Union[Iterable[float], Text, None], the default value of the flag; see `DEFINE_multi`. help: str, the help message. lower_bound: float, min values of the flag. upper_bound: float, max values of the flag. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. r()rrdr]rrs rDEFINE_multi_floatrsXB  ' ' [ A&224*          rTc |tj||}tj} t|| ||||fd|i|S)aRegisters a flag whose value can be a list strings from enum_values. Use the flag on the command line multiple times to place multiple enum values into the list. The 'default' may be a single string (which will be converted into a single-element list) or a list of strings. Args: name: str, the flag name. default: Union[Iterable[Text], Text, None], the default value of the flag; see `DEFINE_multi`. enum_values: [str], a non-empty list of strings with the possible values for the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. case_sensitive: Whether or not the enum is to be case-sensitive. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. r()r EnumParserr]r) rr$rmr%rrpr(r)rr&s rDEFINE_multi_enumrsXD  & &{N C&224*          rc Rttj|||||||fd|i|S)a2Registers a flag whose value can be a list of enum members. Use the flag on the command line multiple times to place multiple enum values into the list. Args: name: str, the flag name. default: Union[Iterable[Enum], Iterable[Text], Enum, Text, None], the default value of the flag; see `DEFINE_multi`; only differences are documented here. If the value is a single Enum, it is treated as a single-item list of that Enum value. If it is an iterable, text values within the iterable will be converted to the equivalent Enum objects. enum_class: class, the Enum class with all the possible values for the flag. help: str, the help message. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: A string, the name of the Python module declaring this flag. If not provided, it will be computed using the stack trace of this call. case_sensitive: bool, whether to map strings to members of the enum_class without considering case. required: bool, is this a required flag. This must be used as a keyword argument. **args: Dictionary with extra keyword args that are passed to the Flag __init__. Returns: a handle to defined flag. )rpr()r"rMultiEnumClassFlagrrs rDEFINE_multi_enum_classr'sFL   z.J       rc ||vrtj|||Gfddtj}djz}t |j j|j|j||S)a?Defines an alias flag for an existing one. Args: name: str, the flag name. original_name: str, the original flag name. flag_values: FlagValues, the FlagValues instance with which the flag will be registered. This should almost never need to be overridden. module_name: A string, the name of the module that defines this flag. Returns: a handle to defined flag. Raises: flags.FlagError: UnrecognizedFlagError: if the referenced flag doesn't exist. DuplicateFlagError: if the alias name has been used by some existing flag. c^eZdZdZfdZdZefdZejfdZy) DEFINE_alias.._FlagAliaszCOverrides Flag class so alias value is copy of original flag value.cRj||xjdz c_y)NrR)parsepresent)selfargumentr7s rrz&DEFINE_alias.._FlagAlias.parsess jj llalrc|SN)rrs r_parse_from_defaultz4DEFINE_alias.._FlagAlias._parse_from_defaultws lrcjSrr)rr7s rrz&DEFINE_alias.._FlagAlias.values ZZrc|_yrr)rrr7s rrz&DEFINE_alias.._FlagAlias.values djrN) rM __module__ __qualname____doc__rrpropertyrsetter)r7sr _FlagAliasrps<M \\rrzAlias for --%s.)boolean) rUnrecognizedFlagErrorrr#rr"rr&r$r)r original_namerr'rhelp_msgr7s @r DEFINE_aliasrVs,+%  + +M :: ] #$5::. *(  ++ //  ,, ,,  "-k ;;r)0r __future__rrrr.rI absl.flagsrrrr r r typingr r r ImportErrorenumrVrWr4r/rMr FLAGSr*r"r@rErPrZr_rbrgrjrnrtryrrrrrrrrrrrrsZ '% '"""$$   CKK$9!:;K2!! %T!!  +=^-8,=,=04?@-8,=,=$?N0;/@/@%>/.!!  2!!  #T!! )`!! )b!! !R!! %7X!!  #T!!  (b!! **b!!  (^!! +d!! +f!! ,h!! ,d!! :;c s$ G G$G! G!$G-,G-