
    !<i                        d Z ddl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/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z: ddl;m<Z<m=Z=m>Z> ddl?m@Z@mAZAmBZBmCZCmDZD erddlEmFZF  ed           G d d                      ZGd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                      e Zd ZU dZ ee          Zee         ed<   	  ee	          Z
e	ed<   	  ee          Zeed<   	  eee          Zeed<   	  ed	          Zedz  ed
<   	  ed	          Zeedf         ed<   	  ede          Zeed<   	  eddd          Zeed<    eddd          Zeed<    eedd          Zeee	f         ed<    edd          Zded<   	  eddd          Zeed<    eddd          Zeed<    eddd          Ze dz  ed<    eddd          Z!e dz  ed<    eddd          Z"edz  ed<   d Z#d eee	f         fd!Z$e%d"             Z&e&j'        d#             Z&e%d$             Z(e(j'        defd%            Z(e%d&efd'            Z)e%d&ee egef         z  fd(            Z*e%d&efd)            Z+d*efd+Z,dOde-eez           dz  d&efd,Z.	 dPde-eez           ez  ez  dz  deedf         d&efd-Z/dd.d/d0eez  d1e egef         dz  d2ed&eeedf         ef         fd3Z0dd.d/d0ed1e egef         dz  d2ed&eeedf         ef         fd4Z1d
ed&eeedf         ef         fd5Z2d6efd7Z3e%d&efd8            Z4e%dQd9            Z5d: Z6dOd;e dz  fd<Z7dOd;e dz  fd=Z8d> Z9dOd;e dz  fd?Z:dRdeedf         fd@Z;e%dA             Z<e%d&efdB            Z=e%d&eedf         fdC            Z>dOded2edz  d&ee         fdDZ?e%d&efdE            Z@e%d&efdF            ZAd&efdGZBd&efdHZCd&efdIZDdSdJed&eedf         dz  fdKZEd&efdLZFdM ZGdN ZHdS )T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<   rI   rJ   _lookup)rI   rJ   r8   children_marked_converted_mark_converted_override_missing_keys_checker_internal_converter_enum_flag_typec                    ddl m}  |            | _        t          | j                  }t          |          rt          |          n|f}| j        j        rct          |          }|t          u s3|t          u sBt          |t                    rt          |t                    st          d| j         d          | j        j        sd S | j        j        du rd S |D ]b}t%          |          }||h}t'          |          }t(          |v rd| _        t,          t,          }	}t          |          }
t/          t0                    5  |
d         }|
d         }	d d d            n# 1 swxY w Y   |t,          urt3          d          |	| _        nt7          |          r7t9          t:                    | _        d| _        |                     |           ntA          |          r7t9          tB                    | _        d| _        |                     |           nwtE          |          rVt9          tB                    | _        d| _        tG          |d	          st          d
          |                     |           ntI          |          r6t9          tJ                    | _        d| _        |                     |           ntM          |          r6t9          tN                    | _        d| _        |                     |           ntQ          |          r$|| _)        d| _        |                     |           nUtU          |          s8|r6t9          tB                    | _        d| _        |                     |           n| j        j        | j        j        d| _        t9          tB                    | _        tW          tY          |j-                  .                                          D ]N\  }}|dk    r|j/        dk    r|j0        |j1        u r|j2        | _        2|                     |j/        |i           Odd S )Nr   r7   z5Parameter(count=True) requires an int type hint, got zA. Use 'Annotated[int, Parameter(count=True)]' for counting flags.FTr1   z1Dictionary type annotations must have "str" keys.__annotations__zGCyclopts cannot handle collections.namedtuple without type annotations.self)3cyclopts.argument._collectionr8   rN   r   rB   r   r
   r?   countr   boolint
