o
    hJ                     @  s$  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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ZG dd dZe ZeG dd dZd"ddZG dd deZG dd dZG dd dZG dd dejZG d d! d!ejZ dS )#    )annotationsN)Callable)Mapping)Sequence)Any)cast)final)Literal)NoReturn)
UsageError)check_ispytestfile_or_dirc                   @  s   e Zd ZdddZdS )NotSetreturnstrc                 C  s   dS )Nz<notset> selfr   r   Z/var/www/html/openai_agents/venv/lib/python3.10/site-packages/_pytest/config/argparsing.py__repr__   s   zNotSet.__repr__Nr   r   )__name__
__module____qualname__r   r   r   r   r   r      s    r   c                   @  s   e Zd ZU dZdZded< 		d9ddd:ddZd;ddZ	d<d=ddZd>dd Z		d?d@d&d'Z
dAd)d*Z	d?dBd,d-Z	d?d@d.d/Z	d?dCd1d2ZdefdDd7d8ZdS )E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
str | NoneprogF	_ispytestusage
processopt!Callable[[Argument], None] | Noner   boolr   Nonec                C  s@   t | td| dd| _g | _|| _|| _i | _g | _i | _d S )NzCustom optionsTparserr   )	r   OptionGroup
_anonymous_groups_processopt_usage_inidict	_ininames
extra_info)r   r   r    r   r   r   r   __init__)   s   
zParser.__init__optionArgumentc                 C  s"   | j r|jr|  | d S d S d S N)r)   dest)r   r/   r   r   r   processoption9   s
   zParser.processoption namer   descriptionafterr&   c                 C  sj   | j D ]}|j|kr|  S qt||| dd}d}t| j D ]\}}|j|kr) nq| j |d | |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(   r5   r&   	enumerateinsert)r   r5   r6   r7   groupigrpr   r   r   getgroup>   s   


zParser.getgroupoptsattrsr   c                 O  s   | 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 :meth:`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   r?   r@   r   r   r   rA   X   s   zParser.addoptionargs Sequence[str | os.PathLike[str]]	namespaceargparse.Namespace | Noneargparse.Namespacec                 C  s>   ddl m} |  | _|| j dd |D }| jj||dS )Nr   )try_argcompletec                 S     g | ]}t |qS r   osfspath.0xr   r   r   
<listcomp>q       z Parser.parse.<locals>.<listcomp>rD   )_pytest._argcompleterG   
_getparser	optparser
parse_args)r   rB   rD   rG   strargsr   r   r   parseh   s
   

zParser.parseMyOptionParserc                 C  s   ddl m} t| | j| jd}g | j| j}|D ]&}|jr?|jp#|j	}|
|}|jD ]}| }| }	|j|i |	 q,q|jtdd}
||
_|S )Nr   )filescompleter)r   *)nargs)rR   rY   rX   r-   r   r(   r'   optionsr6   r5   add_argument_groupnamesr@   add_argumentFILE_OR_DIR	completer)r   rY   rT   groupsr;   descarggroupr/   nafile_or_dir_argr   r   r   rS   t   s   

zParser._getparser	list[str]c                 C  sB   | j ||d}|j D ]
\}}t||| qttt t|tS )NrQ   )	rW   __dict__itemssetattrr   listr   getattrr`   )r   rB   r/   rD   parsedoptionr5   valuer   r   r   parse_setoption   s   zParser.parse_setoptionc                 C  s   | j ||dd S )zbParse the known arguments at this point.

        :returns: An argparse namespace object.
        rQ   r   )parse_known_and_unknown_args)r   rB   rD   r   r   r   parse_known_args   s   	zParser.parse_known_args$tuple[argparse.Namespace, list[str]]c                 C  s$   |   }dd |D }|j||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                 S  rH   r   rI   rL   r   r   r   rO      rP   z7Parser.parse_known_and_unknown_args.<locals>.<listcomp>rQ   )rS   rr   )r   rB   rD   rT   rV   r   r   r   rq      s   z#Parser.parse_known_and_unknown_argshelptypeYLiteral['string', 'paths', 'pathlist', 'args', 'linelist', 'bool', 'int', 'float'] | Nonedefaultc                 C  s<   |dv sJ |t u rt|}|||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
                * ``int``: an integer
                * ``float``: a floating-point number

                .. versionadded:: 8.4

                    The ``float`` and ``int`` types.

            For ``paths`` and ``pathlist`` types, they are considered relative to the ini-file.
            In case the execution is happening without an ini-file defined,
            they will be considered relative to the current working directory (for example with ``--override-ini``).

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

            .. versionadded:: 8.1
                Use the current working directory to resolve ``paths`` and ``pathlist`` in the absence of an ini-file.

            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pathlistrB   linelistr"   intfloatN)NOT_SETget_ini_default_for_typer+   r,   append)r   r5   rt   ru   rw   r   r   r   addini   s
   /zParser.addiniNN)r   r   r    r!   r   r"   r   r#   )r/   r0   r   r#   r4   N)r5   r   r6   r   r7   r   r   r&   r?   r   r@   r   r   r#   r1   )rB   rC   rD   rE   r   rF   )r   rX   )rB   rC   r/   rF   rD   rE   r   rh   )rB   rC   rD   rE   r   rs   )
