a
    SicwC                     @   s   d Z ddlmZ ddlZddlZddlmZ ddlmZ ddlmZ ej	G dd de
ZG d	d
 d
eZG dd deZG dd deZG dd deZG dd deZdS )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)_argument_parser)_exceptions)_helpersc                   @   s   e Zd ZdZd0ddZedd Zejd	d Zd
d Zdd Z	dd Z
dd Zdd Zdd Zdd Zdd Zdd Zdd Zdd Zd d! Zd"d# Zd$d% Zd&d' Zd(d) Zd1d*d+Zd,d- Zd.d/ ZdS )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.
  NFTc                 C   s   || _ |sd}|| _|| _|| _d| _|| _|| _|| _|	| _|
| _	|| _
|| _d| _d | _g | _| j	rx| jrxtd| | d S )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))namehelp
short_namebooleanpresentparser
serializerallow_overrideallow_override_cppallow_hide_cppallow_overwriteallow_using_method_namesusing_default_value_value
validatorsr   Error_set_default)selfr   r   r   defaulthelp_stringr
   r   r   r   r   r   r    r   L/var/www/html/django/DPS/env/lib/python3.9/site-packages/absl/flags/_flag.py__init__O   s,    zFlag.__init__c                 C   s   | j S Nr   r   r   r   r   valuen   s    z
Flag.valuec                 C   s
   || _ d S r   r    r   r"   r   r   r   r"   r   s    c                 C   s   t t| S r   )hashidr!   r   r   r   __hash__v   s    zFlag.__hash__c                 C   s   | |u S r   r   r   otherr   r   r   __eq__y   s    zFlag.__eq__c                 C   s   t |trt| t|k S tS r   )
isinstancer   r%   NotImplementedr'   r   r   r   __lt__|   s    
zFlag.__lt__c                 C   s   t dd S )NzRA Flag instance would always be True. Did you mean to test the `.value` attribute?	TypeErrorr!   r   r   r   __bool__   s    zFlag.__bool__c                 C   s   t dd S )Nzcan't pickle Flag objectsr-   r!   r   r   r   __getstate__   s    zFlag.__getstate__c                 C   s   t dt| j d S )Nz>%s does not support shallow copies. Use copy.deepcopy instead.)r.   type__name__r!   r   r   r   __copy__   s    zFlag.__copy__c                 C   s"   t t| }t| j||_|S r   )object__new__r1   copydeepcopy__dict__)r   memoresultr   r   r   __deepcopy__   s    zFlag.__deepcopy__c                 C   sH   |du rdS | j r"t| j |S | jr<|r4tdS tdS tt|S )z$Returns parsed flag value as string.Ntruefalse)r   repr	serializer   strr#   r   r   r   _get_parsed_value_as_string   s    z Flag._get_parsed_value_as_stringc                 C   sB   | j r$| js$td| j|| jf | || _|  j d7  _ dS )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 %s   N)r   r   r   IllegalFlagValueErrorr   r"   _parse)r   argumentr   r   r   parse   s    
z
Flag.parsec              
   C   sR   z| j |W S  ttfyL } z"td| j||f W Y d}~n
d}~0 0 dS )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.
    zflag --%s=%s: %sN)r   rF   r.   
ValueErrorr   rC   r   )r   rE   er   r   r   rD      s    zFlag._parsec                 C   s   | j | _d| _d| _d S )NTr   )r   r"   r   r   r!   r   r   r   unparse   s    zFlag.unparsec                 C   s   |  | jS )zSerializes the flag.)
_serializer"   r!   r   r   r   r?      s    zFlag.serializec                 C   s\   |du rdS | j r,|r d| j S d| j S n,| jsBtd| j d| j| j|f S dS )zInternal serialize function.N z--%sz--no%s"Serializer not present for flag %sz--%s=%s)r   r   r   r   r   r?   r#   r   r   r   rJ      s    
zFlag._serializec                 C   sB   || _ |du rd| _n| || _| | j| _| jr>| j| _dS )z@Changes the default value (and current value too) for this Flag.N)Zdefault_unparsedr   _parse_from_defaultrA   Zdefault_as_strr   r"   r#   r   r   r   r      s    zFlag._set_defaultc                 C   s
   |  |S r   )rD   r#   r   r   r   rM      s    zFlag._parse_from_defaultc                 C   s
   | 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!   r   r   r   rO      s    zFlag.flag_typec                 C   s(  | d}|r"|t|dd |t|d| |t|d| j | jrh|t|d| j | jr|t|d| j | jrt| j	t
s| j	dur| j| j	}qd	}n| j	}|t|d
| | | j}|t|d| |t|d|   | |D ]}|| q|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
   ZmeaningNrK   r   currentr1   )createElementappendChildr   create_xml_dom_elementr   r
   r	   r   r*   r   r@   r?   _serialize_value_for_xmlr"   rO   _extra_xml_dom_elements)r   docmodule_nameZis_keyelementZdefault_serializedvalue_serializedrH   r   r   r   _create_xml_dom_element   sB    


