
    Rpf8                         d Z ddlZddlZddlmZ  eh d          Z G d dej                  Z G d dej                  Z	 G d	 d
ej                  Z
 G d dej                  Zd Z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>   helphelpxmlundefokflagfilehelpfull	helpshortc                   :     e Zd ZdZ fdZd fd	Zd Zd Z xZS )ArgumentParserz:Custom ArgumentParser class to support special absl flags.c                 d   |                     dd          }|dk    r"t          d                    |                    |                    dt          j                  | _         t          t          |           j	        di | | j
        rU|                     ddt          j        t          j                   |                     dt          t          j        d	           | j        H|                     dt          j        t          j                   |                     | 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 "{}".inherited_absl_flagsz--helpshortr   )actiondefaultr   z
--helpfullzshow full help message and exitNz	--undefok)r   r    )get
ValueErrorformatpopr   FLAGS_inherited_absl_flagssuperr   __init__add_helpadd_argumentargparseSUPPRESS_HelpFullAction_define_absl_flags)selfkwargsr   	__class__s      Y/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/absl/flags/argparse_flags.pyr   zArgumentParser.__init__p   sN    ::nc22Ls##)6,#7#79 9 9
 "(,BEK!P!PD )E.$(226222} 	M 
#(*;  = = = 
#*K  M M M !-

