Ë
    =GìjïM  ã                   ó|  — d Z ddlmZ ddlZddlZddlZddlmZmZm	Z	 ddl
mZ ddlmZ ddlmZ ddlmZ  e	d	«      Z e	d
ej"                  ¬«      Zej&                   G d„ dee   «      «       Z G d„ dee   «      Z G d„ dee   «      Z G d„ dee   «      Z G d„ dee   eee      «      Z G d„ dee   «      Zy)zºContains 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.
é    )ÚIterableN)ÚAnyÚGenericÚTypeVar)Úminidom)Ú_argument_parser)Ú_exceptions)Ú_helpersÚ_TÚ_ET)Úboundc                   óè  — e Zd ZU dZedz  ed<   edz  ed<   edz  ez  ed<   ej                  e   ed<   	 	 	 	 	 	 	 d/dej                  e   dej                  e   dz  dededz  ez  d	edz  d
edz  de
de
de
de
de
de
ddfd„Zededz  fd„«       Zej                  dedz  fd„«       Zd„ Zd„ Zd„ Zd„ Zd„ Zd„ Zdeeef   ddfd„Zdedz  dedz  fd„Zd eez  ddfd!„Zd eez  dedz  fd"„Zd0d#„Zdefd$„Zdedz  defd%„Zdedz  ez  ddfd&„Zdeez  dedz  fd'„Z defd(„Z!	 d1d)e"jF                  d*ed+e
de"jH                  fd,„Z%dedz  defd-„Z&d)e"jF                  de'e"jH                     fd.„Z(y)2Ú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()<absl.flags.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.
  NÚdefaultÚdefault_as_strÚdefault_unparsedÚparserÚ
serializerÚnameÚhelp_stringÚ
short_nameÚbooleanÚallow_overrideÚallow_override_cppÚallow_hide_cppÚallow_overwriteÚallow_using_method_namesÚreturnc                 óZ  — || _         |sd}|| _        || _        || _        d| _        || _        || _        || _        |	| _        |
| _	        || _
        || _        d| _        d | _        g | _        | j                  r!| j                  rt        j                   d«      ‚| j#                  |«       y )Nú(no help available)r   TzsCan't have both allow_hide_cpp (means use Python flag) and allow_override_cpp (means use C++ flag after InitGoogle))r   Úhelpr   r   Úpresentr   r   r   r   r   r   r   Úusing_default_valueÚ_valueÚ
validatorsr	   ÚErrorÚ_set_default)Úselfr   r   r   r   r   r   r   r   r   r   r   r   s                úTC:\Users\Stabi\Downloads\virtual-tryon(1)\venv\Lib\site-packages\absl/flags/_flag.pyÚ__init__zFlag.__init__[   sµ   € ð €D„IáØ)€kà€D„IØ €D„OØ€D„LØ€D„LØ€D„KØ €D„OØ(€DÔØ0€DÔØ(€DÔØ*€DÔØ$<€DÔ!à#€DÔØ!€D„KØ!#€D„OØ×Ò˜t×6Ò6Ü×ÑðEóð ð
 	×Ñ�gÕó    c                 ó   — | j                   S ©N©r$   ©r(   s    r)   Úvaluez
Flag.value†   s   € à�;‰;Ðr+   r0   c                 ó   — || _         y r-   r.   ©r(   r0   s     r)   r0   z
Flag.valueŠ   s	   € à€D…Kr+   c                 ó*   — t        t        | «      «      S r-   )ÚhashÚidr/   s    r)   Ú__hash__zFlag.__hash__Ž   s   € Ü”�4“‹>Ðr+   c                 ó
   — | |u S r-   © ©r(   Úothers     r)   Ú__eq__zFlag.__eq__‘   s   € Ø�5ˆ=Ðr+   c                 ó\   — t        |t        «      rt        | «      t        |«      k  S t        S r-   )Ú
