
    dR                        d dl Z d dlZd dlZd dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlm	Z	 d dlm
Z
 d dlmZ d d	lmZ d d
lmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlZd dlmZ d dlmZ d dlmZ d dlmZ d dlmZ d dlmZ erd dlmZ dZe G d d                      Z  G d de!          Z" G d d          Z# G d d          Z$ G d d e j%                  Z& G d! d"e j'                  Z(dS )#    N)gettext)Any)Callable)cast)Dict)List)Mapping)NoReturn)Optional)Sequence)Tuple)TYPE_CHECKING)Union)final)
UsageError)ARGUMENT_PERCENT_DEFAULT)ARGUMENT_TYPE_STR)ARGUMENT_TYPE_STR_CHOICE)check_ispytest)Literalfile_or_dirc                   r   e Zd ZU dZdZee         ed<   	 	 d%dddee         deedgdf                  d	e	d
dfdZ
d&dZ	 d'dededee         d
dfdZdeded
dfdZ	 d(deeedf                  deej                 d
ej        fdZd)dZ	 d(deeedf                  dej        deej                 d
ee         fdZ	 d(deeedf                  deej                 d
ej        fdZ	 d(deeedf                  deej                 d
eej        ee         f         fdZ	 	 d%ded ed!ed"         d#ed
df
d$ZdS )*ParserzParser for command line arguments and ini-file values.

    :ivar extra_info: Dict of generic param -> value to display in case
        there's an error processing the command line arguments.
    NprogF	_ispytestusage
processoptArgumentr   returnc                    t          |           t          d| d          | _        g | _        || _        || _        i | _        g | _        i | _        d S )NzCustom optionsTparserr   )	r   OptionGroup
_anonymous_groups_processopt_usage_inidict	_ininames
extra_info)selfr   r   r   s       9lib/python3.11/site-packages/_pytest/config/argparsing.py__init__zParser.__init__+   sX     	y!!!%&6ttTTT*,%CE$&*,    optionc                 T    | j         r|j        r|                      |           d S d S d S N)r'   dest)r,   r0   s     r-   processoptionzParser.processoption;   sE     	){ )  (((((	) 	)) )r/    namedescriptionafterr$   c                     | j         D ]}|j        |k    r|c S t          ||| d          }d}t          | j                   D ]\  }}|j        |k    r n| j                             |dz   |           |S )a  Get (or create) a named option Group.

        :param name: Name of the option group.
        :param description: Long description for --help output.
        :param after: Name of another group, used for ordering --help output.
        :returns: The option group.

        The returned group object has an ``addoption`` method with the same
        signature as :func:`parser.addoption <pytest.Parser.addoption>` but
        will be shown in the respective group in the output of
        ``pytest --help``.
        Tr"   r      )r&   r6   r$   	enumerateinsert)r,   r6   r7   r8   groupigrps          r-   getgroupzParser.getgroup@   s     \ 	 	EzT!! "D+ddKKK-- 	 	FAsx5   !AE5)))r/   optsattrsc                 *     | j         j        |i | dS )a!  Register a command line option.

        :param opts:
            Option names, can be short or long options.
        :param attrs:
            Same attributes as the argparse library's :py:func:`add_argument()
            <argparse.ArgumentParser.add_argument>` function accepts.

        After command line parsing, options are available on the pytest config
        object via ``config.option.NAME`` where ``NAME`` is usually set
        by passing a ``dest`` attribute, for example
        ``addoption("--long", dest="NAME", ...)``.
        N)r%   	addoption)r,   rA   rB   s      r-   rD   zParser.addoptionZ   s$     	"!41511111r/   argszos.PathLike[str]	namespacec                     ddl m} |                                 | _         || j                   d |D             }| j                            ||          S )Nr   )try_argcompletec                 6    g | ]}t          j        |          S  osfspath.0xs     r-   
<listcomp>z Parser.parse.<locals>.<listcomp>s        ...A29Q<<...r/   rF   )_pytest._argcompleterH   
_getparser	optparser
parse_args)r,   rE   rF   rH   strargss        r-   parsezParser.parsej   sg    
 	988888**'''.....~((I(FFFr/   MyOptionParserc                    ddl m} t          | | j        | j                  }| j        | j        gz   }|D ]k}|j        rb|j        p|j	        }|
                    |          }|j        D ]7}|                                }|                                }	 |j        |i |	 8l|                    t          d          }
||
_        |S )Nr   )filescompleter)r   *)nargs)rT   r\   rZ   r+   r   r&   r%   optionsr7   r6   add_argument_groupnamesrB   add_argumentFILE_OR_DIR	completer)r,   r\   rV   groupsr=   descarggroupr0   nafile_or_dir_args              r-   rU   zParser._getparserv   s    777777"4tyIII	 11 	3 	3E} 3(6EJ$77==#m 3 3FAA)H)122222#00C0HH %3!r/   c                     |                      ||          }|j                                        D ]\  }}t          |||           t	          t
          t                   t          |t                              S )NrS   )	rY   __dict__itemssetattrr   r   strgetattrrc   )r,   rE   r0   rF   parsedoptionr6   values          r-   parse_setoptionzParser.parse_setoption   sn     zz$)z<<'06688 	) 	)KD%FD%((((DIw|[AABBBr/   c                 <    |                      ||          d         S )zbParse the known arguments at this point.

        :returns: An argparse namespace object.
        rS   r   )parse_known_and_unknown_args)r,   rE   rF   s      r-   parse_known_argszParser.parse_known_args   s"     000KKANNr/   c                 p    |                                  }d |D             }|                    ||          S )a  Parse the known arguments at this point, and also return the
        remaining unknown arguments.

        :returns:
            A tuple containing an argparse namespace object for the known
            arguments, and a list of the unknown arguments.
        c                 6    g | ]}t          j        |          S rJ   rK   rN   s     r-   rQ   z7Parser.parse_known_and_unknown_args.<locals>.<listcomp>   rR   r/   rS   )rU   rv   )r,   rE   rF   rV   rX   s        r-   ru   z#Parser.parse_known_and_unknown_args   s?     OO%%	.....))'Y)GGGr/   helptypezBLiteral['string', 'paths', 'pathlist', 'args', 'linelist', 'bool']defaultc                 `    |dv sJ |||f| j         |<   | j                            |           dS )a  Register an ini-file option.

        :param name:
            Name of the ini-variable.
        :param type:
            Type of the variable. Can be:

                * ``string``: a string
                * ``bool``: a boolean
                * ``args``: a list of strings, separated as in a shell
                * ``linelist``: a list of strings, separated by line breaks
                * ``paths``: a list of :class:`pathlib.Path`, separated as in a shell
                * ``pathlist``: a list of ``py.path``, separated as in a shell

            .. versionadded:: 7.0
                The ``paths`` variable type.

            Defaults to ``string`` if ``None`` or not passed.
        :param default:
            Default value if no ini-file option exists but is queried.

        The value of ini-variables can be retrieved via a call to
        :py:func:`config.getini(name) <pytest.Config.getini>`.
        )NstringpathspathlistrE   linelistboolN)r)   r*   append)r,   r6   ry   rz   r{   s        r-   addinizParser.addini   sF    B XXXXX#T73dd#####r/   NN)r0   r   r    Nr5   Nr2   )r    rZ   )__name__
__module____qualname____doc__r   r   ro   __annotations__r   r   r.   r4   r@   r   rD   r   r   argparse	NamespacerY   rU   r   rs   rv   r   ru   r   rJ   r/   r-   r   r   !   s           D(3-  $=A-
  - - -}- XzlD&89:-
 - 
- - - - ) ) ) ) HL &)7?}	   42s 2S 2T 2 2 2 2& 37
G 
GuS"4456
G H./
G 
		