x0x7H  J J J
d899999 .-    Nc                 j   |t           j        dd          }| j        | j                            |d          }t	                      }t          |d|          }t          t          |                               ||          \  }}||ur||_	        | j        t          |d          rt          |j	        |          }|`	| j                                         	 | j                                         n># t          j        $ r,}|                     t#          |                     Y d }~nd }~ww xY w||fS )N   T)	force_gnur   )sysargvr   read_flags_from_filesobjectgetattrr   r   parse_known_argsr   hasattr_strip_undefok_argsmark_as_parsedvalidate_all_flagsr   IllegalFlagValueErrorerrorstr)r!   args	namespaceundefok_missingr   er#   s         r$   r.   zArgumentParser.parse_known_args   s[   |Xabb\d!- '==
$ >    d hhOiO<<GND11BBi OIt o%%!i!- 
I	&	& "9#4d;; 
 //111"557777(   

3q66 d?s   C3 3D."D))D.c                     t          |                    t          j        d                             }|D ]9}|t          v r||         }||j        k    r||v}|                     ||           :dS )zDefines flags from absl_flags.r   N)setget_key_flags_for_moduler)   r*   _BUILT_IN_FLAGSname_define_absl_flag)r!   
absl_flags	key_flagsr>   flag_instancesuppresss         r$   r    z!ArgumentParser._define_absl_flags   s    J77DDEEI 8 8		 	  &m 
#	#	# !	1}h7778 8r%   c                    |j         }|j        }d|z   g}|r|                    dd|z              |rt          j        }n|j                            dd          }|j        rF|                    d|z               | 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   metavarrB   N)r>   
short_nameinsertr   r   r   replacebooleanappendr   _BooleanFlagActionupper_FlagAction)r!   rB   rC   	flag_namerH   argument_nameshelptexts          r$   r?   z ArgumentParser._define_absl_flag   s   "I)JY&'N 1AsZ/000 7"hh #++C66h 'FY.///d"48$**,,%' ' ' ' ' '
 d+H$**,,%' ' ' ' ' 'r%   )NN)	__name__
__module____qualname____doc__r   r.   r    r?   __classcell__r#   s   @r$   r   r   m   s|        BB': ': ': ': ':R' ' ' ' ' 'R8 8 8 ' ' ' ' ' ' 'r%   r   c                   8     e Zd ZdZej        f fd	ZddZ xZS )rO   z*Action class for Abseil non-boolean flags.c                     ~|| _         t          t          |                               |t          j        ||           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   rG   N)_flag_instancer   rO   r   r   r   )r!   r[   r\   r   rG   rB   r   r#   s          r$   r   z_FlagAction.__init__   sP    & 	'D	+t%%%	 &     r%   Nc                 R    | j                             |           d| j         _        dS )CSee https://docs.python.org/3/library/argparse.html#action-classes.FN)r]   parseusing_default_value)r!   parserr7   valuesoption_strings        r$   __call__z_FlagAction.__call__
  s*    f%%%.3D+++r%   N	rS   rT   rU   rV   r   r   r   re   rW   rX   s   @r$   rO   rO      s_        22      64 4 4 4 4 4 4 4r%   rO   c                   8     e Zd ZdZej        f fd	ZddZ xZS )rM   z&Action class for Abseil boolean flags.c                     ~~|| _         | j         j        g}| j         j        r|                    | j         j                   t	          |          | _        t          t          |                               |t          j
        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   )r[   r\   nargsr   rG   N)r]   r>   rH   rL   	frozenset_flag_namesr   rM   r   r   r   )	r!   r[   r\   r   rG   rB   r   
flag_namesr#   s	           r$   r   z_BooleanFlagAction.__init__  s    & 	g'D%*+J% 8+6777 ,,D	
d##,,% -     r%   Nc                    t          |t                    r|rt          d          |                    d          r|dd         }n
|dd         }|| j        v r| j                            d           nR|                    d          r|dd         | j        vrt          d|z             | j                            d	           d
| j        _        dS )r_   zvalues must be an empty list.rE      Nr'   truenozinvalid option_string: falseF)
isinstancelistr   
startswithrl   r]   r`   ra   )r!   rb   r7   rc   rd   options         r$   re   z_BooleanFlagAction.__call__3  s    fd## 8v 86777%% !QRR ffQRR f!!!
''''t$$ Dqrr
$:J(J(J2]BCCC
(((.3D+++r%   rf   rg   rX   s   @r$   rM   rM     s`        ..      @4 4 4 4 4 4 4 4r%   rM   c                   *     e Zd ZdZ fdZddZ xZS )r   z!Action class for --helpfull flag.c                     ~~t          t          |                               |t          j        t          j        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   )r[   r\   r   rj   r   N)r   r   r   r   r   )r!   r[   r\   r   r   r#   s        r$   r   z_HelpFullAction.__init__G  sP     	g	/4  ))%! *     r%   Nc                 J   |                                  |j        }|qt          |                                          }t          j        d         }||v r|                    |           t          |                    |dd                     |	                                 dS )r_   Nr    T)prefixinclude_special_flags)

print_helpr   sortedflags_by_module_dictr)   r*   removeprint_get_help_for_modulesexit)r!   rb   r7   rc   rd   r@   modulesmain_modules           r$   re   z_HelpFullAction.__call__X  s     -Jz668899gHQKk			{###J,,
"D - : : ; ; ;
KKMMMMMr%   rf   )rS   rT   rU   rV   r   re   rW   rX   s   @r$   r   r   D  sR        ))    "       r%   r   c                     | rVt          d |                     d          D                       t          d D                       z  fd|D             }|S )z=Returns a new list of args after removing flags in --undefok.c              3   >   K   | ]}|                                 V  d S rf   )strip.0r>   s     r$   	<genexpr>z&_strip_undefok_args.<locals>.<genexpr>o  s*      DD

DDDDDDr%   ,c              3       K   | ]	}d |z   V  
dS )rq   Nr   r   s     r$   r   z&_strip_undefok_args.<locals>.<genexpr>p  s&      ????????r%   c                 4    g | ]}t          |          |S r   )_is_undefok)r   argundefok_namess     r$   
<listcomp>z'_strip_undefok_args.<locals>.<listcomp>r  s(    GGGC{3'F'FGCGGGr%   )r;   split)r   r6   r   s     @r$   r0   r0   l  ss     HDDs1C1CDDDDDMS????????MGGGG4GGGD	+r%   c                     |                      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   FrE   ro   Nr'   =T)ru   r   )r   r   arg_without_dashr>   _s        r$   r   r   v  s    			 5^^D 122w122w$$S!,,GD!!D	]4	r%   )rV   r   r)   abslr   rk   r=   r   ActionrO   rM   r   r0   r   r   r%   r$   <module>r      s?  L L\  



       )     |' |' |' |' |'X, |' |' |'~!4 !4 !4 !4 !4(/ !4 !4 !4H14 14 14 14 14 14 14 14h% % % % %ho % % %P      r%   