isinstancer   r5   ÚNotImplementedr9   s     r)   Ú__lt__zFlag.__lt__”   s%   € Ü�%œÔÜ�‹Xœ˜5›	Ñ!Ð!ÜÐr+   c                 ó   — t        d«      ‚)NzRA Flag instance would always be True. Did you mean to test the `.value` attribute?©Ú	TypeErrorr/   s    r)   Ú__bool__zFlag.__bool__™   s   € Ü
ð	7óð r+   c                 ó   — t        d«      ‚)Nzcan't pickle Flag objectsrA   r/   s    r)   Ú__getstate__zFlag.__getstate__Ÿ   s   € Ü
Ð/Ó
0Ð0r+   c                 óD   — t        t        | «      j                  › d�«      ‚)Nz< does not support shallow copies. Use copy.deepcopy instead.)rB   ÚtypeÚ__name__r/   s    r)   Ú__copy__zFlag.__copy__¢   s)   € Ü
Ü�‹:×ÑÐ
ð  "ð 	"óð r+   ÚmemozFlag[_T]c                 óŒ   — t         j                  t        | «      «      }t        j                  | j
                  |«      |_        |S r-   )ÚobjectÚ__new__rG   ÚcopyÚdeepcopyÚ__dict__)r(   rJ   Úresults      r)   Ú__deepcopy__zFlag.__deepcopy__¨   s/   € Ü�^‰^œD ›JÓ'€FÜ—m‘m D§M¡M°4Ó8€F„OØ€Mr+   c                 óØ   — |€y| j                   r$t        | j                   j                  |«      «      S | j                  r|rt        d«      S t        d«      S t        t	        |«      «      S )z$Returns parsed flag value as string.NÚtrueÚfalse)r   ÚreprÚ	serializer   Ústrr2   s     r)   Ú_get_parsed_value_as_stringz Flag._get_parsed_value_as_string­   sX   € à€}ØØ‡‚Ü�$—/‘/×+Ñ+¨EÓ2Ó3Ð3Ø‡|‚|Ù	Ü�F‹|Ðä�G‹}ÐÜ”�E“
ÓÐr+   Úargumentc                 óî   — | j                   r>| j                  s2t        j                  d| j                  › d|› d| j
                  › �«      ‚| j                  |«      | _        | xj                   dz  c_         y)z}Parses string and sets flag value.

    Args:
      argument: str or the correct flag value type, argument to be parsed.
    úflag --Ú=z: already defined as é   N)r"   r   r	   ÚIllegalFlagValueErrorr   r0   Ú_parse)r(   rZ   s     r)   Úparsez
Flag.parseº   se   € ð ‡|‚|˜D×0Ò0Ü×-Ñ-Ø�D—I‘I�;˜a ˜zÐ)>¸t¿z¹z¸lÐ
Kóð ð —‘˜XÓ&€D„JØ‡L‚L�AÑ†Lr+   c           	      óÂ   — 	 | j                   j                  |«      S # t        t        t        f$ r-}t        j                  d| j                  › d|› d|› �«      ‚d}~ww xY w)zÝInternal 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.
    r\   r]   z: N)r   ra   rB   Ú