isinstancetype
issubclass
ValueErrorparseaccepts_keysr   r)   dictrK   strr   
IndexError	TypeErrorrL   r   r5   r(   rQ   _update_lookupr   r&   r   hasattrr   r%   r   r'   r   rS   r0   	enumerater*   __init__valuesnamekindVAR_KEYWORD
annotation)rV   r8   rB   hintsresolved_hintoriginhint_originfield_infoskey_typeval_typeargsir>   s                /Users/kimhansen/Desktop/03 Workspace/ceo-agents/chl-effectiveness/mcp-servers/whoop/.venv/lib/python3.11/site-packages/cyclopts/argument/_argument.py__attrs_post_init__zArgument.__attrs_post_init__   s   DDDDDD**,,ty!!"*4..=tg> 
	,T22M$$$$M4)H)H$ZXegjMkMk$ WDI W W W  
 ~# 	F>&%//F ;	G ;	GD%%F.K)$//K{"")-&%(#(~~j)) ' '#AwH#AwH' ' ' ' ' ' ' ' ' ' ' ' ' ' ' 3&&#$WXXX (d## -ABY-Z-Z*)-&##K0000d## -AB\-]-]*)-&##K0000t$$ -AB\-]-]*)-&t%677 p$%nooo##K0000$ -ABT-U-U*)-&##K0000T"" -ABW-X-X*)-&##K0000d## 	'+$)-&##K0000%% + -AB\-]-]*)-&##K0000,4~*2%)D")=>X)Y)YD&!*+?+N+N+U+U+W+W!X!X G G:66jo77?j&<<<$.$9DMM''*(EFFFFGk;	G ;	Gs    EE!	$E!	rr   c                 ^   ddl m} t          | j        j                  }|                                D ]x\  }}| j                            |          x}rM||k    r(|r=||j        v r4||j        v r+||j        |j        f         |_        t          j
        |_        gt          || j        |<   yd S )Nr   )Literal)typingrz   r3   r>   rm   itemsrM   getnamesr$   emptyr@   NotImplementedError)rV   rr   rz   discriminatorkeyr>   existing_field_infos          rw   re   zArgument._update_lookup   s    """"""3DO4NOO*0022 
	/ 
	/OC&*l&6&6s&;&;;" 	/&*44" .}
