o
    i                     @   s|  d Z ddlZddlZddlZddlmZmZ ddlmZ ddl	m
Z
mZ ddlmZmZmZmZ ddlmZmZ ddlmZmZmZmZ dd	lmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z% dd
l&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z, ddl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4 ddl5m6Z6m7Z7 ddl8m9Z9 ddl:m;Z;m<Z<m=Z= ddl>m?Z?m@Z@mAZAmBZBmCZC erddlDmEZE eddG dd dZFdS )z)Argument class and related functionality.    N)CallableSequence)suppress)partialreduce)TYPE_CHECKINGAnyget_args
get_origin)definefield)ITERABLE_TYPESconvertinstantiate_from_dicttoken_count)contains_hintis_attrsis_dataclassis_enum_flagis_namedtupleis_nonetypeis_pydanticis_typeddictis_unionresolveresolve_annotatedresolve_optional)CoercionErrorCycloptsErrorMissingArgumentErrorMixedArgumentErrorRepeatArgumentErrorValidationError)	FieldInfo_attrs_field_infos_generic_class_field_infos_pydantic_field_infos_typed_dict_field_infosget_field_infossignature_parameters)ITERATIVE_BOOL_IMPLICIT_VALUE	Parameter)Token)UNSETgrouper
is_builtin   )enum_flag_from_dictget_annotated_discriminatorget_choices_from_hintmissing_keys_factory
startswithArgumentCollectionT)kw_onlyc                   @   s  e Zd ZU dZeedZee ed< 	 ee	dZ
e	ed< 	 eedZeed< 	 eeedZeed< 	 edd	ZedB ed
< 	 edd	Zeedf ed< 	 ededZeed< 	 eddddZeed< eddddZeed< eedddZeee	f ed< edddZded< 	 eddddZeed< eddddZeed< eddddZe dB ed< eddddZ!e dB ed< eddddZ"edB ed< dd  Z#d!eee	f fd"d#Z$e%d$d% Z&e&j'd&d% Z&e%d'd( Z(e(j'defd)d(Z(e%d*efd+d,Z)e%d*ee egef B fd-d.Z*e%d*efd/d0Z+d1efd2d3Z,drde-eeB  dB d*efd4d5Z.	dsde-eeB  eB eB dB deedf d*efd6d7Z/dd8d9d:eeB d;e egef dB d<ed*eeedf ef fd=d>Z0dd8d9d:ed;e egef dB d<ed*eeedf ef fd?d@Z1d
ed*eeedf ef fdAdBZ2dCefdDdEZ3e%d*efdFdGZ4e%dtdHdIZ5dJdK Z6drdLe dB fdMdNZ7drdLe dB fdOdPZ8dQdR Z9drdLe dB fdSdTZ:dudeedf fdUdVZ;e%dWdX Z<e%d*efdYdZZ=e%d*eedf fd[d\Z>drded<edB d*ee fd]d^Z?e%d*efd_d`Z@e%d*efdadbZAd*efdcddZBd*efdedfZCd*efdgdhZDdvdied*eedf dB fdjdkZEd*efdldmZFdndo ZGdpdq ZHdS )wArgumentzEncapsulates functionality and additional contextual information for parsing a parameter.

    An argument is defined as anything that would have its own entry in the help page.
    )factorytokens
field_info	parameter)default	converterhintN)r>   index .keysvalue)aliasr>   _valueF)r>   initrepr_accepts_keywords_default)r:   rG   rH   _lookup)rG   rH   r7   children_marked_converted_mark_converted_override_missing_keys_checker_internal_converter_enum_flag_typec              	   C   s  ddl m} | | _t| j}t|rt|n|f}| jjr=t	|}|t
u s4|tu s=t|tr4t|ts=td| j d| jjsCd S | jjdu rKd S |D ]}t|}||h}t|}t|v rd| _tt}}	t|}
tt |
d }|
d }	W d    n1 sw   Y  |turtd|	| _nt|rtt| _d| _| | nt |rtt!| _d| _| | nnt"|rtt!| _d| _t#|d	std
| | nSt$|rtt%| _d| _| | nAt&|rtt'| _d| _| | n/t(|r|| _)d| _| | nt*|s|rtt!| _d| _| | n| jjd u r&qM| jjd u r.qMd| _tt!| _t+t,|j-. D ]'\}}|dkrP|j/dkrPq?|j0|j1u r]|j2| _q?| |j/|i q?qMd S )Nr   r6   z5Parameter(count=True) requires an int type hint, got zA. Use 'Annotated[int, Parameter(count=True)]' for counting flags.FTr0   z1Dictionary type annotations must have "str" keys.__annotations__zGCyclopts cannot handle collections.namedtuple without type annotations.self)3cyclopts.argument._collectionr7   rL   r   r@   r   r	   r=   countr   boolint
isinstancetype
issubclass
ValueErrorparseaccepts_keysr
   r(   dictrI   strr   
IndexError	TypeErrorrJ   r   r4   r'   rO   _update_lookupr   r%   r   hasattrr   r$   r   r&   r   rQ   r/   	enumerater)   __init__valuesnamekindVAR_KEYWORD
annotation)rS   r7   r@   hintsresolved_hintoriginhint_originfield_infoskey_typeval_typeargsir<   rB   rB   a/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/cyclopts/argument/_argument.py__attrs_post_init__   s   













zArgument.__attrs_post_init__ro   c                 C   s   ddl m} t| jj}| D ]2\}}| j| }r=||kr!q|r;||jv r;||jv r;||j|jf |_t	j
|_qt|| j|< qd S )Nr   )Literal)typingrv   r2   r<   rj   itemsrK   getnamesr#   emptyr>   NotImplementedError)rS   ro   rv   discriminatorkeyr<   existing_field_inforB   rB   rt   rb      s   
zArgument._update_lookupc                 C   s   | j S )zConverted value from last :meth:`convert` call.

        This value may be stale if fields have changed since last :meth:`convert` call.
        :class:`.UNSET` if :meth:`convert` has not yet been called with tokens.
        )rF   rS   rB   rB   rt   rD     s   zArgument.valuec                 C   s   | j rd| _d| _ || _d S )NT)_markedrN   rF   )rS   valrB   rB   rt   rD     s   
c                 C   s   | j | jB S )zdIf ``True``, then this node in the tree has already been converted and ``value`` has been populated.)rM   rN   r   rB   rB   rt   r     s   zArgument._markedc                 C   s
   || _ d S N)rM   )rS   rD   rB   rB   rt   r   #  s   
returnc                 C   s.   t | jr
t| jn| jf}tdd |D S )Nc                 s   s     | ]}t |t|fv V  qd S r   )r^   r
   ).0argrB   rB   rt   	<genexpr>*      z7Argument._accepts_arbitrary_keywords.<locals>.<genexpr>)r   r@   r	   any)rS   rr   rB   rB   rt   _accepts_arbitrary_keywords'  s   z$Argument._accepts_arbitrary_keywordsc                 C   sN   | j rdS | jjdu r| jjd| jjfvS | jj| jju s!| jjs#dS | jjS )z(Show the default value on the help page.FN)requiredr=   show_defaultr<   r>   r{   r   rB   rB   rt   r   ,  s   zArgument.show_defaultc                 C   s<   t t| jpt| jotdd t| jD pt| jjS )Nc                 s       | ]}t |V  qd S r   )r   r   xrB   rB   rt   r   ?      z6Argument._use_pydantic_type_adapter.<locals>.<genexpr>)	rV   r   r@   r   r   r	   r2   r<   rj   r   rB   rB   rt   _use_pydantic_type_adapter8  s   


z#Argument._use_pydantic_type_adapterr~   c                 C   s4   z| j | jW S  ty   | jd u r | j Y S w r   )rK   rj   KeyErrorrJ   )rS   r~   rB   rB   rt   _type_hint_for_keyE  s   

zArgument._type_hint_for_keyc                 C   s   |du r| j }|sdS t|d tr|d jn|d }| ds$dS | jr<| jjdur1| jjS t	| j
jtr:dS dS t| j}t|}|tv rWt|}|rW|d turWdS dS )zEWhen parsing, should attempt to parse the token(s) as json dict data.NFr   {T)r;   rX   r,   rD   stripr5   rI   r=   	json_dictr   r<   rj   r_   r   r@   r
   r   r	   )rS   r;   rD   r@   rm   rr   rB   rB   rt   _should_attempt_json_dictM  s(    
z"Argument._should_attempt_json_dictc                 C   s   |du r| j }|sdS | |\}}|sdS t|tr|j}nt|tr'|}nt|d tr3|d jn|d }| ds@dS | jj	durJ| jj	S t
| jjpRtfD ]
}t|tr] dS qSdS )zEWhen parsing, should attempt to parse the token(s) as json list data.NFr   [T)r;   r   rX   r,   rD   r_   r   r5   r=   	json_listr	   r<   rj   r   )rS   r;   rC   _consume_allrD   r   rB   rB   rt   _should_attempt_json_listg  s*   

 
z"Argument._should_attempt_json_list.	transform	delimitertermr   r   c                C   s0   | j jstt|tr| |S | j|||dS )a  Match a name search-term, or a positional integer index.

        Raises
        ------
        ValueError
            If no match is found.

        Returns
        -------
        tuple[str, ...]
            Leftover keys after matching to this argument.
            Used if this argument accepts_arbitrary_keywords.
        Any
            Implicit value.
            :obj:`~.UNSET` if no implicit value is applicable.
        r   )r=   r\   r[   rX   rW   _match_index_match_name)rS   r   r   r   rB   rB   rt   match  s   
zArgument.matchc          
      C   s  | j j| j ju rt|d|tfS |}t}| jjsJ | jjD ]:}|r*||}t	||r\|t
|d }| jtu sA| jtv rCdnt}|rV|d |krU|dd } nq"d|f  S q"t| j j}t|rlt|}n|f}|D ]`}t|}d}	| j|D ]M}|r||}t	||r|t
|d }|tv rd}nt|s|du rd}nt|}t|p| }|r|d |kr|dd }d}	 n
qd|f    S q|	r nqqt| jstt|||fS )as  Check how well this argument matches a token keyword identifier.

        Parameters
        ----------
        term: str
            Something like "--foo"
        transform: Callable
            Function that converts the cyclopts Parameter name(s) into
            something that should be compared against ``term``.

        Raises
        ------
        ValueError
            If no match found.

        Returns
        -------
        tuple[str, ...]
            Leftover keys after matching to this argument.
            Used if this argument accepts_arbitrary_keywords.
        Any
            Implicit value.
        -NTr   r0   rB   F)r<   rh   ri   tuplelstripsplitr-   r=   rg   r5   lenr@   rV   r*   r   rj   r   r	   get_negativesr   r   r
   r[   r   )