ValueErrorÚOverflowErrorr	   r_   r   )r(   rZ   Úes      r)   r`   zFlag._parseÇ   s`   € ðØ�[‰[×Ñ˜xÓ(Ð(øÜ”z¤=Ð1ò ä×-Ñ-Ø�D—I‘I�;˜a ˜z¨¨A¨3Ð
/óð ûðús   ‚ �A±(AÁAc                 óB   — | j                   | _        d| _        d| _        y )NTr   )r   r0   r#   r"   r/   s    r)   ÚunparsezFlag.unparseÚ   s   € Ø—‘€D„JØ#€DÔØ€D…Lr+   c                 ó8   — | j                  | j                  «      S )zSerializes the flag.)Ú
_serializer0   r/   s    r)   rW   zFlag.serializeß   s   € à�?‰?˜4Ÿ:™:Ó&Ð&r+   c                 ó  — |€y| j                   r |rd| j                  › �S d| j                  › �S | j                  s"t        j                  d| j                  › �«      ‚d| j                  › d| j                  j                  |«      › �S )zInternal serialize function.Ú z--z--noú Serializer not present for flag r]   )r   r   r   r	   r&   rW   r2   s     r)   ri   zFlag._serializeã   s�   € à€}ØØ‡|‚|Ù	Ø�D—I‘I�;ÐÐà�d—i‘i�[Ð!Ð!à�_Š_Ü×ÑÐ"BÀ4Ç9Á9À+Ð NÓOÐOØ�$—)‘)�˜A˜dŸo™o×7Ñ7¸Ó>Ð?Ð@Ð@r+   c                 óÎ   — || _         |€d| _        n| j                  |«      | _        | j                  | j                  «      | _        | j
                  r| j                  | _        yy)z@Changes the default value (and current value too) for this Flag.N)r   r   Ú_parse_from_defaultrY   r   r#   r0   r2   s     r)   r'   zFlag._set_defaultñ   sX   € à!€DÔØ€}Ø€d…là×-Ñ-¨eÓ4€d„lØ×:Ñ:¸4¿<¹<ÓH€DÔØ×ÒØ—<‘<€d…jð  r+   c                 ó$   — | j                  |«      S r-   )r`   r2   s     r)   rn   zFlag._parse_from_defaultþ   s   € Ø�;‰;�uÓÐr+   c                 ó6   — | j                   j                  «       S )a   Returns 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_typer/   s    r)   rr   zFlag.flag_type  s   € ð �;‰;× Ñ Ó"Ð"r+   ÚdocÚmodule_nameÚis_keyc                 óf  — |j                  d«      }|r&|j                  t        j                  |dd«      «       |j                  t        j                  |d|«      «       |j                  t        j                  |d| j                  «      «       | j
                  r0|j                  t        j                  |d| j
                  «      «       | j                  r0|j                  t        j                  |d| j                  «      «       | j                  rOt        | j                  t        «      s5| j                  �&| j                  j                  | j                  «      }nd}n| j                  }|j                  t        j                  |d	|«      «       | j                  | j                  «      }|j                  t        j                  |d
|«      «       |j                  t        j                  |d| j                  «       «      «       | j                  |«      D ]  }|j                  |«       Œ |S )a6  Returns 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.
    ÚflagÚkeyÚyesÚfiler   r   Úmeaningrk   r   ÚcurrentrG   )ÚcreateElementÚappendChildr
   Úcreate_xml_dom_elementr   r   r!   r   r=   r   rX   rW   Ú_serialize_value_for_xmlr0   rr   Ú_extra_xml_dom_elements)r(   rs   rt   ru   ÚelementÚdefault_serializedÚvalue_serializedre   s           r)   Ú_create_xml_dom_elementzFlag._create_xml_dom_element
  sÄ  € ð& ×Ñ Ó'€GÙØ×Ñœ(×9Ñ9¸#¸uÀeÓLÔMØ×ÑÜ×'Ñ'¨¨V°[ÓAôð ×Ñœ×7Ñ7¸¸VÀTÇYÁYÓOÔPØ‡‚Ø×ÑÜ
