a ijoN@s&dZddlmZddlZddlZddlZddlmZmZm Z m Z m Z m Z m Z mZmZddlmZddlmZddlmZddlmZed Zed ejd ZejGd d d e eZGdddeeZGdddeeZGdddeeZGddde eee eZ Gddde eZ!dS)zContains Flag class - information about single command-line flag. Do NOT import this module directly. Import the flags package and use the aliases defined at the package level instead. )abcN) AnyDictGenericIterableListOptionalTypeTypeVarUnion)minidom)_argument_parser) _exceptions)_helpers_T_ET)boundc@seZdZUdZeeed<eeed<eeeefed<e j eed<d=e j eee j eeeeeefeeeee e e e e e dd d d Z eeed d dZejeedddZddZddZddZddZddZddZeeefdddd Zeeeed!d"d#Zeeefdd$d%d&Zeeefeed$d'd(Zdd d)d*Zed d+d,Zeeed!d-d.Z eeeefdd!d/d0Z!eeefeed!d1d2Z"ed d3d4Z#d>e$j%ee e$j&d5d6d7Z'eeed!d8d9Z(e$j%e)e$j&d:d;d<Z*dS)?Flaga Information about a command-line flag. Attributes: name: the name for this flag default: the default value for this flag default_unparsed: the unparsed default value for this flag. default_as_str: default value as repr'd string, e.g., "'true'" (or None) value: the most recent parsed value of this flag set by :meth:`parse` help: a help string or None if no help is available short_name: the single letter alias for this flag (or None) boolean: if 'true', this flag does not accept arguments present: true if this flag was parsed from command line flags parser: an :class:`~absl.flags.ArgumentParser` object serializer: an ArgumentSerializer object allow_override: the flag may be redefined without raising an error, and newly defined flag overrides the old one. allow_override_cpp: use the flag from C++ if available the flag definition is replaced by the C++ flag after init allow_hide_cpp: use the Python flag despite having a C++ flag with the same name (ignore the C++ flag) using_default_value: the flag value has not been set by user allow_overwrite: the flag may be parsed more than once without raising an error, the last set value will be used allow_using_method_names: whether this flag can be defined even if it has a name that conflicts with a FlagValues method. validators: list of the flag validators. The only public method of a ``Flag`` object is :meth:`parse`, but it is typically only called by a :class:`~absl.flags.FlagValues` object. The :meth:`parse` method is a thin wrapper around the :meth:`ArgumentParser.parse()` method. The parsed value is saved in ``.value``, and the ``.present`` attribute is updated. If this flag was already present, an Error is raised. :meth:`parse` is also called during ``__init__`` to parse the default value and initialize the ``.value`` attribute. This enables other python modules to safely use flags even if the ``__main__`` module neglects to parse the command line arguments. The ``.present`` attribute is cleared after ``__init__`` parsing. If the default value is set to ``None``, then the ``__init__`` parsing step is skipped and the ``.value`` attribute is initialized to None. Note: The default value is also presented to the user in the help string, so it is important that it be a legal value for this flag. defaultdefault_as_strdefault_unparsedparserNFT) r serializernamer help_string short_namebooleanallow_overrideallow_override_cppallow_hide_cppallow_overwriteallow_using_method_namesreturnc Cs||_|sd}||_||_||_d|_||_||_||_| |_| |_ | |_ | |_ d|_ d|_ g|_|j rx|jrxtd||dS)N(no help available)rTzsCan't have both allow_hide_cpp (means use Python flag) and allow_override_cpp (means use C++ flag after InitGoogle))rhelprrpresentrrrrrr r!using_default_value_valueZ validatorsrError _set_default) selfrrrrrrrrrrr r!r+N/home/ghrups/robot-bench/.venv/lib/python3.9/site-packages/absl/flags/_flag.py__init__\s, z Flag.__init__)r"cCs|jSNr'r*r+r+r,valuesz Flag.value)r1cCs ||_dSr.r/r*r1r+r+r,r1scCs tt|Sr.)hashidr0r+r+r,__hash__sz Flag.__hash__cCs||uSr.r+r*otherr+r+r,__eq__sz Flag.__eq__cCst|trt|t|kStSr.) isinstancerr4NotImplementedr6r+r+r,__lt__s z Flag.__lt__cCs tddS)NzRA Flag instance would always be True. Did you mean to test the `.value` attribute? TypeErrorr0r+r+r,__bool__sz Flag.__bool__cCs tddS)Nzcan't pickle Flag objectsr<r0r+r+r, __getstate__szFlag.__getstate__cCstdt|jdS)Nz>%s does not support shallow copies. Use copy.deepcopy instead.)r=type__name__r0r+r+r,__copy__sz Flag.__copy__zFlag[_T])memor"cCs"tt|}t|j||_|Sr.)object__new__r@copydeepcopy__dict__)r*rCresultr+r+r, __deepcopy__szFlag.__deepcopy__r1r"cCsH|dur dS|jr"t|j|S|jr<|r4tdStdStt|S)z$Returns parsed flag value as string.Ntruefalse)rrepr serializerstrr2r+r+r,_get_parsed_value_as_stringsz Flag._get_parsed_value_as_string)argumentr"cCsB|jr$|js$td|j||jf|||_|jd7_dS)z}Parses string and sets flag value. Args: argument: str or the correct flag value type, argument to be parsed. z#flag --%s=%s: already defined as %sN)r%r rIllegalFlagValueErrorrr1_parse)r*rRr+r+r,parses   z Flag.parsec CsTz|j|WStttfyN}z"td|j||fWYd}~n d}~00dS)zInternal parse function. It returns the parsed value, and does not modify class states. Args: argument: str or the correct flag value type, argument to be parsed. Returns: The parsed value. zflag --%s=%s: %sN)rrVr= ValueError OverflowErrorrrTr)r*rRer+r+r,rUs z Flag._parsecCs|j|_d|_d|_dS)NTr)rr1r&r%r0r+r+r,unparsesz Flag.unparsecCs ||jS)zSerializes the flag.) _serializer1r0r+r+r,rOszFlag.serializecCs\|dur dS|jr,|r d|jSd|jSn,|jsBtd|jd|j|j|fSdS)zInternal serialize function.Nz--%sz--no%s"Serializer not present for flag %sz--%s=%s)rrrrr(rOr2r+r+r,r[s  zFlag._serializecCsB||_|durd|_n |||_||j|_|jr>|j|_dS)z@Changes the default value (and current value too) for this Flag.N)rr_parse_from_defaultrQrr&r1r2r+r+r,r)s zFlag._set_defaultcCs ||Sr.)rUr2r+r+r,r^szFlag._parse_from_defaultcCs |jS)aReturns a str that describes the type of the flag. NOTE: we use strings, and not the types.*Type constants because our flags can have more exotic types, e.g., 'comma separated list of strings', 'whitespace separated list of strings', etc. r flag_typer0r+r+r,r`szFlag.flag_type)doc module_nameis_keyr"cCs(|d}|r"|t|dd|t|d||t|d|j|jrh|t|d|j|jr|t|d|j|jrt|j t s|j dur|j |j }qd }n|j }|t|d || |j }|t|d ||t|d |||D]}||q|S) a6Returns an XML element that contains this flag's information. This is information that is relevant to all flags (e.g., name, meaning, etc.). If you defined a flag that has some other pieces of info, then please override _ExtraXMLInfo. Please do NOT override this method. Args: doc: minidom.Document, the DOM document it should create nodes from. module_name: str,, the name of the module that defines this flag. is_key: boolean, True iff this flag is key for main module. Returns: A minidom.Element instance. flagkeyyesfilerrZmeaningNr\rcurrentr@)Z createElementZ appendChildrcreate_xml_dom_elementrrr$rr9rrPrO_serialize_value_for_xmlr1r`_extra_xml_dom_elements)r*rarbrcelementZdefault_serializedvalue_serializedrYr+r+r,_create_xml_dom_elementsB    zFlag._create_xml_dom_elementcCs|S)z:Returns the serialized value, for use in an XML help text.r+r2r+r+r,rj<szFlag._serialize_value_for_xmlrar"cCs |j|S)aReturns extra info about this flag in XML. "Extra" means "not already included by _create_xml_dom_element above." Args: doc: minidom.Document, the DOM document it should create nodes from. Returns: A list of minidom.Element. )rZ_custom_xml_dom_elements)r*rar+r+r,rk@szFlag._extra_xml_dom_elements)NFFFFTF)F)+rA __module__ __qualname____doc__rr__annotations__rPr r ArgumentParserArgumentSerializerboolr-propertyr1setterr5r8r;r>r?rBrintrrJrQrVrUrZrOr[r)r^r`r DocumentElementrnrjrrkr+r+r+r,r$sp 0     *     6rcsDeZdZdZdeeeeefeeeeddfdd ZZ S) BooleanFlagaBasic boolean flag. Boolean flags do not take any arguments, and their value is either ``True`` (1) or ``False`` (0). The false value is specified on the command line by prepending the word ``'no'`` to either the long or the short flag name. For example, if a Boolean flag was created whose long name was ``'update'`` and whose short name was ``'x'``, then this flag could be explicitly unset through either ``--noupdate`` or ``--nox``. N)rrr$rr"c s,t}tj|d||||dfi|dS)NT)r Z BooleanParsersuperr-)r*rrr$rargsp __class__r+r,r-_szBooleanFlag.__init__)N) rArprqrrrPr rrvr- __classcell__r+r+rr,r|Rsr|csfeZdZUdZejed<d eeeeee eeee dfdd Z e j ee jdd d ZZS) EnumFlagzFBasic enum flag; its value can be any string from list of enum_values.rNT)rrr$ enum_valuesrcase_sensitivec  sTt||}t} tj|| ||||fi|||_dd|j|jf|_dS)N<%s>: %s|) r EnumParserrur}r-rjoinrr$) r*rrr$rrrr~rgrr+r,r-ps zEnumFlag.__init__rocCs*g}|jjD]}|t|d|q |SN enum_value)rrappendrrir*raelementsrr+r+r,rks  z EnumFlag._extra_xml_dom_elements)NT)rArprqrrr rrsrPrrrvr-r rzrr{rkrr+r+rr,rks  rcsneZdZUdZejed<d eee e efe ee e e ee dfdd Z ejeejdd d ZZS) EnumClassFlagz5Basic enum flag; its value is an enum class's member.rNF)rrr$ enum_classrrc  s\tj||d}tj| d} tj|| ||||fi|||_dd|j|jf|_dS)Nr) lowercaserr) r EnumClassParserZEnumClassSerializerr}r-rr member_namesr$) r*rrr$rrrr~rrrr+r,r-s zEnumClassFlag.__init__rocCs0g}|jjjD]}|t|d|q|Srrr __members__keysrrrirr+r+r,rks z%EnumClassFlag._extra_xml_dom_elements)NF)rArprqrrr rrsrPr rrr rvr-r rzrr{rkrr+r+rr,rs  rcseZdZdZfddZeeeeefdddZ eeeeefe edfdd Z e e eed fd d Z d dZeje ejdddZZS) MultiFlagaeA flag that can appear multiple time on the command-line. The value of such a flag is a list that contains the individual values from all the appearances of that flag on the command-line. See the __doc__ for Flag for most behavior of this class. Only differences in behavior are described here: * The default value may be either a single value or an iterable of values. A single value is transformed into a single-item list of that value. * The value of the flag is always a list, even if the option was only supplied once, and even if the default value is a single value cs$tj|i||jd7_dS)Nz4; repeat this option to specify a list of values)r}r-r$)r*r~kwargsrr+r,r-szMultiFlag.__init__) argumentscCsH||}|jr,|jdusJ|j|n||_|jt|7_dS)aParses one or more arguments with the installed parser. Args: arguments: a single argument or a list of arguments (typically a list of default values); a single argument is converted internally into a list containing one item. N)rUr%r1extendlen)r*r new_valuesr+r+r,rVs  zMultiFlag.parse)rr"csBt|tr|g}nt|tjr(t|}n|g}fdd|DS)Ncsg|]}tt|qSr+)r}rrU).0itemrr*r+r, z$MultiFlag._parse..)r9rPrrlist)r*rZarguments_listrr0r,rUs    zMultiFlag._parserKcs@jstdj|dur"dSfdd|D}d|S)See base class.r]Nr\csg|]}tt|qSr+)r}rr[)rZ value_itemrr+r,rsz(MultiFlag._serialize.. )rrr(rr)r*r1Zserialized_itemsrr0r,r[s zMultiFlag._serializecCsd|jS)rzmulti r_r0r+r+r,r`szMultiFlag.flag_typerocCs6g}t|jdr2|jjD]}|t|d|q|S)Nrr)hasattrrrrrrirr+r+r,rks  z!MultiFlag._extra_xml_dom_elements)rArprqrrr-r rPrrrVrrUrr[r`r rzr{rkrr+r+rr,rs &rcszeZdZUdZejeed<d ee de eee eefee ee dfdd Z ejeejdd d Zd d ZZS)MultiEnumClassFlagzA multi_enum_class flag. See the __doc__ for MultiFlag for most behaviors of this class. In addition, this class knows how to handle enum.Enum instances as values for this flag type. rFN)rrrrrc  sdtj||d}tjd| d}tj|||||fi|||_||_dd|j|pXdf|_ dS)Nr,)Zlist_seprz<<%s>: %s; repeat this option to specify a list of valuesrr#) r rZEnumClassListSerializerr}r-rrrrr$) r*rrrrrr~rrrr+r,r- s zMultiEnumClassFlag.__init__rocCs0g}|jjjD]}|t|d|q|Srrrr+r+r,rk#s z*MultiEnumClassFlag._extra_xml_dom_elementscCs4|dur,|jstd|j|j|}nd}|S)rNr]r\)rrr(rrO)r*r1rmr+r+r,rj,sz+MultiEnumClassFlag._serialize_value_for_xml)F)rArprqrrr rrrsrPr rr rvr-r rzrr{rkrjrr+r+rr,rs  r)"rr collectionsrrFenum functoolstypingrrrrrrr r r Zxml.domr Z absl.flagsr rrrEnumrtotal_orderingrrvr|rPrrrrr+r+r+r,s( ,    / "T