G 
G 
G 
G   . 37		C 	CuS"4456	C "	C H./		C
 
c	C 	C 	C 	C 37	O 	OuS"4456	O H./	O 
			O 	O 	O 	O 37H HuS"4456H H./H 
x!49,	-	H H H H, #$ #$#$ #$ P
	#$ #$ 
#$ #$ #$ #$ #$ #$r/   r   c                   B    e Zd ZdZdededef         ddfdZdefdZdS )	ArgumentErrorzURaised if an Argument instance is created with invalid or
    inconsistent arguments.msgr0   r   r    Nc                 <    || _         t          |          | _        d S r2   )r   ro   	option_id)r,   r   r0   s      r-   r.   zArgumentError.__init__   s    Vr/   c                 B    | j         rd| j          d| j         S | j        S )Nzoption : )r   r   r,   s    r-   __str__zArgumentError.__str__   s-    > 	9T^99tx9998Or/   )r   r   r   r   ro   r   r.   r   rJ   r/   r-   r   r      sk         %C %z3)? %D % % % %      r/   r   c                       e Zd ZdZeeeedZdede	ddfdZ
dee         fdZdeee	f         fd	Zd
ee         ddfdZdefdZdS )r   zClass that mimics the necessary behaviour of optparse.Option.

    It's currently a least effort implementation and ignoring choices
    and integer prefixes.

    https://docs.python.org/3/library/optparse.html#optparse-standard-option-types
    )intr}   floatcomplexra   rB   r    Nc                    || _         g | _        g | _        d|                    d          pdv rt	          j        t          d           	 |d         }t          |t                    r|dk    rIt	          j        t          j
        ||          d	           t          |d
         d                   |d<   n?t	          j        t          j
        ||          d	           t          j        |         |d<   |d         | _        n|| _        n# t          $ r Y nw xY w	 |d         | _        n# t          $ r Y nw xY w|                     |           |                    d          }|r	|| _        dS | j        r0| j        d         dd                             dd          | _        dS 	 | j        d         dd         | _        dS # t(          $ r}d| _        t+          d|           |d}~ww xY w)z5Store params in private vars for use in add_argument.%defaultry   r5      )