×
)Ñ
)¨#¨|¸T¿_¹_Ó
Môð ‡y‚yØ×ÑÜ
×
)Ñ
)¨#¨y¸$¿)¹)Ó
Dôð ‡‚œz¨$¯,©,¼Ô<Ø	�‰Ð	!Ø!Ÿ_™_×6Ñ6°t·|±|ÓDÑàÑàŸ<™<ÐØ×ÑÜ×'Ñ'¨¨YÐ8JÓKôð ×4Ñ4°T·Z±ZÓ@ÐØ×ÑÜ×'Ñ'¨¨YÐ8HÓIôð ×ÑÜ×'Ñ'¨¨V°T·^±^Ó5EÓFôð ×)Ñ)¨#Ö.ˆØ×Ñ˜!Õð /à€Nr+   c                 ó   — |S )z:Returns the serialized value, for use in an XML help text.r8   r2   s     r)   r€   zFlag._serialize_value_for_xmlF  s   € à€Lr+   c                 ó8   — | j                   j                  |«      S )a   Returns 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.
    )r   Ú_custom_xml_dom_elements)r(   rs   s     r)   r�   zFlag._extra_xml_dom_elementsJ  s   € ð �;‰;×/Ñ/°Ó4Ð4r+   )NFFFFTF)r   N©F))rH   Ú