8H'H'H]^q^wMwMw5<=P=[]g]r=r5s'22;/'//--$.S!!
	/ 
	/    c                     | 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.
        )rH   rV   s    rw   rF   zArgument.value  s     {r   c                 >    | j         rd| _        d| _         || _        d S )NT)_markedrP   rH   )rV   vals     rw   rF   zArgument.value  s&    < 	1,0D)r   c                      | j         | j        z  S )zdIf ``True``, then this node in the tree has already been converted and ``value`` has been populated.)rO   rP   r   s    rw   r   zArgument._marked  s     %(EEEr   c                     || _         d S N)rO   )rV   rF   s     rw   r   zArgument._marked$  s    !&r   returnc                     t          | j                  rt          | j                  n| j        f}t          d |D                       S )Nc              3   F   K   | ]}t           |t          |          fv V  d S r   )ra   r   ).0args     rw   	<genexpr>z7Argument._accepts_arbitrary_keywords.<locals>.<genexpr>+  s2      BBc4CC11BBBBBBr   )r   rB   r
   any)rV   ru   s     rw   _accepts_arbitrary_keywordsz$Argument._accepts_arbitrary_keywords(  sF    &.ty&9&9Kx	"""	|BBTBBBBBBr   c                     | j         rdS | j        j        | 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   s    rw   r   zArgument.show_default-  sg     = 	/5^(0?*49N2OOOo%)>>>t~Gb>5>..r   c                     t          t          | j                  pWt          | j                  oCt	          d t          | j                  D                       pt          | j        j                            S )Nc              3   4   K   | ]}t          |          V  d S r   )r   r   xs     rw   r   z6Argument._use_pydantic_type_adapter.<locals>.<genexpr>@  s(      DD1ADDDDDDr   )	rY   r   rB   r   r   r
   r3   r>   rm   r   s    rw   _use_pydantic_type_adapterz#Argument._use_pydantic_type_adapter9  sr    	"" ## DD0C0CDDDDD O24?3MNN	
 	
 		
r   r   c                 f    	 | j         |         j        S # t          $ r | j         | j        cY S w xY wr   )rM   rm   KeyErrorrL   )rV   r   s     rw   _type_hint_for_keyzArgument._type_hint_for_keyF  sK    	!<$// 	! 	! 	!}$=   	!s    00c                    || j         }|sdS t          |d         t                    r|d         j        n|d         }|                                                    d          sdS | j        r;| j        j        | j        j        S t          | j
        j        t                    rdS dS t          | j                  }t          |          }|t           v r"t#          |          }|r|d         t          urdS dS )zEWhen parsing, should attempt to parse the token(s) as json dict data.NFr   {T)r=   r[   r-   rF   stripr6   rK   r?   	json_dictr   r>   rm   rb   r   rB   r   r   r
   )rV   r=   rF   rB   rp   ru   s         rw   _should_attempt_json_dictz"Argument._should_attempt_json_dictN  s    >[F 	5#-fQi#?#?Nq	VAY{{}}'',, 	5! 	~'3~//T_7== u4ty!!D!!^##D>>D Qs**tur   c                    || j         }|sdS |                     |          \  }}|sdS t          |t                    r|j        }nHt          |t
                    r|}n0t          |d         t                    r|d         j        n|d         }|                                                    d          sdS | j        j	        | j        j	        S t          | j        j                  pt
          fD ]}t          |t
                    r dS dS )zEWhen parsing, should attempt to parse the token(s) as json list data.NFr   [T)r=   r   r[   r-   rF   rb   r   r6   r?   	json_listr
   r>   rm   r   )rV   r=   rE   _consume_allrF   r   s          rw   _should_attempt_json_listz"Argument._should_attempt_json_listh  s    >[F 	5))$//; 	5fe$$ 	SLEE$$ 	SEE'1&)U'C'CRF1IOOPQE{{}}'',, 	5>#/>++DO677AC6 	 	CS#&& uutr   .	transform	delimitertermr   r   c                    | j         j        st          t          |t                    r|                     |          n|                     |||          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^   r[   rZ   _match_index_match_name)rV   r   r   r   s       rw   matchzArgument.match  s\    . ~# 	 $$$RDd###!!$)y!QQ	
r   c                   | 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 s| j        t          v rdnt          }|r|d         |k    r|dd         } n"wd|fc S ~t          | j         j                  }t!          |          rt#          |          }n|f}|D ]}t          |          }d}	| j                            |          D ]}|r ||          }t          ||          r|t          |          d         }|t          v rd}n<t'          |          s|d}n(t)          |          } t+          |          p|            }|r|d         |k    r|dd         }d}	 n
d|fc c S |	r nt,          | j        st,          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   r1   rD   F)r>   rk   rl   tuplelstripsplitr.   r?   rj   r6   lenrB   rY   r+   r   rm   r   r
   get_negativesr   r   r   r^   r   )
rV   r   r   r   trailingimplicit_valuerj   rB   rn   double_breaks
             rw   r   zArgument._match_name  s   < ?4?#>>>S))//	::;;UBB~""""N' +	! +	!D ' y$%% .D		,)-d):):diKh>h>hns .{i//#+ABB< 0 ~----. %T_%?@@D~~    ! !(..$ N88>> 6 6D  /(y!$-- 6#'D		#4#@@@-2NN(.. J$,-1NN#3D#9#9D.Fj.>.>.F$-I-IN# 6'{i77+3ABB</3 %  8
 $&~#5555556    E ! / 	X^^I..//??r   c                     | j         t          | j        j        | j        j        u r|| j         k     rt          n|| j         k    rt          dt
          fS NrD   )rC   r^   r>   rk   VAR_POSITIONALr.   )rV   rC   s     rw   r   zArgument._match_index  sZ    :_!T_%CCCtz!!   "dj  5yr   tokenc                    | j         j        st          t          fd| j        D                       r;|                     j                  \  }}|s| j         j        st                    | j        rCt          j                  t          d | j        D                       z  rt          |           | j                                       dS )zSafely add a :class:`Token`.c              3   8   K   | ]}|j         j         k    V  d S r   )address)r   r   r   s     rw   r   z"Argument.append.<locals>.<genexpr>  s,      ??aqyEM)??????r   )r   c              3   $   K   | ]}|j         V  d S r   rE   r   s     rw   r   z"Argument.append.<locals>.<genexpr>  s$      %B%Baf%B%B%B%B%B%Br   argumentN)r?   r_   r^   r   r=   r   rE   rX   r"   rY   r!   append)rV   r   r   r   s    `  rw   r   zArgument.append  s    ~# 	????4;????? 	7!--ej99NA{ 7t~'; 7)6666; 	8EJ#%B%Bdk%B%B%B"B"BB 8($77775!!!!!r   c                 f    t          | j                  pt          d | j        D                       S )z@This argument, or a child argument, has at least 1 parsed token.c              3   $   K   | ]}|j         V  d S r   )
has_tokensr   s     rw   r   z&Argument.has_tokens.<locals>.<genexpr>  s$      'L'L'L'L'L'L'L'Lr   )rY   r=   r   rN   r   s    rw   r   zArgument.has_tokens  s2     DK  LC'L'Ldm'L'L'L$L$LLr   c                     ddl m}  |            }| j        D ]1}|                    |           |                    |j                   2|S )Nr   r7   )rW   r8   rN   r   extendchildren_recursive)rV   r8   outchilds       rw   r   zArgument.children_recursive  sb    DDDDDD  ""] 	1 	1EJJuJJu/0000
r   c                    | j         rxdd l}|                                 }	 |                    | j        j                                      |          S # |j        $ r }|                     |           Y d }~d S d }~ww xY wt          S )Nr   )
r   pydantic_jsonTypeAdapterr>   rm   validate_pythonr#   !_handle_pydantic_validation_errorr.   )rV   r   unstructured_dataes       rw   _convert_pydanticzArgument._convert_pydantic   s    ? 		OOO $

:++DO,FGGWWXijjj+ : : :66q999999999: Ls   1A 
A=A88A=rA   c                     ddl m}  j        j        rLt	           j        j        t
                    r t           j         j        j                  n/ j        j        n" t          t           j        j
                  J  fd j        j        s	t          }n" j        j        r t          d  j        D                       }n j        s8g }i } fd}t#           | j                            }|D ]}t%           j                  }	|j        t          urBt	          |j        t)          |	          p|	          rt+          |          dk    sJ |j        c S |j        r_|}
|j        d d         D ]}|
                    |i           }
|
                    |j        d         g                               |           n|                    |           |r|rt3           	          |r j        ru j        j         j        j        u r]t;           j                  d                                          \  }}t?          fd
tA          ||          D                       }nR  j        t?          |                    }n2|r\ j        rB j        j         j        j!        u r* j        s# fd|"                                D             }n  j        |          }nԉ j#        rtI           	          t          S i }t          } j%        r %                    d          } j%        rQ j        rJ  j%         j                  }|t	          |t"                    rtM          tN          j(        |          n|z  } )                                r j        r j        *                    d          }	 tW          j,        |j-                  }n.# tV          j.        $ r}t_          | j                  |d }~ww xY w | j0        1                    d          |i|j2         j3        dd            j         j4        r 5                                S  j        r8 j%        s1d  j        D             }|r  j        t?          |                    S  j        D ]}t+          |j                  t+           j                  dz   k    sJ |j6        r%|7                              ||j        d         <   ]|j#        r;|}|j        D ]*}	 ||         }# tp          $ r tI          |	          d w xY wd|_9         :                    |            j%        r-|tw           j%        | j        j
                  z  }|st          }n6|rty           j        |          }n j#        rtI           	          t          }|S )Nr   )update_argument_collection)name_transformc                    t          |t                    rS	  | |          S # t          t          t          f$ r,}t          |j        r|j        d         nd |           |d }~ww xY w	 t          j                  r |          S  | |          S # t          t          t          f$ rJ}t          |          dk    r|d         nd }t          |j        r|j        d         nd | |          |d }~ww xY w)Nr   )msgr   target_typer1   )r   r   r   r   )
r[   ra   AssertionErrorr^   rd   r   ru   inspectismethodr   )rB   r=   r   r   rA   rV   s       rw   safe_converterz)Argument._convert.<locals>.safe_converter:  s7   &$'' s$9T6222&
I> s s s',IAF1IITTXfjkkkqrrs'	22 7(y000  )yv666&
I>   ),V)9)9F1IItE')*9AF1IITDVZbg  s3   $ A''A""A'+B 
B C7-AC22C7c              3   @   K   | ]}|j         t          u|j         V  d S r   )r   r.   r   r   s     rw   r   z$Argument._convert.<locals>.<genexpr>R  s3      iiuuG[chGhGhe*GhGhGhGhiir   c              3   ~  K   | D ]5}                     |          r	 t          j        |j                  }n.# t          j        $ r}t          |j                  |d }~ww xY wt          |t                    st          |j                  |s|	                    dg           V  |D ]}||	                    d|          V  t          |t                    r+|	                    t          j        |                    V  ^|	                    t          |                    V  1|V  7d S )Nr   r    )rF   r   )rF   )r   jsonloadsrF   JSONDecodeErrorr   rB   r[   listevolvera   dumpsrb   )r=   r   parsed_jsonr   elementrV   s        rw   expand_tokensz(Argument._convert.<locals>.expand_tokensW  s     # $ $E55e<< $[*.*U[*A*AKK#3 [ [ ["/e"S"S"SYZZ[  *+t<< T"/e"S"S"SS* 	K"',,R,"K"KKKKK+6 K K#*?*/,,RPW,*X*X$X$X$X$X%/%>%> !K*/,,TZ=P=P,*Q*Q$Q$Q$Q$Q*/,,S\\,*J*J$J$J$J$JK $+$ $s   :A%	A  A%r1   r   c              3   0   K   | ]} |          V  d S r   rD   )r   ri   rB   r   s     rw   r   z$Argument._convert.<locals>.<genexpr>  s/      sstV < <ssssssr   c                 `    i | ]*\  }}| t          j                  d          |          +S )r1   )r
   rB   )r   r   rF   r   rV   s      rw   