r5   r   rt   r   ru   rv   rw   r   r   r#   )r   r   r   __doc__r   __annotations__r.   r3   r>   rA   rW   rS   rp   rr   rq   r~   r   r   r   r   r   r      s0   
 


r   ru   rv   r   r   c                 C  s@   | du rdS | dv rg S | dkrdS | dkrdS | dkrd	S dS )
zp
    Used by addini to get the default value for a given ini-option type, when
    default is not supplied.
    Nr4   )ry   rz   rB   r{   r"   Fr|   r   r}   g        r   )ru   r   r   r   r      s   
r   c                   @  s$   e Zd ZdZddd	Zdd
dZdS )ArgumentErrorzURaised if an Argument instance is created with invalid or
    inconsistent arguments.msgr   r/   Argument | strr   r#   c                 C  s   || _ t|| _d S r1   )r   r   	option_id)r   r   r/   r   r   r   r.   
  s   zArgumentError.__init__c                 C  s    | j rd| j  d| j S | jS )Nzoption : )r   r   r   r   r   r   __str__  s   zArgumentError.__str__N)r   r   r/   r   r   r#   r   )r   r   r   r   r.   r   r   r   r   r   r     s    
r   c                   @  sB   e Zd ZdZddd	ZdddZdddZdddZdddZdS )r0   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
    r^   r   r@   r   r   r#   c              
   O  s   || _ g | _g | _z|d | _W n	 ty   Y nw z|d | _W n	 ty*   Y nw | | |d}|r<|| _dS | jrO| jd dd 	dd| _dS z| jd d	d | _W dS  t
yq } z	d
| _td| |d}~ww )z5Store params in private vars for use in add_argument.ru   rw   r2   r      N-_r8   z???zneed a long or short option)_attrs_short_opts
_long_optsru   KeyErrorrw   _set_opt_stringsgetr2   replace
IndexErrorr   )r   r^   r@   r2   er   r   r   r.     s4   


 zArgument.__init__rh   c                 C  s   | j | j S r1   )r   r   r   r   r   r   r^   9  s   zArgument.namesMapping[str, Any]c              	   C  sJ   d  }|| j |D ]}z
t| || j|< W q ty!   Y qw | jS )Nzdefault dest help)splitr   r2   rm   r   AttributeError)r   r@   attrr   r   r   r@   <  s   zArgument.attrsr?   Sequence[str]c                 C  s   |D ]P}t |dk rtd|d| t |dkr5|d dkr%|d dks.td|d| | j| q|dd d	krC|d dksLtd
|d| | j| qdS )zhDirectly from optparse.

        Might not be necessary as this is passed to argparse later on.
        r   zinvalid option string z&: must be at least two characters longr   r   r8   zinvalid short option string z/: must be of the form -x, (x any non-dash char)--zinvalid long option string z*: must start with --, followed by non-dashN)lenr   r   r   r   )r   r?   optr   r   r   r   G  s(   


zArgument._set_opt_stringsc                 C  s   g }| j r|dt| j  g7 }| jr|dt| j g7 }|dt| j g7 }t| dr5|dt| j g7 }t| drD|dt| j g7 }dd	|S )
Nz_short_opts: z_long_opts: zdest: ru   ztype: rw   z	default: zArgument({}), )	r   reprr   r2   hasattrru   rw   formatjoin)r   rB   r   r   r   r   d  s   

zArgument.__repr__N)r^   r   r@   r   r   r#   )r   rh   )r   r   )r?   r   r   r#   r   )	r   r   r   r   r.   r^   r@   r   r   r   r   r   r   r0     s    



r0   c                   @  sF   e Zd ZdZ		ddddddZdddZdddZd d!ddZdS )"r&   z,A group of options shown in its own section.r4   NFr   r5   r   r6   r%   Parser | Noner   r"   r   r#   c                C  s$   t | || _|| _g | _|| _d S r1   )r   r5   r6   r\   r%   )r   r5   r6   r%   r   r   r   r   r.   u  s
   
