o
    ee8                     @   s   d Z ddlZddlZddlmZ eh dZG dd dejZG dd dejZ	G d	d
 d
ejZ
G dd dejZdd Zdd ZdS )a  This module provides argparse integration with absl.flags.

``argparse_flags.ArgumentParser`` is a drop-in replacement for
:class:`argparse.ArgumentParser`. It takes care of collecting and defining absl
flags in :mod:`argparse`.

Here is a simple example::

    # Assume the following absl.flags is defined in another module:
    #
    #     from absl import flags
    #     flags.DEFINE_string('echo', None, 'The echo message.')
    #
    parser = argparse_flags.ArgumentParser(
        description='A demo of absl.flags and argparse integration.')
    parser.add_argument('--header', help='Header message to print.')

    # The parser will also accept the absl flag `--echo`.
    # The `header` value is available as `args.header` just like a regular
    # argparse flag. The absl flag `--echo` continues to be available via
    # `absl.flags.FLAGS` if you want to access it.
    args = parser.parse_args()

    # Example usages:
    # ./program --echo='A message.' --header='A header'
    # ./program --header 'A header' --echo 'A message.'


Here is another example demonstrates subparsers::

    parser = argparse_flags.ArgumentParser(description='A subcommands demo.')
    parser.add_argument('--header', help='The header message to print.')

    subparsers = parser.add_subparsers(help='The command to execute.')

    roll_dice_parser = subparsers.add_parser(
        'roll_dice', help='Roll a dice.',
        # By default, absl flags can also be specified after the sub-command.
        # To only allow them before sub-command, pass
        # `inherited_absl_flags=None`.
        inherited_absl_flags=None)
    roll_dice_parser.add_argument('--num_faces', type=int, default=6)
    roll_dice_parser.set_defaults(command=roll_dice)

    shuffle_parser = subparsers.add_parser('shuffle', help='Shuffle inputs.')
    shuffle_parser.add_argument(
        'inputs', metavar='I', nargs='+', help='Inputs to shuffle.')
    shuffle_parser.set_defaults(command=shuffle)

    args = parser.parse_args(argv[1:])
    args.command(args)

    # Example usages:
    # ./program --echo='A message.' roll_dice --num_faces=6
    # ./program shuffle --echo='A message.' 1 2 3 4


There are several differences between :mod:`absl.flags` and
:mod:`~absl.flags.argparse_flags`:

1. Flags defined with absl.flags are parsed differently when using the
   argparse parser. Notably:

   1) absl.flags allows both single-dash and double-dash for any flag, and
      doesn't distinguish them; argparse_flags only allows double-dash for
      flag's regular name, and single-dash for flag's ``short_name``.
   2) Boolean flags in absl.flags can be specified with ``--bool``,
      ``--nobool``, as well as ``--bool=true/false`` (though not recommended);
      in argparse_flags, it only allows ``--bool``, ``--nobool``.

2. Help related flag differences:

   1) absl.flags does not define help flags, absl.app does that; argparse_flags
      defines help flags unless passed with ``add_help=False``.
   2) absl.app supports ``--helpxml``; argparse_flags does not.
   3) argparse_flags supports ``-h``; absl.app does not.
    N)flags>   helpZhelpxmlZhelpfullZ	helpshortZflagfileundefokc                       s>   e Zd ZdZ fddZd fdd	Zdd Zd	d
 Z  ZS )ArgumentParserz:Custom ArgumentParser class to support special absl flags.c                    s   | dd}|dkrtd||dtj| _tt| j	di | | j
r<| jddtjtjd | jdttjd	d | jrQ| jd
tjtjd | | j dS dS )a  Initializes ArgumentParser.

    Args:
      **kwargs: same as argparse.ArgumentParser, except:
          1. It also accepts `inherited_absl_flags`: the absl flags to inherit.
             The default is the global absl.flags.FLAGS instance. Pass None to
             ignore absl flags.
          2. The `prefix_chars` argument must be the default value '-'.

    Raises:
      ValueError: Raised when prefix_chars is not '-'.
    prefix_chars-zTargparse_flags.ArgumentParser only supports "-" as the prefix character, found "{}".Zinherited_absl_flagsz--helpshortr   )actiondefaultr   z
--helpfullzshow full help message and exitz	--undefok)r	   r   N )get
ValueErrorformatpopr   FLAGS_inherited_absl_flagssuperr   __init__add_helpadd_argumentargparseSUPPRESS_HelpFullAction_define_absl_flags)selfkwargsr   	__class__r
   ID:\Projects\ConvertPro\env\Lib\site-packages\absl/flags/argparse_flags.pyr   p   s.   
zArgumentParser.__init__Nc              
      s   |d u rt jdd  }| jr| jj|dd}t }t|d|}tt| ||\}}||ur1||_	| jrnt