<dictcomp>z%Argument._convert.<locals>.<dictcomp>  s=    pppR\RUW\3x	/B/B1/Eu M Mpppr   r   r   rD   F)	root_keysallow_unknownc                      g | ]}|j         	|S rD   r   r   s     rw   
<listcomp>z%Argument._convert.<locals>.<listcomp>  s    $V$V$Vu5:$VU$V$V$Vr   rA   T)=rW   r   r?   rA   r[   rb   getattrrB   r   r   r   r_   r.   rX   sumr=   rN   r   r   r   r   r   rE   
setdefaultr   r!   r>   rk   r   r
   r   r   r/   rl   r|   r   r    rS   r   operatoror_r   popr   r   rF   r   r   rj   r   sourcer   r   r   r   convert_and_validate	Exceptionr   _run_missing_keys_checkerr2   r   )rV   rA   r   r   
positionalkeywordr   expanded_tokensr   ro   lookupr   tokens_per_elementr   dataconverted_flagsr   r   positional_tokensr   objkrB   r   s   ``                    @@rw   _convertzArgument._convert,  s   LLLLLL># 	W$.2C88 5#DIt~/GHH		 N4		8UVVVI$$$	 	 	 	 	 	* ~# ~	CC^! |	iiiiiiiCC z	&(JG$ $ $ $ $0 #==#=#=>>O( < < 0 ; ;'u44(*]*C*C*T}: :4 //14444 ////: -$F$z#2# < <!'!2!23!;!;%%ejnb99@@GGGG%%e,,, <' <,d;;;; ? Gt';t?]']']#DI..q1D,0,<,<,>,>)&sssss7S]_qKrKrsssssCC(.E*4E4EFFCC ? =t';t?Z'Z'Zcgcl'Zppppp`g`m`m`o`opppCC(.G<<CC *D9999DC# .**1--# w w"0.1Et{"S"S
?\`@a@avvhlO<<<gvv--// k  KOOA..EW&*j&=&=/ W W W+%TYOOOUVVW..))#..</"$&+    k  . 0--///{ O4#7 O$V$V$V$V$V!$ O)>$)U;L5M5MNNN ) )5:3ty>>A+=>>>># 	)+0+E+EPY+E+Z+ZDB((^ )C"Z Q QQ"%a&CC( Q Q Q"6"F"F"FDPQ$(EM**4000# 	*4+?t~Gdeee  C +DIt<< *D9999
s$   O P,PPT  T<c                     | j         sm	 |                     |          | _        nP# t          $ r'}|j        | |_        |j        | j        |_         d}~wt          $ r}|j        | |_         d}~ww xY 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  rF   r   r   r   rB   r   )rV   rA   r   s      rw   r   zArgument.convert  s     | 	!]]Y]??

    :%!%AJ=($(IAM    :%!%AJ
 zs    % 
A2"AA2A--A2c                      t           j        j        t                    sJ dt          j        v r>ddlt          d j                            d          D                       }|dk     rdnd fd}	  j	        s j
        r j
        j         j
        j        u rvt           j                  d         } j        j        D ]%}|                                D ]} |||           & |t           t"           j
        j        f         |           dS  j
        rw j
        j         j
        j        u r_t           j                  d         } j        j        D ]}|D ]} |||            |t           j
        j        d	f         |           dS  j        j        D ]} | j        |            | j
        j        |           dS # t(          t*          t,          f$ r+}t/          |j        r|j        d         nd
           |d}~ww xY w)zValidates provided value.

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

        Returns
        -------
        Any
            The converted data. Same as :attr:`value`.
        r   r   Nc              3   4   K   | ]}t          |          V  d S r   )rZ   r   s     rw   r   z$Argument.validate.<locals>.<genexpr>   s(      $U$USVV$U$U$U$U$U$Ur   r   )   c                     sd S j         rd S 	                     |                               |           d S # j        $ r }                    |           Y d }~d S d }~wj        $ r Y d S w xY wr   )r   r   r   r#   r   PydanticUserError)rB   r   r   r   rV   s      rw   validate_pydanticz,Argument.validate.<locals>.validate_pydantic  s     . $$T**::3?????+ : : :66q999999999-   s   (: 
A0AA0/A0r1   .r   exception_messager   )r[   r?   	validatorr   sysmodulesr   __version__r   rE   r>   rk   rl   r
   rB   ri   ra   rb   rm   r   r   r^   rd   r#   ru   )	rV   rF   pydantic_versionr  rB   r  r   r   r   s	   `       @rw   validatezArgument.validate  s}    $.2E:::::$$OOO$$U$UX5I5O5OPS5T5T$U$U$UUU$&&H	 	 	 	 	 		g9 E ET_5IT_Mh5h5h	**1-!%!9 - -I$||~~ - -!	$,,,,-!!$sDO,F'F"GOOOOO 	ET_%9T_=[%[%[	**1-!%!9 - -I$ - -!	$,,,,-!!%(BC(G"H%PPPPP!%!9 0 0IIdi////!!$/"<eDDDDD