zOptionGroup.__init__r?   r@   r   c                 O  sN   t |dd | jD }|rtd| dt|i |}| j|dd dS )aJ  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 :meth:`add_argument()
            <argparse.ArgumentParser.add_argument>` function accepts.
        c                 s  s"    | ]}|  D ]}|V  qqd S r1   )r^   )rM   r   r5   r   r   r   	<genexpr>  s    z(OptionGroup.addoption.<locals>.<genexpr>zoption names z already addedF
shortupperN)setintersectionr\   
ValueErrorr0   _addoption_instance)r   r?   r@   conflictr/   r   r   r   rA     s   zOptionGroup.addoptionc                 O  s    t |i |}| j|dd d S )NTr   )r0   r   )r   r?   r@   r/   r   r   r   
_addoption  s   zOptionGroup._addoptionr/   r0   r   c                 C  sR   |s|j D ]}|d dkr|d  rtdq| jr!| j| | j| d S )Nr   r   r8   zlowercase shortoptions reserved)r   islowerr   r%   r3   r\   r   )r   r/   r   r   r   r   r   r     s   
zOptionGroup._addoption_instancer   )
r5   r   r6   r   r%   r   r   r"   r   r#   r   )F)r/   r0   r   r"   r   r#   )r   r   r   r   r.   rA   r   r   r   r   r   r   r&   r  s    

r&   c                      s>   e Zd Z		dd fd
dZdddZ		ddddZ  ZS )rX   Nr%   r   r-   dict[str, Any] | Noner   r   r   r#   c                   s8   || _ t j||jdtddd |r|| _d S i | _d S )NF@)r   r   add_helpformatter_classallow_abbrevfromfile_prefix_chars)_parsersuperr.   r*   DropShorterLongHelpFormatterr-   )r   r%   r-   r   	__class__r   r   r.     s   
zMyOptionParser.__init__messager   r
   c                 C  s@   | j  d| }t| jdr| d| jj d}t|  | )z1Transform argparse error message into UsageError.z	: error: _config_source_hintz ())r   r   r   r   r   format_usage)r   r   r   r   r   r   error  s   zMyOptionParser.errorrB   Sequence[str] | NonerD   rE   rF   c           	      C  s   |  ||\}}|rG|D ]2}|r>|d dkr>dd|g}t| j D ]\}}|d| d|  q&| d| qt|t	
| |S )z(Allow splitting of positional arguments.r   r   zunrecognized arguments: {} z  r   
)rr   r   r   sortedr-   rj   r   r   rm   r`   extend)	r   rB   rD   parsedunrecognizedarglineskvr   r   r   rU     s   zMyOptionParser.parse_argsr   )r%   r   r-   r   r   r   r   r#   )r   r   r   r
   )rB   r   rD   rE   r   rF   )r   r   r   r.   r   rU   __classcell__r   r   r   r   rX     s    
rX   c                      s8   e Zd ZdZd fddZd fddZdd Z  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.
    rB   r   kwargsr   r#   c                   s,   d|vrt j |d< t j|i | d S )Nwidth)_pytest_ioget_terminal_widthr   r.   )r   rB   r   r   r   r   r.     s   z%DropShorterLongHelpFormatter.__init__actionargparse.Actionr   c                   sj  t  |}|r|d dkr|S t|dd }|r|S |d}t|dkr:t|d dks5t|d dkr:||_|S g }i }|D ];}t|dksN|d dkrOq@|ds]td	| d
||dd  }|dd}	|	|vswt||	 t|k r{|||	< q@|D ],}t|dks|d dkr|	| |dd  |
|ddkr|	|ddd q~d|}
|
|_|
S )Nr   r   _formatted_action_invocationr   r   r8   r   r   z&long optional argument without "--": []r4   =)r   _format_action_invocationrm   r   r   r   
startswithr   r   r   r   r   )r   r   orgstrresr\   return_list
short_longr/   xxoption	shortenedformatted_action_invocationr   r   r   r     sF   
,


z6DropShorterLongHelpFormatter._format_action_invocationc                 C  s4   ddl }g }| D ]}||| | q
|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   liner   r   r   _split_lines  s
   z)DropShorterLongHelpFormatter._split_lines)rB   r   r   r   r   r#   )r   r   r   r   )r   r   r   r   r.   r   r   r   r   r   r   r   r     s
    &r   )ru   rv   r   r   )!
__future__r   argparsecollections.abcr   r   r   rJ   typingr   r   r   r	   r
   _pytest._ior   _pytest.config.exceptionsr   _pytest.deprecatedr   r`   r   r~   r   r   	Exceptionr   r0   r&   ArgumentParserrX   HelpFormatterr   r   r   r   r   <module>   s4    
O]52