|drAt|j	|}|`	| j  z
| j  W ||fS  tjym } z| t| W Y d }~||fS d }~ww ||fS )N   T)Z	force_gnur   )sysargvr   Zread_flags_from_filesobjectgetattrr   r   parse_known_argsr   hasattr_strip_undefok_argsZmark_as_parsedZvalidate_all_flagsr   ZIllegalFlagValueErrorerrorstr)r   args	namespaceZundefok_missingr   er   r
   r   r#      s6   


zArgumentParser.parse_known_argsc                 C   sR   t |tjd }|D ]}|tv rq|| }||jkr&||v}| || qdS )zDefines flags from absl_flags.r   N)setZget_key_flags_for_moduler   r    _BUILT_IN_FLAGSname_define_absl_flag)r   
absl_flagsZ	key_flagsr-   flag_instancesuppressr
   r
   r   r      s   
z!ArgumentParser._define_absl_flagsc                 C   s   |j }|j}d| g}|r|dd|  |rtj}n|jdd}|jr<|d|  | j	|t
||j  |d dS | j	|t||j  |d dS )	z&Defines a flag from the flag_instance.--r   r   %z%%z--no)r   r   metavarr0   N)r-   
short_nameinsertr   r   r   replacebooleanappendr   _BooleanFlagActionupper_FlagAction)r   r0   r1   Z	flag_namer5   Zargument_namesZhelptextr
   r
   r   r.      s(   
z ArgumentParser._define_absl_flag)NN)	__name__
__module____qualname____doc__r   r#   r   r.   __classcell__r
   r
   r   r   r   m   s    ))r   c                       0   e Zd ZdZejf fdd	ZdddZ  ZS )r<   z*Action class for Abseil non-boolean flags.c                    s&   ~|| _ tt| j|tj||d dS )a  Initializes _FlagAction.

    Args:
      option_strings: See argparse.Action.
      dest: Ignored. The flag is always defined with dest=argparse.SUPPRESS.
      help: See argparse.Action.
      metavar: See argparse.Action.
      flag_instance: absl.flags.Flag, the absl flag instance.
      default: Ignored. The flag always uses dest=argparse.SUPPRESS so it
          doesn't affect the parsing result.
    )option_stringsdestr   r4   N)_flag_instancer   r<   r   r   r   )r   rC   rD   r   r4   r0   r	   r   r
   r   r      s   

z_FlagAction.__init__Nc                 C   s   | j | d| j _dS )CSee https://docs.python.org/3/library/argparse.html#action-classes.FN)rE   parseusing_default_value)r   parserr)   valuesoption_stringr
   r
   r   __call__
  s   z_FlagAction.__call__N	r=   r>   r?   r@   r   r   r   rL   rA   r
   r
   r   r   r<      s
    	r<   c                       rB   )r:   z&Action class for Abseil boolean flags.c                    sT   ~~|| _ | j jg}| j jr|| j j t|| _tt| j|t	j
d||d dS )a  Initializes _BooleanFlagAction.

    Args:
      option_strings: See argparse.Action.
      dest: Ignored. The flag is always defined with dest=argparse.SUPPRESS.
      help: See argparse.Action.
      metavar: See argparse.Action.
      flag_instance: absl.flags.Flag, the absl flag instance.
      default: Ignored. The flag always uses dest=argparse.SUPPRESS so it
          doesn't affect the parsing result.
    r   )rC   rD   nargsr   r4   N)rE   r-   r5   r9   	frozenset_flag_namesr   r:   r   r   r   )r   rC   rD   r   r4   r0   r	   Z
flag_namesr   r
   r   r     s   



z_BooleanFlagAction.__init__Nc                 C   s   t |tr|rtd|dr|dd }n|dd }|| jv r)| jd n|dr7|dd | jvr=td| | jd	 d
| j_dS )rF   zvalues must be an empty list.r2      Nr   truenozinvalid option_string: falseF)
isinstancelistr   
startswithrQ   rE   rG   rH   )r   rI   r)   rJ   rK   optionr
   r
   r   rL   3  s   

z_BooleanFlagAction.__call__rM   rN   r
   r
   r   r   r:     s
    	 r:   c                       s*   e Zd ZdZ fddZdddZ  ZS )r   z!Action class for --helpfull flag.c                    s&   ~~t t| j|tjtjd|d dS )zInitializes _HelpFullAction.

    Args:
      option_strings: See argparse.Action.
      dest: Ignored. The flag is always defined with dest=argparse.SUPPRESS.
      default: Ignored.
      help: See argparse.Action.
    r   )rC   rD   r	   rO   r   N)r   r   r   r   r   )r   rC   rD   r	   r   r   r
   r   r   G  s   	

z_HelpFullAction.__init__Nc                 C   sZ   |   |j}|r't| }tjd }||v r|| t|j|ddd |	  dS )rF   r    T)prefixZinclude_special_flagsN)

print_helpr   sortedZflags_by_module_dictr   r    removeprintZ_get_help_for_modulesexit)r   rI   r)   rJ   rK   r/   modulesZmain_moduler
   r
   r   rL   X  s   

z_HelpFullAction.__call__rM   )r=   r>   r?   r@   r   rL   rA   r
   r
   r   r   r   D  s    r   c                    sH   | r"t dd | dD   t dd  D O   fdd|D }|S )z=Returns a new list of args after removing flags in --undefok.c                 s   s    | ]}|  V  qd S rM   )strip.0r-   r
   r
   r   	<genexpr>o      z&_strip_undefok_args.<locals>.<genexpr>,c                 s   s    | ]}d | V  qdS )rT   Nr
   rc   r
   r
   r   re   p  rf   c                    s   g | ]	}t | s|qS r
   )_is_undefok)rd   argundefok_namesr
   r   
<listcomp>r  s    z'_strip_undefok_args.<locals>.<listcomp>)r+   split)r   r(   r
   rj   r   r%   l  s
   r%   c                 C   s`   |  dsdS |  dr| dd }n| dd }d|v r&|dd\}}n|}||v r.dS dS )	zGReturns whether we can ignore arg based on a set of undefok flag names.r   Fr2   rR   Nr   =T)rX   rm   )ri   rk   Zarg_without_dashr-   _r
   r
   r   rh   v  s   

rh   )r@   r   r   Zabslr   rP   r,   r   ZActionr<   r:   r   r%   rh   r
   r
   r
   r   <module>   s   N
$4(