I6 	g 	g 	g!4OAF1IIRZ^___eff	gs&   9BG A<G 6G H"&HHc                     |                      |          }|t          ur|                     |           n7| 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   )rV   rA   r   s      rw   r  zArgument.convert_and_validate'  se     llYl//eMM#_$IO;;MM$/1222
r   c                     | j         j        rdS | j         j        | j         j        dk    rdS t          |          dk    r| j        }n6t          |          dk    r|                     |d                   }n| j        }t          |          \  }}| j         j        |fS t          |          dk    r| j        }nAt          |          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   FNr   )r1   Tr1   r   )	r?   rX   n_tokensr   rL   r   rB   r   rS   )rV   rE   rB   r   consume_all_from_typer
  r   s          rw   r   zArgument.token_count;  s#   " > 	8
 >".~&",,w t99q===DDYY!^^2247;;DD9D ,7t+<+<((~.0EEEt99q===DDYY!^^**4733DD9D# D w*5d*;*;'K!;..r   c                 d    | j                             t          | j        j                            S )z5Negative flags from :meth:`.Parameter.get_negatives`.)r?   r   r   r>   rm   r   s    rw   	negativeszArgument.negativeso  s(     ~++,=do>X,Y,YZZZr   c                     | j         d         S )z2The **first** provided name this argument goes by.r   )r~   r   s    rw   rj   zArgument.namet  s     z!}r   c                     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)	itertoolsr[   r?   rj   r   chainr&  )rV   r)  s     rw   r~   zArgument.namesy  sN     	$.-u55555Y__T^%8$.IIJJJr   c                 F    | j                             | j        ||          S )z:Split a given value with :meth:`.Parameter.env_var_split`.)r   )r?   env_var_splitrB   )rV   rF   r   s      rw   r,  zArgument.env_var_split  s!    ~++DIu	+RRRr   c                 *    | 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.
        )rN   r?   showr   s    rw   r.  zArgument.show  s     = 8T^%88r   c                 J    | j         j        | j        j        S | j         j        S )z<Whether or not this argument requires a user-provided value.)r?   r   r>   r   s    rw   r   zArgument.required  s%     >"*?++>**r   c                     | j         j        S r   )r>   is_positional_onlyr   s    rw   r1  zArgument.is_positional_only  s    11r   c                 6    | j         j        | j         j        k    S r   )r>   rk   r   r   s    rw   is_var_positionalzArgument.is_var_positional  s    #t'EEEr   c                 2    |                                  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   s    rw   is_flagzArgument.is_flag  s    * !!Z//r   forcec                     |s| j         j        sdS t          | j        | j         j                  }|rt          |          n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_choicesr4   rB   r   r   )rV   r6  choicess      rw   get_choiceszArgument.get_choices  sH    6  	T^8 	4'	4>3PQQ!(2uW~~~d2r   c                 0   i }| j         r^| j        D ]V}|}|j        dd         D ]}|                    |i           }|j        t
          u r|j        n|j        ||j        d         <   W| j        D ]}d|_        |j	        s|j        t          | j                  d         }|j         r"|                                }|r|||d         <   \t          |j                  p|j        t          v r|j        D ]}|j        t
          ur5|                    |d         g                               |j                   E|j        }t!          |t"                    r[|                                rG|                                d         dv r+	 t'          j        |          }n# t&          j        $ r Y nw xY w|                    |d         g                               |           s|j        d         }|j        t
          u r|j        n|j        ||d         <   |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   )rK   r=   rE   r   r   r.   rF   rN   r   r   r   r   r   rB   r   r   r[   rb   r   r   r   r   r   )	rV   r   r   noder   r   rE   resultrF   s	            rw   r   zArgument._json  s@    ! 	n n n :crc? 4 4C??333DD6;6Je6S6Su{{Y^YmUZ^$$] 	f 	fE EM# :c$)nn../D& f *#)CQLUZ((6EJ>II"\ C CE+588tBx44;;E<PQQQQ %%eS11 %ekkmm %VWHX\fHfHf%(,
5(9(9#'#7 % % % $%tBx44;;EBBBBC Q.3.Be.K.Ku{{QVQeDG
s   FF-,F-c                 b   | j         r	| j        s|sd S |                      | |          x}sd S |d         }| j        |fz   }| j                            |          }|rt          |d                   | j        j        d         dz   d                    |          z   }t          d| d          )Nr   keys_prefixr   z->zRequired field "z]" is not accessible by Cyclopts; possibly due to conflicting POSITIONAL/KEYWORD requirements.)
rQ   r   rE   rN   	filter_byr    r>   r~   joinr^   )rV   r  missing_keysmissing_keyrE   missing_argumentsmissing_descriptions          rw   r  z"Argument._run_missing_keys_checker  s    ) 	$- 	 	F $ : :4 F FF 	F"1oyK>) M333EE 	&0A!0DEEEE"&/"7":T"ADIIdOO"S V#6  V  V  V  r   c                 B   dd l }|                                d         }|d         dk    r@| j                            | j        |d         z             d         }t          |          |t          ||j                  rt          t          |          |           ||)Nr   r\   missinglocr?  r   r  )	r   errorsr   rA  rE   r    r[   r#   rb   )rV   excr   errormissing_arguments        rw   r   z*Argument._handle_pydantic_validation_error  s    