stacklevelrz   choice)typra      choicesr   r{   r3      N-_r:   z???zneed a long or short option)_attrs_short_opts
_long_optsgetwarningswarnr   
isinstancero   r   formatrz   r   r   _typ_mapKeyErrorr{   _set_opt_stringsr3   replace
IndexErrorr   )r,   ra   rB   r   r3   es         r-   r.   zArgument.__init__   s>   &(%'%))F++1r22M2qAAAA	 -C
 #s##  (??M07CuMMM#$    %)y)9!)<$=$=E&MMM)0SFFFST    %-$5c$:E&M!&M				+  	 	 	D	,	 +DLL 	 	 	D	e$$$#ii// 		PDIII_ 	P*122.66sC@@DIIIP ,Q/3			 P P P!	#$A4HHaOPs<   D 
DDD+ +
D87D8(G 
G+G&&G+c                      | j         | j        z   S r2   )r   r   r   s    r-   ra   zArgument.names   s    $/11r/   c                 V   d                                 }|                    | j                   |D ]+}	 t          | |          | j        |<   # t
          $ r Y (w xY w| j                            d          r-| j        d         }|                    dd          }|| j        d<   | j        S )Nzdefault dest helpry   r   z%(default)s)splitr   r3   rp   r   AttributeErrorr   r   )r,   rB   attrri   s       r-   rB   zArgument.attrs#  s    #))++TY 	 	D$+D$$7$7D!!!   ;??6"" 	$F#A		*m44A"#DK{s   A