__module__Ú__qualname__Ú__doc__r   Ú__annotations__rX   r   ÚArgumentParserÚArgumentSerializerÚboolr*   Úpropertyr0   Úsetterr6   r;   r?   rC   rE   rI   ÚdictÚintr   rR   rY   ra   r`   rg   rW   ri   r'   rn   rr   r   ÚDocumentÚElementr…   r€   Úlistr�   r8   r+   r)   r   r   $   s¬  … ñ,ð^ �‰9ÓØ˜‘*ÓØ˜‘I ‘OÓ#à
×
)Ñ
)¨"Ñ
-Ó-ð  $ØØ"Ø!&Ø"Ø"Ø',ñ)à×-Ñ-¨bÑ1ð)ð #×5Ñ5°bÑ9¸DÑ@ð)ð ð	)ð
 �D‰y˜3‰ð)ð ˜‘:ð)ð ˜‘*ð)ð ð)ð ð)ð ð)ð ð)ð ð)ð !%ð)ð ó)ðV ð�R˜$‘Yò ó ðð 	‡<�<ð˜˜d™ò ó ðòòòò
ò1òð˜t C¨ H™~ð °*ó ð
¨r°D©yð ¸SÀ4¹Zó ð˜C "™Hð ¨ó ð˜S 2™Xð ¨"¨t©)ó ó&ð
'˜ó 'ðA˜b 4™ið A¨Có Að	   T¡	¨C¡ð 	 °Dó 	 ð s¨R¡xð °B¸±Ió ð#˜ó #ð EJñ:Ø×!Ñ!ð:Ø03ð:Ø=Að:à‡�ó:ðx¨B°©Ið ¸#ó ð5Ø×!Ñ!ð5àˆG�O‰OÑô5r+   r   c                   óT   ‡ — e Zd ZdZ	 d	dededz  ez  dedz  dedz  ddf
ˆ fd„Zˆ xZS )
ÚBooleanFlagaÈ  Basic 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``.
  Nr   r   r!   r   r   c           	      óZ   •— t        j                  «       }t        ‰| �  |d ||||dfi |¤Ž y ©NT)r   ÚBooleanParserÚsuperr*   )r(   r   r   r!   r   ÚargsÚpÚ	__class__s          €r)   r*   zBooleanFlag.__init__i  s1   ø€ ô 	×&Ñ&Ó(€AÜ	�GÑ�Q˜˜d G¨T°:¸tÑLÀtÓLr+   r-   )rH   rŠ   r‹   rŒ   rX   r�   r*   Ú__classcell__©r    s   @r)   r™   r™   \  s_   ø„ ñ
ð"  $ñ	Màð	Mð �d‰{˜SÑ ð	Mð �$‰Jð		Mð
 ˜‘*ð	Mð ÷	Mñ 	Mr+   r™   c                   ó¸   ‡ — e Zd ZU dZej
                  ed<   	 	 ddededz  dedz  dee   dedz  d	e	fˆ fd
„Z
dej                  deej                     fd„Zˆ xZS )ÚEnumFlagzFBasic enum flag; its value can be any string from list of enum_values.r   Nr   r   r!   Úenum_valuesr   Úcase_sensitivec                 óö   •— t        j                  ||«      }t        j                  «       }	t        ‰| �  ||	||||fi |¤Ž || _        dj                  |j                  «      }
d|
› d| j                  › �| _        y )NÚ|Ú<ú>: )	r   Ú
EnumParserr�   r�   r*   r   Újoinr¥   r!   )r(   r   r   r!   r¥   r   r¦   rž   rŸ   ÚgÚjoined_valuesr    s              €r)   r*   zEnumFlag.__init__z  sr   ø€ ô 	×#Ñ# K°Ó@€Aä×+Ñ+Ó-€AÜ	�GÑ�Q˜˜4 ¨$°
ÑC¸dÒCØ€D„KØ—H‘H˜QŸ]™]Ó+€MØ�M�? # d§i¡i [Ð1€D…Ir+   rs   r   c                 óŒ   — g }| j                   j                  D ](  }|j                  t        j                  |d|«      «       Œ* |S ©NÚ
enum_value)r   r¥   Úappendr
   r   ©r(   rs   Úelementsr±   s       r)   r�   z EnumFlag._extra_xml_dom_elementsŒ  sB   € ð €HØ—k‘k×-Ô-ˆ
Ø‡o�oÜ
×
)Ñ
)¨#¨|¸ZÓ
Hõð .ð €Or+   r›   )rH   rŠ   r‹   rŒ   r   r«   r�   rX   r   r�   r*   r   r•   r—   r–   r�   r¡   r¢   s   @r)   r¤   r¤   u  s�   ø… ÙNà
×
%Ñ
%Ó%ð  $Ø!ñ2àð2ð �T‰zð2ð �$‰Jð	2ð
 ˜C‘=ð2ð ˜‘*ð2ð õ2ð$Ø×!Ñ!ðàˆG�O‰OÑ÷r+   r¤   c                   ó¾   ‡ — e Zd ZU dZej
                  ed<   	 	 ddededz  ez  dedz  de	e   dedz  d	e
fˆ fd
„Zdej                  deej                     fd„Zˆ xZS )ÚEnumClassFlagz5Basic enum flag; its value is an enum class's member.r   Nr   r   r!   Ú
enum_classr   r¦   c                 óþ   •— t        j                  ||¬«      }t        j                  | ¬«      }	t        ‰| �  ||	||||fi |¤Ž || _        dj                  |j                  «      }
d|
› d| j                  › �| _        y )N©r¦   )Ú	lowercaser¨   r©   rª   )	r   ÚEnumClassParserÚEnumClassSerializerr�   r*   r   r¬   Úmember_namesr!   )r(   r   r   r!   r·   r   r¦   rž   rŸ   r­   Újoined_namesr    s              €r)   r*   zEnumClassFlag.__init__œ  s|   ø€ ô 	×(Ñ(Ø >ô	€Aô 	×,Ñ,¸>Ð7IÔJ€AÜ	�GÑ�Q˜˜4 ¨$°
ÑC¸dÒCØ€D„KØ—8‘8˜AŸN™NÓ+€LØ�L�>  T§Y¡Y KÐ0€D…Ir+   rs   r   c                 ó¼   — g }| j                   j                  j                  j                  «       D ](  }|j	                  t        j                  |d|«      «       Œ* |S r°   ©r   r·   Ú__members__Úkeysr²   r
   r   r³   s       r)   r�   z%EnumClassFlag._extra_xml_dom_elements°  óR   € ð €HØ—k‘k×,Ñ,×8Ñ8×=Ñ=Ö?ˆ
Ø‡o�oÜ
×
)Ñ
)¨#¨|¸ZÓ
Hõð @ð €Or+   )NF)rH   rŠ   r‹   rŒ   r   r»   r�   rX   r   rG   r�   r*   r   r•   r—   r–   r�   r¡   r¢   s   @r)   r¶   r¶   —  s’   ø… Ù=à
×
*Ñ
*Ó*ð  $Ø"ñ1àð1ð �T‰z˜CÑð1ð �$‰Jð	1ð
 �s‘)ð1ð ˜‘*ð1ð õ1ð(Ø×!Ñ!ðàˆG�O‰OÑ÷r+   r¶   c                   óÐ   ‡ — e Zd ZdZˆ fd„Zdeez  ee   z  fd„Zdeez  ee   z  de	e   fˆ fd„Z
de	e   dz  defˆ fd	„Zd
„ Zdej                  de	ej                     fd„Zˆ xZS )Ú	MultiFlagae  A 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
  c                 óN   •— t        ‰| �  |i |¤Ž | xj                  dz  c_        y )Nú4;
    repeat this option to specify a list of values)r�   r*   r!   )r(   rž   Úkwargsr    s      €r)   r*   zMultiFlag.__init__Ì  s$   ø€ Ü	�GÑ�dÐ%˜fÒ%Ø‡I‚IÐHÑH†Ir+   Ú	argumentsc                 óÜ   — | j                  |«      }| j                  r*| j                  €J ‚| j                  j                  |«       n|| _        | xj                  t	        |«      z  c_        y)a  Parses 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)r`   r"   r0   ÚextendÚlen)r(   rÉ   Ú