Q=I%%#6@@TYY^_dYeMe@ffghi&0@AAAsJX566 	!CHHtLLLRUUIr   r   r   )r   r8   )rD   )F)I__name__
__module____qualname____doc__r   r   r=   r-   rU   r$   r>   r,   r?   rb   r   rB   r	   rC   rZ   rE   r   r.   rH   rK   rY   rL   ra   rM   rN   rO   rP   rQ   r   rR   rS   rx   re   propertyrF   setterr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r  r  r   r&  rj   r~   r,  r.  r   r1  r3  r5  r:  r   r  r   rD   r   rw   r;   r;   C   s         
  %---FDK---
 "E)444J	444 !5333Iy333 cW555D#555 d+++E3:+++
 "E"---D%S/---%N %gu555FC555 $eEEJJJtJJJE$U???Hc???$)E$U$O$O$OGT#y.!OOO%*UE%B%B%BH"BBB $eEEJJJtJJJ%*U5u5%Q%Q%QdQQQ-2U4eRW-X-X-X8d?XXX+05EPU+V+V+VDVVV"'%5u"M"M"MOS4ZMMMUG UG UGn/$sI~*> / / / /"   X \  \ F F XF ^'T ' ' ' ^' CT C C C XC 	/dXseSj%99 	/ 	/ 	/ X	/ 