zFlag._create_xml_dom_elementc                 C   s   |S )z:Returns the serialized value, for use in an XML help text.r   r#   r   r   r   rX   !  s    zFlag._serialize_value_for_xmlc                 C   s   | 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   rZ   r   r   r   rY   %  s    zFlag._extra_xml_dom_elements)NFFFFTF)F)r2   
__module____qualname____doc__r   propertyr"   setterr&   r)   r,   r/   r0   r3   r;   rA   rF   rD   rI   r?   rJ   r   rM   rO   r^   rX   rY   r   r   r   r   r      s8   0   


	
4r   c                       s"   e Zd ZdZd fdd	Z  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``.
  Nc                    s0   t  }tt| j|d ||||dfi | d S )NrB   )r   BooleanParsersuperre   r   )r   r   r   r	   r
   argsp	__class__r   r   r   B  s    
zBooleanFlag.__init__)N)r2   r`   ra   rb   r   __classcell__r   r   rj   r   re   5  s   re   c                       s*   e Zd ZdZd fdd	Zdd Z  ZS )	EnumFlagzFBasic enum flag; its value can be any string from list of enum_values.NTc           
         sP   t ||}t  }	tt| j||	||||fi | dd|| jf | _d S )N<%s>: %s|)r   
EnumParserArgumentSerializerrg   rm   r   joinr	   )
r   r   r   r	   enum_valuesr
   case_sensitiverh   ri   grj   r   r   r   K  s    
zEnumFlag.__init__c                 C   s*   g }| j jD ]}|t|d| q|S N
enum_value)r   rs   appendr   rW   r   rZ   elementsrw   r   r   r   rY   S  s    z EnumFlag._extra_xml_dom_elements)NTr2   r`   ra   rb   r   rY   rl   r   r   rj   r   rm   H  s    rm   c                       s*   e Zd ZdZd fdd	Zdd Z  ZS )	EnumClassFlagz5Basic enum flag; its value is an enum class's member.NFc           
         sZ   t j||d}t j| d}	tt| j||	||||fi | dd|j| jf | _d S )Nrt   )	lowercasern   ro   )	r   EnumClassParserEnumClassSerializerrg   r|   r   rr   member_namesr	   )
r   r   r   r	   
enum_classr
   rt   rh   ri   ru   rj   r   r   r   ^  s    	
zEnumClassFlag.__init__c                 C   s0   g }| j jj D ]}|t|d| q|S rv   r   r   __members__keysrx   r   rW   ry   r   r   r   rY   n  s    z%EnumClassFlag._extra_xml_dom_elements)NFr{   r   r   rj   r   r|   [  s
     r|   c                       sP   e Zd ZdZ fddZdd Z fddZ fdd	Zd
d Zdd Z	  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                    s(   t t| j|i | |  jd7  _d S )Nz4;
    repeat this option to specify a list of values)rg   r   r   r	   )r   rh   kwargsrj   r   r   r     s    zMultiFlag.__init__c                 C   s:   |  |}| jr| j| n|| _|  jt|7  _dS )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)rD   r   r"   extendlen)r   	arguments
new_valuesr   r   r   rF     s
    
zMultiFlag.parsec                    sB   t |tjrt |tst|}t |ts.|g} fdd|D S )Nc                    s   g | ]}t t|qS r   )rg   r   rD   ).0itemrk   r   r   r   
<listcomp>      z$MultiFlag._parse.<locals>.<listcomp>)r*   r   Iterabler@   list)r   r   rj   r!   r   rD     s    
zMultiFlag._parsec                    s@    j std j |du r"dS  fdd|D }d|S )See base class.rL   NrK   c                    s   g | ]}t t|qS r   )rg   r   rJ   )r   Z
value_itemr   r   r   r     s   z(MultiFlag._serialize.<locals>.<listcomp>
)r   r   r   r   rr   )r   r"   Zserialized_itemsrj   r!   r   rJ     s    zMultiFlag._serializec                 C   s   d| j   S )r   zmulti rN   r!   r   r   r   rO     s    zMultiFlag.flag_typec                 C   s6   g }t | jdr2| jjD ]}|t|d| q|S )Nrs   rw   )hasattrr   rs   rx   r   rW   ry   r   r   r   rY     s    z!MultiFlag._extra_xml_dom_elements)r2   r`   ra   rb   r   rF   rD   rJ   rO   rY   rl   r   r   rj   r   r   v  s   r   c                       s2   e Zd ZdZd	 fdd	Zdd Zdd Z  ZS )
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.
  Fc           	         s\   t j||d}t jd| d}tt| j|||||fi | dd|j|pPdf | _d S )Nr}   ,)list_sepr~   z<<%s>: %s;
    repeat this option to specify a list of valuesro   r   )	r   r   EnumClassListSerializerrg   r   r   rr   r   r	   )	r   r   r   r   r   rt   rh   ri   ru   rj   r   r   r     s    

zMultiEnumClassFlag.__init__c                 C   s0   g }| j jj D ]}|t|d| q|S rv   r   ry   r   r   r   rY     s    z*MultiEnumClassFlag._extra_xml_dom_elementsc                 C   s   |dur| j |}nd}|S )r   NrK   )r   r?   )r   r"   r]   r   r   r   rX     s    z+MultiEnumClassFlag._serialize_value_for_xml)F)r2   r`   ra   rb   r   rY   rX   rl   r   r   rj   r   r     s
    r   )rb   collectionsr   r6   	functools
absl.flagsr   r   r   total_orderingr4   r   re   rm   r|   r   r   r   r   r   r   <module>   s     L