rS   r   r   r   trailingimplicit_valuerg   r@   rk   double_breakrB   rB   rt   r     sf   



zArgument._match_namec                 C   sJ   | j d u rt| jj| jju r|| j k rtdtfS || j kr!tdtfS NrB   )rA   r[   r<   rh   VAR_POSITIONALr-   )rS   rA   rB   rB   rt   r     s   


zArgument._match_indextokenc                    s   | j jstt fdd| jD r%|  j\}}|s%| j js%t d| jr<t	 jtdd | jD A r<t
| d| j  dS )zSafely add a :class:`Token`.c                 3   s    | ]	}|j  j kV  qd S r   )addressr   r   rB   rt   r     s    z"Argument.append.<locals>.<genexpr>r   c                 s       | ]}|j V  qd S r   rC   r   rB   rB   rt   r         argumentN)r=   r\   r[   r   r;   r   rC   rU   r!   rV   r    append)rS   r   r   r   rB   r   rt   r     s   

zArgument.appendc                 C   s   t | jptdd | jD S )z@This argument, or a child argument, has at least 1 parsed token.c                 s   r   r   )
has_tokensr   rB   rB   rt   r     r   z&Argument.has_tokens.<locals>.<genexpr>)rV   r;   r   rL   r   rB   rB   rt   r     s   zArgument.has_tokensc                 C   s8   ddl m} | }| jD ]}|| ||j q|S )Nr   r6   )rT   r7   rL   r   extendchildren_recursive)rS   r7   outchildrB   rB   rt   r     s   