new_valuess      r)   ra   zMultiFlag.parseÐ  sT   € ð —‘˜YÓ'€JØ‡|‚|Ø�Z‰ZÐ#Ð#Ð#Ø
‡j�j×Ñ˜
Õ#à€d„jØ‡L‚L”C˜
“OÑ#†Lr+   r   c                 ó®   •— |xt         d˜ x�\    |g}n t        d˜ x�\   t        |«      }n 	 |g}|D �cg c]  }t        t        | �  |«      ‘Œ c}S c c}w )Nr8   )rX   r   r—   r�   rÅ   r`   )r(   rÉ   Úarguments_listÚitemr    s       €r)   r`   zMultiFlag._parseà  s^   ø€ ð ØŒ3Ž5Ø#˜‰ð ä�:Ü˜i›‰ð àð $˜ˆá<JÓK¹N°DŒE”)˜TÑ)¨$Õ/¸NÑKÐKùÒKs   µAr0   Nc                 óÒ   •— | j                   s"t        j                  d| j                  › �«      ‚|€y|D �cg c]  }t        t
        | �  |«      ‘Œ }}dj                  |«      S c c}w )úSee base class.rl   rk   Ú
)r   r	   r&   r   r�   rÅ   ri   r¬   )r(   r0   Ú
value_itemÚserialized_itemsr    s       €r)   ri   zMultiFlag._serializeð  st   ø€ à�?Š?Ü×ÑÐ @ÀÇÁÀÐLÓMÐMØ€}Øñ  óáˆJô 	Œi˜Ñ)¨*Õ5Øð ð ð
 �9‰9Ð%Ó&Ð&ùòs   ·A$c                 ó<   — d| j                   j                  «       z   S )rÒ   zmulti rq   r/   s    r)   rr   zMultiFlag.flag_typeþ  s   € à�d—k‘k×+Ñ+Ó-Ñ-Ð-r+   rs   c                 ó¸   — g }t        | j                  d«      rA| j                  j                  D ](  }|j                  t	        j
                  |d|«      «       Œ* |S )Nr¥   r±   )Úhasattrr   r¥   r²   r
   r   r³   s       r)   r�   z!MultiFlag._extra_xml_dom_elements  sP   € ð €HÜˆt�{‰{˜MÔ*ØŸ™×/Ô/ˆ*Ø�‰Ü×+Ñ+¨C°¸zÓJõ	
ð 0ð €Or+   )rH   rŠ   r‹   rŒ   r*   rX   r   r   ra   r—   r`   ri   rr   r   r•   r–   r�   r¡   r¢   s   @r)   rÅ   rÅ   »  s’   ø„ ñô Ið$˜S 2™X¨°©Ñ4ó $ð L˜c B™h¨°"©Ñ5ð L¸$¸r¹(õ Lð '˜d 2™h¨™oð '°#õ 'ò.ð	Ø×!Ñ!ð	àˆG�O‰OÑ÷	r+   rÅ   c                   óÐ   ‡ — e Zd ZU dZej
                  e   ed<   	 ddedde	e   z  ez  e	e   z  ez  dede
e   def
ˆ fd	„Zd
ej                  deej                      fd„Zd„ Zˆ xZS )ÚMultiEnumClassFlagzÁA 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.
  r   r   r   Nr   r·   r¦   c                 ó  •— t        j                  ||¬«      }t        j                  d| ¬«      }t        ‰
| �  |||||fi |¤Ž || _        || _        dj                  |j                  «      }	d|	› d|xs d› d�| _	        y )	Nr¹   Ú,)Úlist_seprº   r¨   r©   rª   r    rÇ   )
r   r»   ÚEnumClassListSerializerr�   r*   r   r   r¬   r½   r!   )r(   r   r   r   r·   r¦   rž   rŸ   r­   r¾   r    s             €r)   r*   zMultiEnumClassFlag.__init__  s˜   ø€ ô 	×(Ñ(Ø >ô	€Aô 	×0Ñ0Ø NÐ 2ô	€Aô 
�GÑ�Q˜˜4 ¨+Ñ>¸Ò>ð €D„Kà€D„OØ—8‘8˜AŸN™NÓ+€Là
ˆLˆ>˜ØÒ/Ð/Ð
0ð 1=ð	=ð 	…Ir+   rs   r   c                 ó¼   — g }| j                   j                  j                  j                  «       D ](  }|j	                  t        j                  |d|«      «       Œ* |S r°   rÀ   r³   s       r)   r�   z*MultiEnumClassFlag._extra_xml_dom_elements5  rÃ   r+   c                 ó¤   — |�K| j                   s"t        j                  d| j                  › �«      ‚| j                   j	                  |«      }|S d}|S )rÒ   rl   rk   )r   r	   r&   r   rW   )r(   r0   r„   s      r)   r€   z+MultiEnumClassFlag._serialize_value_for_xml?  sW   € àÐØ�_Š_Ü×ÑÐ"BÀ4Ç9Á9À+Ð NÓOÐOØŸ™×2Ñ2°5Ó9Ðð Ðð ÐØÐr+   r‰   )rH   rŠ   r‹   rŒ   r   r»   r   r�   rX   r   rG   r�   r*   r   r•   r—   r–   r�   r€   r¡   r¢   s   @r)   rÚ   rÚ     sž   ø… ñð ×
*Ñ
*¨3Ñ
/Ó/ð #ñàðð �h˜s‘mÑ# cÑ)¨H°S©MÑ9¸CÑ?ðð ð	ð
 �s‘)ðð õð:Ø×!Ñ!ðàˆG�O‰OÑóör+   rÚ   )rŒ   Úcollections.abcr   rN   ÚenumÚ	functoolsÚtypingr   r   r   Úxml.domr   Ú
absl.flagsr   r	   r
   r   ÚEnumr   Útotal_orderingr   r�   r™   rX   r¤   r¶   r—   rÅ   rÚ   r8   r+   r)   Ú<module>ré      sÍ   ðñõ %Û Û Û ß (Ñ (Ý å 'Ý "Ý áˆTƒ]€Ùˆe˜4Ÿ9™9Ô%€ð ×Ñôt5ˆ7�2‰;ó t5ó ðt5ôn	M�$�t‘*ô Mô2ˆt�C‰yô ôD!�D˜‘Iô !ôHP�˜‘˜T $ r¡(™^ô Pôf9˜ 3™õ 9r+   