B
    dwC                 @   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 )Nz(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_valueZ
validatorsr   Error_set_default)selfr   r   r   defaulthelp_stringr	   r
   r   r   r   r   r    r   B/var/www/html/venv/lib/python3.7/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 )N)r   )r   r   r   r   r   r   r   s    c             C   s   t t| S )N)hashid)r   r   r   r   __hash__v   s    zFlag.__hash__c             C   s   | |kS )Nr   )r   otherr   r   r   __eq__y   s    zFlag.__eq__c             C   s   t |trt| t|k S tS )N)
isinstancer   r   NotImplemented)r   r!   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?)	TypeError)r   r   r   r   __bool__   s    zFlag.__bool__c             C   s   t dd S )Nzcan't pickle Flag objects)r&   )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 )N)object__new__r)   copydeepcopy__dict__)r   memoresultr   r   r   __deepcopy__   s    zFlag.__deepcopy__c             C   sH   |dk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
   str)r   r   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   sN   y| j |S  ttfk
rH } ztd| j||f W dd}~X Y nX 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   r>   r&   
ValueErrorr   r;   r   )r   r=   er   r   r   r<      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   r7      s    zFlag.serializec             C   s\   |dk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%sz"Serializer not present for flag %sz--%s=%s)r
   r   r   r   r   r7   )r   r   r   r   r   rB      s    
zFlag._serializec             C   sB   || _ |dk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_defaultr9   Zdefault_as_strr   r   )r   r   r   r   r   r      s    zFlag._set_defaultc             C   s
   |  |S )N)r<   )r   r   r   r   r   rD      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_type)r   r   r   r   rE      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k	r| j| j	}qd	}n| j	}|t|d
| | | j}|t|d| |t|d|   x| |D ]}|| qW |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meaningNrC   r   currentr)   )ZcreateElementZappendChildr   create_xml_dom_elementr   r	   r   r   r#   r   r8   r7   _serialize_value_for_xmlr   rE   _extra_xml_dom_elements)r   docmodule_nameZis_keyelementZdefault_serializedvalue_serializedr@   r   r   r   _create_xml_dom_element   s6    

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   r   rL   !  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   Z_custom_xml_dom_elements)r   rN   r   r   r   rM   %  s    zFlag._extra_xml_dom_elements)NFFFFTF)F)r*   
__module____qualname____doc__r   propertyr   setterr    r"   r%   r'   r(   r+   r3   r9   r>   r<   rA   r7   rB   r   rD   rE   rR   rL   rM   r   r   r   r   r      s2   /  
	
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                s,   t  }tt| j|d ||||df| d S )Nr:   )r   ZBooleanParsersuperrX   r   )r   r   r   r   r	   argsp)	__class__r   r   r   B  s    
zBooleanFlag.__init__)N)r*   rS   rT   rU   r   __classcell__r   r   )r\   r   rX   5  s   rX   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       
         sL   t ||}t  }	tt| j||	||||f| dd|| jf | _d S )Nz<%s>: %s|)r   Z
EnumParserZArgumentSerializerrY   r^   r   joinr   )
r   r   r   r   enum_valuesr	   case_sensitiverZ   r[   g)r\   r   r   r   K  s
    
zEnumFlag.__init__c             C   s.   g }x$| j jD ]}|t|d| qW |S )N
enum_value)r   ra   appendr   rK   )r   rN   elementsrd   r   r   r   rM   S  s
    z EnumFlag._extra_xml_dom_elements)NT)r*   rS   rT   rU   r   rM   r]   r   r   )r\   r   r^   H  s   r^   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       
         sV   t j||d}t j| d}	tt| j||	||||f| dd|j| jf | _d S )N)rb   )	lowercasez<%s>: %sr_   )	r   EnumClassParserZEnumClassSerializerrY   rg   r   r`   member_namesr   )
r   r   r   r   
enum_classr	   rb   rZ   r[   rc   )r\   r   r   r   ^  s    	

zEnumClassFlag.__init__c             C   s4   g }x*| j jj D ]}|t|d| qW |S )Nrd   )r   rk   __members__keysre   r   rK   )r   rN   rf   rd   r   r   r   rM   n  s
    z%EnumClassFlag._extra_xml_dom_elements)NF)r*   rS   rT   rU   r   rM   r]   r   r   )r\   r   rg   [  s    	rg   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|| |  jd7  _d S )Nz4;
    repeat this option to specify a list of values)rY   rn   r   r   )r   rZ   kwargs)r\   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)r<   r   r   extendlen)r   	arguments
new_valuesr   r   r   r>     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   )rY   rn   r<   ).0item)r\   r   r   r   
<listcomp>  s    z$MultiFlag._parse.<locals>.<listcomp>)r#   r   Iterabler8   list)r   rr   )r\   )r   r   r<     s    

zMultiFlag._parsec                s@    j std j |dkr"dS  fdd|D }d|S )zSee base class.z"Serializer not present for flag %sNrC   c                s   g | ]}t t|qS r   )rY   rn   rB   )rt   Z
value_item)r\   r   r   r   rv     s    z(MultiFlag._serialize.<locals>.<listcomp>
)r   r   r   r   r`   )r   r   Zserialized_items)r\   )r   r   rB     s    zMultiFlag._serializec             C   s   d| j   S )zSee base class.zmulti )r   rE   )r   r   r   r   rE     s    zMultiFlag.flag_typec             C   s:   g }t | jdr6x$| jjD ]}|t|d| qW |S )Nra   rd   )hasattrr   ra   re   r   rK   )r   rN   rf   rd   r   r   r   rM     s    z!MultiFlag._extra_xml_dom_elements)r*   rS   rT   rU   r   r>   r<   rB   rE   rM   r]   r   r   )r\   r   rn   v  s   rn   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       	         sX   t j||d}t jd| d}tt| j|||||f| dd|j|pLdf | _d S )N)rb   ,)Zlist_seprh   z<<%s>: %s;
    repeat this option to specify a list of valuesr_   z(no help available))	r   ri   ZEnumClassListSerializerrY   r{   r   r`   rj   r   )	r   r   r   r   rk   rb   rZ   r[   rc   )r\   r   r   r     s    

zMultiEnumClassFlag.__init__c             C   s4   g }x*| j jj D ]}|t|d| qW |S )Nrd   )r   rk   rl   rm   re   r   rK   )r   rN   rf   rd   r   r   r   rM     s
    z*MultiEnumClassFlag._extra_xml_dom_elementsc             C   s   |dk	r| j |}nd}|S )zSee base class.NrC   )r   r7   )r   r   rQ   r   r   r   rL     s    z+MultiEnumClassFlag._serialize_value_for_xml)F)r*   rS   rT   rU   r   rM   rL   r]   r   r   )r\   r   r{     s   r{   )rU   collectionsr   r.   	functoolsZ
absl.flagsr   r   r   total_orderingr,   r   rX   r^   rg   rn   r{   r   r   r   r   <module>   s     L