zArgument.children_recursivec              
   C   sd   | j r0dd l}|  }z|| jj|W S  |jy/ } z| | W Y d }~d S d }~ww t	S )Nr   )
r   pydantic_jsonTypeAdapterr<   rj   validate_pythonr"   !_handle_pydantic_validation_errorr-   )rS   r   unstructured_dataerB   rB   rt   _convert_pydantic  s   zArgument._convert_pydanticr?   c              
      s8  ddl m} jjrjj n d u rttjjd  fddjjs*t}|S jj	r:t
dd jD }|S jsg }i }fdd	}t|j}|D ]S}tj}	|jturtt|jt|	pe|	rtt|d
ksoJ |j  S |jr|}
|jd d D ]}|
|i }
q|
|jd g | n|| |r|rtdqQ|rڈjrЈjjjju rtjd  \}}tfddt||D }|S jt|}|S |rjrjjjju rjsfdd|  D }|S j|}|S j!r
t"dtS i }t}j#r#d}j#r8jr8j#j}|t|tr5t$t%j&|n|O }' r{jr{j(d}zt)*|j+}W n t)j,ye } zt-|jd|d }~ww |j./d|i|j0j1ddd jsAj2r3 S jrj#sdd jD }|rjt|S jD ]G}t|jtjd
 ksJ |j4r|j5 d||jd < q|j!r|}|jD ]}z|| }W q t6y   t"|dd w d|_7q8| j#r|t9j#|jjO }|st}|S |rt:j|}|S j!rt"dt}|S )Nr   )update_argument_collection)name_transformc              
      s   t |tr+z | |W S  tttfy* } zt|jr|jd nd | d|d }~ww z | |W S  tttfy] } zt|dkrF|d nd }t|jrQ|jd nd | |d|d }~ww )Nr   )msgr   target_typer0   )r   r   r   r   )rX   r^   AssertionErrorr[   ra   r   rr   r   )r@   r;   r   r   )r?   rS   rB   rt   safe_converter3  s$   
 z)Argument._convert.<locals>.safe_converterc                 s   s     | ]}|j tur|j V  qd S r   )r   r-   r   r   rB   rB   rt   r   E  r   z$Argument._convert.<locals>.<genexpr>c                 3   s    | D ]k}  |rkzt|j}W n tjy' } zt| jd|d }~ww t|ts4t| jd|s?|j	dg dV  q|D ](}|d u rP|j	d|dV  qAt|t