AArA   c                    |D ]}t          |          dk     rt          d|z  |           t          |          dk    rF|d         dk    r|d         dk    st          d|z  |           | j                            |           |dd         dk    r|d         dk    st          d|z  |           | j                            |           d	S )
zhDirectly from optparse.

        Might not be necessary as this is passed to argparse later on.
        r   z>invalid option string %r: must be at least two characters longr   r   r:   zMinvalid short option string %r: must be of the form -x, (x any non-dash char)--zGinvalid long option string %r: must start with --, followed by non-dashN)lenr   r   r   r   )r,   rA   opts      r-   r   zArgument._set_opt_strings3  s   
  	, 	,C3xx!||#;=@A  
 SQA##a&C--'HJMN  
  '',,,,AaCD((SVs]]'CEHI  
 &&s++++-	, 	,r/   c                    g }| j         r|dt          | j                   z   gz  }| j        r|dt          | j                  z   gz  }|dt          | j                  z   gz  }t	          | d          r|dt          | j                  z   gz  }t	          | d          r|dt          | j                  z   gz  }d                    d	                    |                    S )
Nz_short_opts: z_long_opts: zdest: rz   ztype: r{   z	default: zArgument({}), )	r   reprr   r3   hasattrrz   r{   r   join)r,   rE   s     r-   __repr__zArgument.__repr__P  s     	?_tD,<'='==>>D? 	=^d4?&;&;;<<DDOO+,,4   	1XTY/00D4## 	7[4#5#5566D$$TYYt__555r/   )r   r   r   r   r   ro   r   r   r   r   r.   r   ra   r	   rB   r   r   r   rJ   r/   r-   r   r      s          cEgNNH/Ps /PS /PT /P /P /P /Pb2tCy 2 2 2 2wsCx(     ,Xc] ,t , , , ,:6# 6 6 6 6 6 6r/   r   c                       e Zd ZdZ	 	 ddddededee         d	ed
df
dZdede	d
dfdZ
dede	d
dfdZdddded
dfdZdS )r$   z,A group of options shown in its own section.r5   NFr   r6   r7   r#   r   r    c                \    t          |           || _        || _        g | _        || _        d S r2   )r   r6   r7   r_   r#   )r,   r6   r7   r#   r   s        r-   r.   zOptionGroup.__init__a  s3     	y!!!	&')r/   rA   rB   c                     t          |                              d | j        D                       }|rt          d|z            t	          |i |}|                     |d           dS )aM  Add an option to this group.

        If a shortened version of a long option is specified, it will
        be suppressed in the help. ``addoption('--twowords', '--two-words')``
        results in help showing ``--two-words`` only, but ``--twowords`` gets
        accepted **and** the automatic destination is in ``args.twowords``.

        :param opts:
            Option names, can be short or long options.
        :param attrs:
            Same attributes as the argparse library's :py:func:`add_argument()
            <argparse.ArgumentParser.add_argument>` function accepts.
        c              3   H   K   | ]}|                                 D ]}|V  d S r2   )ra   )rO   r   r6   s      r-   	<genexpr>z(OptionGroup.addoption.<locals>.<genexpr>}  sO       *
 *
SYY[[*
 *
-1D*
 *
 *
 *
 *
 *
 *
r/   zoption names %s already addedF
shortupperN)setintersectionr_   
ValueErrorr   _addoption_instance)r,   rA   rB   conflictr0   s        r-   rD   zOptionGroup.addoptiono  s     t99)) *
 *
 L*
 *
 *
 
 
  	I<xGHHH4)5))  E :::::r/   c                 L    t          |i |}|                     |d           d S )NTr   )r   r   )r,   rA   rB   r0   s       r-   
_addoptionzOptionGroup._addoption  s3    4)5))  D 99999r/   r0   r   r   c                     |s?|j         D ]7}|d         dk    r)|d                                         rt          d          8| j        r| j                            |           | j                            |           d S )Nr   r   r:   zlowercase shortoptions reserved)r   islowerr   r#   r4   r_   r   )r,   r0   r   r   s       r-   r   zOptionGroup._addoption_instance  s     	H) H Hq6S==SV^^%5%5=$%FGGG; 	.K%%f---F#####r/   r   )F)r   r   r   r   ro   r   r   r   r.   r   rD   r   r   rJ   r/   r-   r$   r$   ^  s        66
 #'	       	  
   ;s ;S ;T ; ; ; ;,: :c :d : : : :$ $* $$ $SW $ $ $ $ $ $r/   r$   c            	       >    e Zd Z	 	 ddedeeeef                  dee         ddf fdZdede	fdZ
	 	 dd	eee                  d
eej                 dej        fdZej        dd         dk     r,dedeeeej                 eee         f                  fdZ xZS  xZS )rZ   Nr#   r+   r   r    c                     || _         t                                          ||j        dt          d           |r|ni | _        d S )NF)r   r   add_helpformatter_classallow_abbrev)_parsersuperr.   r(   DropShorterLongHelpFormatterr+   )r,   r#   r+   r   	__class__s       r-   r.   zMyOptionParser.__init__  sT     -8 	 	
 	
 	
 )3:**r/   messagec                     | j          d| }t          | j        d          r| d| j        j         d}t	          |                                 |z             )z1Transform argparse error message into UsageError.z	: error: _config_source_hintz ())r   r   r   r   r   format_usage)r,   r   r   s      r-   errorzMyOptionParser.error  sg    ..W..4<!677 	@??DL<???C**,,s2333r/   rE   rF   c                    |                      ||          \  }}|r|D ]}|r|d         dk    rdd                    |          z  g}t          | j                                                  D ] \  }}|                    d| d|            !|                     d                    |                     t          |t                    	                    |           |S )z(Allow splitting of positional arguments.r   r   zunrecognized arguments: %s z  r   
)
rv   r   sortedr+   rm   r   r   rp   rc   extend)	r,   rE   rF   parsedunrecognizedarglineskvs	            r-   rW   zMyOptionParser.parse_args  s      $44T9EE 	># 1 1 13q6S==9SXXl=S=STUE &t'<'<'>'> ? ? 4 41]!]]q]]3333JJtyy//000FK((//===r/   r   )r   	   
arg_stringc                    |sd S |d         | j         vrd S || j        v r| j        |         }||d fS t          |          dk    rd S d|v r4|                    dd          \  }}|| j        v r| j        |         }|||fS | j        s|                    d          s|                     |          }t          |          dk    rJt          d          }d                    d |D                       }| 	                    |||dz             nt          |          dk    r|\  }|S | j
                            |          r	| j        sd S d	|v rd S d |d fS )
Nr   r:   =r   z4ambiguous option: %(option)s could match %(matches)sr   c              3   "   K   | ]
\  }}}|V  d S r2   rJ   )rO   r   r0   s      r-   r   z1MyOptionParser._parse_optional.<locals>.<genexpr>  s(      'Q'Q<1fa'Q'Q'Q'Q'Q'Qr/   )r0   matchesr   )prefix_chars_option_string_actionsr   r   r   
startswith_get_option_tuplesr   r   r   _negative_number_matchermatch_has_negative_number_optionals)	r,   r   actionoption_stringexplicit_argoption_tuplesr   r_   option_tuples	            r-   _parse_optionalzMyOptionParser._parse_optional  s     ta=D$555tT8884Z@z4//:!##tj  .8.>.>sA.F.F+| D$???!8GF!=,>>  
(
(=(=d(C(C 
( $ 7 7
 C C}%%))!N C #ii'Q'Q='Q'Q'QQQGJJs
w%O%OOPPPP''1,,&3O\'',22:>>  :  4j  tT))r/   r   )r   r   r   r   r   r   ro   r   r.   r
   r   r   r   r   rW   sysversion_infor   Actionr   __classcell__r   s   @r-   rZ   rZ     s[        04"	; ;; T#s(^,; sm	;
 
; ; ; ; ; ;$4S 4X 4 4 4 4 )-26 x}% H./ 
		   " f$$!	*!!	*eHX_5sHSMIJK!	* !	* !	* !	* !	* !	* !	* !	* %$$$r/   rZ   c                   T     e Zd ZdZdededdf fdZdej        def fdZ	d	 Z
 xZS )
r   a+  Shorten help for long options that differ only in extra hyphens.

    - Collapse **long** options that are the same except for extra hyphens.
    - Shortcut if there are only two options and one of them is a short one.
    - Cache result on the action object as this is called at least 2 times.
    rE   kwargsr    Nc                     d|vr!t           j                                        |d<    t                      j        |i | d S )Nwidth)_pytest_ioget_terminal_widthr   r.   )r,   rE   r  r   s      r-   r.   z%DropShorterLongHelpFormatter.__init__  sG    &  %k<<>>F7O$)&)))))r/   r   c                    t                                          |          }|r|d         dk    r|S t          |dd           }|r|S |                    d          }t	          |          dk    r;t	          |d                   dk    st	          |d                   dk    r	||_        |S g }i }|D ]}t	          |          dk    s|d         dk    r"|                    d          st          d	|z  |          |dd          }|                    dd
          }	|	|vs&t	          ||	                   t	          |          k     r|||	<   |D ]}t	          |          dk    s|d         dk    r|	                    |           |dd          |
                    |                    dd
                    k    r*|	                    |                    ddd                     d                    |          }
|
|_        |
S )Nr   r   _formatted_action_invocationr   r   r:   r   r   z)long optional argument without "--": [%s]r5   r   )r   _format_action_invocationrp   r   r   r  r   r   r   r   r   r   )r,   r   orgstrresr_   return_list
short_longr0   xxoption	shortenedformatted_action_invocationr   s              r-   r  z6DropShorterLongHelpFormatter._format_action_invocation  s6   226:: 	fQi3&&M$V-KTRR 	J,,t$$w<<1#gaj//Q"6"6#gaj//Q:N:N28F/M%'
 	1 	1F6{{a6!9#3#3$$T** #?6JF   abbzH ((b11I
**c*Y2G.H.H3L L / / )1
9%  	@ 	@F6{{a6!9#3#3""6***abbzZ^^FNN3,C,CDDDD""6>>#sA#>#>???&*ii&<&<#.I+**r/   c                     ddl }g }|                                D ]=}|                    |                    |                                |                     >|S )z}Wrap lines after splitting on original newlines.

        This allows to have explicit line breaks in the help text.
        r   N)textwrap
splitlinesr   wrapstrip)r,   textr  r  r   lines         r-   _split_linesz)DropShorterLongHelpFormatter._split_lines  s[    
 	OO%% 	= 	=DLLtzz||U;;<<<<r/   )r   r   r   r   r   r.   r   r  ro   r  r  r  r  s   @r-   r   r     s         *c *S *T * * * * * *$+ $+C $+ $+ $+ $+ $+ $+L
 
 
 
 
 
 
r/   r   ))r   rL   r   r   r   typingr   r   r   r   r   r	   r
   r   r   r   r   r   _pytest._ior  _pytest.compatr   _pytest.config.exceptionsr   _pytest.deprecatedr   r   r   r   typing_extensionsr   rc   r   	Exceptionr   r   r$   ArgumentParserrZ   HelpFormatterr   rJ   r/   r-   <module>r&     s    				 



                                                                                                      0 0 0 0 0 0 7 7 7 7 7 7 0 0 0 0 0 0 7 7 7 7 7 7 - - - - - - *)))))) p$ p$ p$ p$ p$ p$ p$ p$f    I   w6 w6 w6 w6 w6 w6 w6 w6t2$ 2$ 2$ 2$ 2$ 2$ 2$ 2$jS* S* S* S* S*X, S* S* S*l> > > > >8#9 > > > > >r/   