D 

 

 

 X

!c ! ! ! ! 0E0L X\    6 bd us{+e3c9D@OTUXZ]U]	   < 26
 
 
Ci
 SE3J'$.	

 
 
uS#X#	$
 
 
 
F 26U@ U@ U@U@ SE3J'$.	U@
 U@ 
uS#X#	$U@ U@ U@ U@n# %c3h0D*E    "E " " " " MD M M M XM    X
 
 
c c(T/ c c c cJ D    :7g 7g 7gr ho    (2/ 2/c3h 2/ 2/ 2/ 2/h [ [ X[ c    X KuS#X K K K XKS S3 S3: Sc S S S S 9d 9 9 9 X9 +$ + + + X+2D 2 2 2 2F4 F F F F0 0 0 0 0.3 3 3%S/D2H 3 3 3 3@'t ' ' ' 'R   
 
 
 
 
r   r;   )HrQ  r   r   r   r  collections.abcr   r   
contextlibr   	functoolsr   r   r{   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/   r0   utilsr2   r3   r4   r5   r6   rW   r8   r;   rD   r   rw   <module>r`     s#   / /    



 . . . . . . . .       % % % % % % % % ; ; ; ; ; ; ; ; ; ; ; ;                                                                               H G G G G G G G             5 5 5 5 5 5 5 5 5 5               A@@@@@@ Q Q Q Q Q Q Q Q Q Qr   