r`|j	t|dV  qA|j	t|dV  qAq|V  qd S )Nr   r    )rD   r   )rD   )r   jsonloadsrD   JSONDecodeErrorr   r@   rX   listevolver^   dumpsr_   )r;   r   parsed_jsonr   elementr   rB   rt   expand_tokensJ  s,   


z(Argument._convert.<locals>.expand_tokensr0   r   c                 3   s    | ]} |V  qd S r   rB   )r   rf   )r@   r   rB   rt   r   z  s    c                    s&   i | ]\}}| t jd  |qS )r0   )r	   r@   )r   r~   rD   )r   rS   rB   rt   
<dictcomp>  s   & z%Argument._convert.<locals>.<dictcomp>r   r   rB   F)	root_keysallow_unknownc                 S   s   g | ]}|j s|qS rB   r   r   rB   rB   rt   
<listcomp>  s    z%Argument._convert.<locals>.<listcomp>r?   T);rT   r   r=   r?   r   r   r   r\   r-   rU   sumr;   rL   r   r   r@   r   rX   r
   r   rC   
setdefaultr   r    r<   rh   r   r	   r   r   r.   ri   rx   r   r   rQ   r   operatoror_r   popr   r   rD   r   r   rg   r   sourcer   r   r   r   convert_and_validate	Exceptionr   _run_missing_keys_checkerr1   r   )rS   r?   r   r   
positionalkeywordr   expanded_tokensr   rl   lookupr~   tokens_per_elementr   dataconverted_flagsr   r   positional_tokensr   objkrB   )r?   r@   r   rS   rt   _convert+  s   
}



HFCA

 




zArgument._convertc              
   C   s   | j sAz| j|d| _W | jS  ty, } z|jdu r| |_|jdu r'| j|_ d}~w ty@ } z	|jdu r;| |_ d}~ww | jS )a0  Converts :attr:`tokens` into :attr:`value`.

        Parameters
        ----------
        converter: Callable | None
            Converter function to use. Overrides ``self.parameter.converter``

        Returns
        -------
        Any
            The converted data. Same as :attr:`value`.
        r   N)r   r   rD   r   r   r   r@   r   )rS   r?   r   rB   rB   rt   r     s$   


zArgument.convertc              
      s  t jjts	J dtjv r&ddl tdd  jdD }|dk r%d nd  fdd	}z~j	sfj
rfj
jj
ju rftjd
 }jjD ]}| D ]}||| qOqI|ttj
jf | W dS j
rj
jj
ju rtjd }jjD ]}|D ]}||| qq||tj
jdf | W dS jjD ]}|j| q|j
j| W dS  tttfy } zt|jr|jd ndd|d}~ww )zValidates provided value.

        Parameters
        ----------
        value:
            Value to validate.

        Returns
        -------
        Any
            The converted data. Same as :attr:`value`.
        r   r   Nc                 s   r   r   )rW   r   rB   rB   rt   r     r   z$Argument.validate.<locals>.<genexpr>r   )   c              
      sp    sd S j r	d S z | | W d S   jy- } z| W Y d }~d S d }~w  jy7   Y d S w r   )r   r   r   r"   r   PydanticUserError)r@   r   r   r   rS   rB   rt   validate_pydantic  s   z,Argument.validate.<locals>.validate_pydanticr0   .r   exception_messager   )rX   r=   	validatorr   sysmodulesr   __version__r   rC   r<   rh   ri   r	   r@   rf   r^   r_   rj   r   r   r[   ra   r"   rr   )rS   rD   pydantic_versionr   r@   r   r   r   rB   r   rt   validate  s>   
zArgument.validatec                 C   sB   | j |d}|tur| | |S | jjtjur| | jj |S )a>  Converts and validates :attr:`tokens` into :attr:`value`.

        Parameters
        ----------
        converter: Callable | None
            Converter function to use. Overrides ``self.parameter.converter``

        Returns
        -------
        Any
            The converted data. Same as :attr:`value`.
        r   )r   r-   r   r<   r>   r#   r{   )rS   r?   r   rB   rB   rt   r     s   
zArgument.convert_and_validatec                 C   sd   | j jrdS t|dkr| j}nt|dkr| |d }n
| j}| jr(|s(dS t|\}}||fS )a  The number of string tokens this argument consumes.

        Parameters
        ----------
        keys: tuple[str, ...]
            The **python** keys into this argument.
            If provided, returns the number of string tokens that specific
            data type within the argument consumes.

        Returns
        -------
        int
            Number of string tokens to create 1 element.
        consume_all: bool
            :obj:`True` if this data type is iterable.
        r   Fr0   r   )r0   T)r=   rU   r   rJ   r   r@   rQ   r   )rS   rC   r@   r   r   rB   rB   rt   r   .  s   
zArgument.token_countc                 C   s   | j t| jjS )z5Negative flags from :meth:`.Parameter.get_negatives`.)r=   r   r   r<   rj   r   rB   rB   rt   	negativesM  s   zArgument.negativesc                 C   s
   | j d S )z2The **first** provided name this argument goes by.r   )rz   r   rB   rB   rt   rg   R  s   
zArgument.namec                 C   s0   ddl }t| jjtsJ t|| jj| jS )z8Names the argument goes by (both positive and negative).r   N)	itertoolsrX   r=   rg   r   chainr   )rS   r   rB   rB   rt   rz   W  s   zArgument.namesc                 C   s   | j j| j||dS )z:Split a given value with :meth:`.Parameter.env_var_split`.)r   )r=   env_var_splitr@   )rS   rD   r   rB   rB   rt   r  _  s   zArgument.env_var_splitc                 C   s   | j  o| jjS )zzShow this argument on the help page.

        If an argument has child arguments, don't show it on the help-page.
        )rL   r=   showr   rB   rB   rt   r  c  s   zArgument.showc                 C   s   | j jdu r
| jjS | j jS )z<Whether or not this argument requires a user-provided value.N)r=   r   r<   r   rB   rB   rt   r   k  s   zArgument.requiredc                 C   s   | j jS r   )r<   is_positional_onlyr   rB   rB   rt   r  s  s   zArgument.is_positional_onlyc                 C   s   | j j| j jkS r   )r<   rh   r   r   rB   rB   rt   is_var_positionalv  s   zArgument.is_var_positionalc                 C   s   |   dkS )a  Check if this argument is a flag (consumes no CLI tokens).

        Flags are arguments that don't consume command-line tokens after the option name.
        They typically have implicit values (e.g., `--verbose` for bool, `--no-items` for list).

        Returns
        -------
        bool
            True if the argument consumes zero tokens from the command line.

        Examples
        --------
        >>> from cyclopts import Parameter
        >>> bool_arg = Argument(hint=bool, parameter=Parameter(name="--verbose"))
        >>> bool_arg.is_flag()
        True
        >>> str_arg = Argument(hint=str, parameter=Parameter(name="--name"))
        >>> str_arg.is_flag()
        False
        r   )r   r   rB   rB   rt   is_flagy  s   zArgument.is_flagforcec                 C   s0   |s| j jsdS t| j| j j}|rt|S dS )a*  Extract completion choices from type hint.

        Extracts choices from Literal types, Enum types, and Union types containing them.
        Respects the Parameter.show_choices setting unless force=True.

        Parameters
        ----------
        force : bool
            If True, return choices even when show_choices=False.
            Used by shell completion to always provide choices.

        Returns
        -------
        tuple[str, ...] | None
            Tuple of choice strings if choices exist and should be shown, None otherwise.

        Examples
        --------
        >>> argument = Argument(hint=Literal["dev", "staging", "prod"], parameter=Parameter(show_choices=True))
        >>> argument.get_choices()
        ('dev', 'staging', 'prod')
        >>> argument = Argument(hint=Literal["dev", "staging", "prod"], parameter=Parameter(show_choices=False))
        >>> argument.get_choices()  # Returns None for help text
        >>> argument.get_choices(force=True)  # Returns choices for completion
        ('dev', 'staging', 'prod')
        N)r=   show_choicesr3   r@   r   r   )rS   r  choicesrB   rB   rt   get_choices  s   zArgument.get_choicesc           	   
   C   s|  i }| j r-| jD ]$}|}|jdd D ]}||i }q|jtu r$|jn|j||jd < q| jD ]}d|_|j	s9q0|jt
| jd }|j rS| }|rR|||d < q0t|jpZ|jtv r|jD ]E}|jturt||d g |j q`|j}t|tr| r| d dv rzt|}W n
 tjy   Y nw ||d g | q`q0|jd }|jtu r|jn|j||d < q0|S )a  Convert argument to be json-like for pydantic.

        All values will be str/list/dict. JSON-serialized strings (from sources
        like config files or environment variables) are deserialized back to their
        original dict/list structure.
        Nr   Tr   )r   r   )rI   r;   rC   r   r   r-   rD   rL   r   r   r   r   r
   r@   r   r   rX   r_   r   r   r   r   r   )	rS   r   r   noder~   r   rC   resultrD   rB   rB   rt   r     sB   
"


"
 zArgument._jsonc                 C   s   | j r| js
|s
d S |  | | }sd S |d }| j|f }| jj|d}|r.t|d d| jjd d d| }t	d| d)Nr   keys_prefixr   z->zRequired field "z]" is not accessible by Cyclopts; possibly due to conflicting POSITIONAL/KEYWORD requirements.)
rO   r   rC   rL   	filter_byr   r<   rz   joinr[   )rS   r   missing_keysmissing_keyrC   missing_argumentsmissing_descriptionrB   rB   rt   r     s   
z"Argument._run_missing_keys_checkerc                 C   sj   dd l }| d }|d dkr$| jj| j|d  dd }t|d|t||jr3tt|| d||)Nr   rY   missinglocr  r   r   )	r   errorsr   r  rC   r   rX   r"   r_   )rS   excr   errormissing_argumentrB   rB   rt   r     s   z*Argument._handle_pydantic_validation_errorr   r   )r   r7   )rB   )F)I__name__
__module____qualname____doc__r   r   r;   r,   rR   r#   r<   r+   r=   r_   r   r@   r   rA   rW   rC   r   r-   rF   rI   rV   rJ   r^   rK   rL   rM   rN   rO   r   rP   rQ   ru   rb   propertyrD   setterr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rg   rz   r  r  r   r  r  r  r
  r   r   r   rB   rB   rB   rt   r9   B   s   
 'W


 


#
"W
	 9
   )r9   )Gr  r   r   r   collections.abcr   r   
contextlibr   	functoolsr   r   rw   r   r   r	   r
   attrsr   r   cyclopts._convertr   r   r   r   cyclopts.annotationsr   r   r   r   r   r   r   r   r   r   r   r   cyclopts.exceptionsr   r   r   r    r!   r"   cyclopts.field_infor#   r$   r%   r&   r'   r(   r)   cyclopts.parameterr*   r+   cyclopts.tokenr,   cyclopts.utilsr-   r.   r/   utilsr1   r2   r3   r4   r5   rT   r7   r9   rB   rB   rB   rt   <module>   s*    8 $	