
    Kiڦ                        d Z ddl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'm(Z( dd
l)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/ ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 ddl8m9Z9m:Z: ddl;m<Z< ddl=m>Z>m?Z?m@Z@mAZA ddlBmCZCmDZDmEZEmFZFmGZG erddlHmIZI  ed       G d d             ZJy)z)Argument class and related functionality.    N)CallableSequence)suppress)partialreduce)TYPE_CHECKINGAnyget_args
get_origin)definefield)_validate_json_extra_keysconvertinstantiate_from_dicttoken_count)ITERABLE_TYPES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parse_version   )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&jN                  d#        Z&e%d$        Z(e(jN                  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,dPde-eez     dz  d&efd,Z.	 dQd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%dRd9       Z5d: Z6dPd;e dz  fd<Z7dPd;e dz  fd=Z8d> Z9dPd;e dz  fd?Z:dSd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>dPded2edz  d&ee   fdDZ?e%d&efdE       Z@e%d&efdF       ZAe%d&efdG       ZBd&efdHZCd&efdIZDd&efdJZEdTdKed&eedf   dz  fdLZFd&efdMZGdN ZHdO ZIy)U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)rB   index .keysvalue)aliasrB   _valueF)rB   initrepr_accepts_keywords_default)r>   rK   rL   _lookup)rK   rL   r:   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                  rTt        |      }|t        u s(|t        u s9t        |t              rt        |t              st        d| j                   d      | j                  j                   r!| j                  j"                  rt        d      | j$                  s| j&                  j(                  | j&                  j*                  u }| j&                  j,                  | j&                  j.                  u}|s%|s#t        d| j&                  j0                   d      y | j                  j2                  du ry |D ]  }t5        |      }||h}t7        |      }	t8        |v r\d	| _        t<        t<        }}
t        |      }t?        t@              5  |d   }
|d
   }d d d        |
t<        urtC        d      || _"        ntG        |      r.tI        tJ              | _&        d	| _        | jO                  |	       nutQ        |      r.tI        tR              | _&        d	| _        | jO                  |	       n<tU        |      rDtI        tR              | _&        d	| _        tW        |d      st        d      | jO                  |	       ntY        |      r-tI        tZ              | _&        d	| _        | jO                  |	       nt]        |      r-tI        t^              | _&        d	| _        | jO                  |	       n}ta        |      r || _1        d	| _        | jO                  |	       nRte        |      s/|	r-tI        tR              | _&        d	| _        | jO                  |	       n| j                  j2                  0| j                  j2                  Hd	| _        tI        tR              | _&        tg        ti        |jj                        jm                               D ]a  \  }}|dk(  r|j0                  dk(  r|j(                  |jn                  u r|jp                  | _"        E| jO                  |j0                  |i       c  y # 1 sw Y   xY w)Nr   r9   z5Parameter(count=True) requires an int type hint, got zA. Use 'Annotated[int, Parameter(count=True)]' for counting flags.zParameter(requires_equals=True) and Parameter(consume_multiple=...) cannot be used together. requires_equals enforces '--option=value' syntax, which is incompatible with consume_multiple's space-separated value consumption.zNon-parsed parameter 'zD' must be a KEYWORD_ONLY function parameter or have a default value.FTr3   z1Dictionary type annotations must have "str" keys.__annotations__zGCyclopts cannot handle collections.namedtuple without type annotations.self)9cyclopts.argument._collectionr:   rP   r   rD   r   r
   rA   countr   boolint
isinstancetype
issubclass
ValueErrorrequires_equalsconsume_multipleparser@   kindKEYWORD_ONLYrB   emptynameaccepts_keysr   r*   dictrM   strr   
IndexError	TypeErrorrN   r   r7   r)   rS   _update_lookupr   r'   r   hasattrr   r&   r   r(   r   rU   r1   	enumerater+   __init__valuesVAR_KEYWORD
annotation)rX   r:   rD   hintsresolved_hintis_keyword_onlyhas_defaultoriginhint_originfield_infoskey_typeval_typeargsir@   s                  g/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/cyclopts/argument/_argument.py__attrs_post_init__zArgument.__attrs_post_init__   s   D*,tyy!"*4.tg>>,T2M$$M4)HZXegjMk KDII; WV W 
 >>))dnn.M.MH  zz"oo22doo6R6RRO//119N9NNK#{ ,T__-A-A,B C/ /  >>&&%/ ;	GD%F.K)$/K{")-&%(#(~j) '#AwH#AwH' 3&#$WXX (d#-ABY-Z*)-&##K0d#-AB\-]*)-&##K0t$-AB\-]*)-&t%67$%noo##K0$-ABT-U*)-&##K0T"-ABW-X*)-&##K0d#'+$)-&##K0%+-AB\-]*)-&##K0,,4~~**2%)D")=>X)YD&!*+?+N+U+U+W!X G:6joo7??j&<&<<$.$9$9DM''*(EFGk;	G' 's   R  R
	rz   c                    ddl m} t        | j                  j                        }|j                         D ]  \  }}| j                  j                  |      x}r`||k(  r)|rR||j                  v rD||j                  v r6||j                  |j                  f   |_        t        j                  |_        }t        || j                  |<    y )Nr   )Literal)typingr   r5   r@   rs   itemsrO   getnamesr%   rf   rB   NotImplementedError)rX   rz   r   discriminatorkeyr@   existing_field_infos          r   rm   zArgument._update_lookup  s    "3DOO4N4NO*002 
	/OC&*ll&6&6s&;;";&*4"}
8H8H'H]^q^w^wMw5<=P=[=[]g]r]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.
        )rJ   rX   s    r   rH   zArgument.value   s     {{r   c                 F    | j                   rd| _        d| _         || _        y )NT)_markedrR   rJ   )rX   vals     r   rH   zArgument.value)  s    <<,0D)r   c                 4    | j                   | j                  z  S )zdIf ``True``, then this node in the tree has already been converted and ``value`` has been populated.)rQ   rR   r   s    r   r   zArgument._marked0  s     %%(E(EEEr   c                     || _         y N)rQ   )rX   rH   s     r   r   zArgument._marked5  s
    !&r   returnc                     t        | j                        rt        | j                        n| j                  f}t        d |D              S )Nc              3   B   K   | ]  }t         |t        |      fv   y wr   )ri   r   ).0args     r   	<genexpr>z7Argument._accepts_arbitrary_keywords.<locals>.<genexpr><  s     Bc4CC11Bs   )r   rD   r
   any)rX   r}   s     r   _accepts_arbitrary_keywordsz$Argument._accepts_arbitrary_keywords9  s4    &.tyy&9x		"		|BTBBBr   c                 V   | j                   ry| j                  j                  .| j                  j                  d| j                  j
                  fvS | j                  j                  | j                  j
                  u s| j                  j                  sy| j                  j                  S )z(Show the default value on the help page.FN)requiredrA   show_defaultr@   rB   rf   r   s    r   r   zArgument.show_default>  s}     ==^^((0??**49N9N2OOOoo%%)>)>>t~~GbGb>>...r   c                     t        t        | j                        xs] t        | j                        xrF t	        d t        | j                        D              xs t        | j                  j                              S )Nc              3   2   K   | ]  }t        |        y wr   )r   r   xs     r   r   z6Argument._use_pydantic_type_adapter.<locals>.<genexpr>Q  s     D1ADs   )	r[   r   rD   r   r   r
   r5   r@   rs   r   s    r   _use_pydantic_type_adapterz#Argument._use_pydantic_type_adapterJ  s`    		" # D0CDD O24??3M3MN	
 		
r   r   c                     	 | j                   |   j                  S # t        $ r | j                   | j                  cY S w xY wr   )rO   rs   KeyErrorrN   )rX   r   s     r   _type_hint_for_keyzArgument._type_hint_for_keyW  sB    	!<<$/// 	!}}$== 	!s    "A A c                    || j                   }|syt        |d   t              r|d   j                  n|d   }|j	                         j                  d      sy| j                  rR| j                  j                  | j                  j                  S t        | j                  j                  t              ryyt        | j                        }t        |      }|t         v rt#        |      }|r|d   t        uryy)zEWhen parsing, should attempt to parse the token(s) as json dict data.Fr   {T)r?   r]   r.   rH   stripr8   rM   rA   	json_dictr   r@   rs   rj   r   rD   r   r   r
   )rX   r?   rH   rD   rx   r}   s         r   _should_attempt_json_dictz"Argument._should_attempt_json_dict_  s    >[[F#-fQi#?q	VAY{{}'',!!~~''3~~///T__77=tyy!D!^#D>DQs*r   c                    || j                   }|sy| j                  |      \  }}|syt        |t              r|j                  }n:t        |t
              r|}n't        |d   t              r|d   j                  n|d   }|j                         j                  d      sy| j                  j                  | j                  j                  S t        | j                  j                        xs t
        fD ]  }t        |t
              s y y)zEWhen parsing, should attempt to parse the token(s) as json list data.Fr   [T)r?   r   r]   r.   rH   rj   r   r8   rA   	json_listr
   r@   rs   r   )rX   r?   rG   _consume_allrH   r   s          r   _should_attempt_json_listz"Argument._should_attempt_json_listy  s     >[[F))$/;fe$LLE$E'1&)U'CF1IOOPQE{{}'',>>##/>>+++DOO667AC6 	CS#&	 r   .	transform	delimitertermr   r   c                    | j                   st        t        |t              r| j	                  |      S | j                  |||      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   )rc   r`   r]   r\   _match_index_match_name)rX   r   r   r   s       r   matchzArgument.match  sN    . zz $$ d#	
 !!$)y!Q	
r   c                <   | j                   j                  | j                   j                  u r/t        |j	                  d      j                  |            t        fS |}t        }| j                  j                  sJ | j                  j                  D ]j  }|r ||      }t        ||      s|t        |      d }| j                  t        u s| j                  t        v rdnt        }|r|d   |k(  s_|dd } nd|fc S  t        | j                   j                        }t!        |      rt#        |      }n|f}|D ]  }t        |      }d}	| j                  j%                  |      D ]|  }|r ||      }t        ||      s|t        |      d }|t        v rd}n/t'        |      s|d}nt)        |      } t+        |      xs |       }|r|d   |k(  sm|dd }d}	 n	d|fc c S  |	s n t,        | j.                  st,        t        |j                  |            |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   r3   rF   F)r@   rd   rr   tuplelstripsplitr/   rA   rg   r8   lenrD   r[   r,   r   rs   r   r
   get_negativesr   r   r   r`   r   )
rX   r   r   r   trailingimplicit_valuerg   rD   rt   double_breaks
             r   r   zArgument._match_name  s   < ??4??#>#>>S)//	:;UBB~~""""NN'' +	!D $%D	,)-d):diiKh>hns{i/#+AB<~--+	! %T__%?%?@D~  !(.$ NN88> 6D (!$-#'D	#4#@@-2N(.$,-1N#3D#9D.Fj.>.F$-IN#'{i7+3AB</3 %#%~#55%6&  /!2 ! //X^^I./??r   c                     | j                   t        | j                  j                  | j                  j                  u r|| j                   k  rt        dt
        fS || j                   k7  rt        dt
        fS NrF   )rE   r`   r@   rd   VAR_POSITIONALr/   )rX   rE   s     r   r   zArgument._match_index	  sj    ::__!!T__%C%CCtzz!   5y djj 5yr   tokenc                    | j                   st        t        fd| j                  D              r| j                  j
                  du rt              | j                  j                        \  }}| j                  j
                  du r<|s^| j                  D cg c]  }|j                  j                  k7  s|  c}| _        n$|s"| j                  j                  st              | j                  r>t        j                        t        d | j                  D              z  rt        |       | j                  j                         yc c}w )zSafely add a :class:`Token`.c              3   P   K   | ]  }|j                   j                   k(    y wr   )address)r   r   r   s     r   r   z"Argument.append.<locals>.<genexpr>  s     ?aqyyEMM)?s   #&F)r   Tc              3   4   K   | ]  }|j                     y wr   )rG   r   s     r   r   z"Argument.append.<locals>.<genexpr>$  s     %Baff%B   argumentN)rc   r`   r   r?   rA   allow_repeatingr#   r   rG   r   rZ   r[   r"   append)rX   r   r   r   r   s    `   r   r   zArgument.append  s    zz?4;;??~~--6)66!--ejj9NA{~~--5".2kk"XQYY%--=W1"XDK )=)=)66;;EJJ#%Bdkk%B"BB($775! #Ys   E;Ec                 h    t        | j                        xs t        d | j                  D              S )z@This argument, or a child argument, has at least 1 parsed token.c              3   4   K   | ]  }|j                     y wr   )
has_tokensr   s     r   r   z&Argument.has_tokens.<locals>.<genexpr>+  s     'L'Lr   )r[   r?   r   rP   r   s    r   r   zArgument.has_tokens(  s'     DKK LC'Ldmm'L$LLr   c                     ddl m}  |       }| j                  D ].  }|j                  |       |j	                  |j
                         0 |S )Nr   r9   )rY   r:   rP   r   extendchildren_recursive)rX   r:   outchilds       r   r   zArgument.children_recursive-  sE    D "]] 	1EJJuJJu//0	1 
r   c                    | j                   rIdd l}| j                         }	 |j                  | j                  j
                        j                  |      S t        S # |j                  $ r}| j                  |       Y d }~y d }~ww xY w)Nr   )
r   pydantic_jsonTypeAdapterr@   rs   validate_pythonr$   !_handle_pydantic_validation_errorr/   )rX   r   unstructured_dataes       r   _convert_pydanticzArgument._convert_pydantic7  st    ?? $

:++DOO,F,FGWWXijj L ++ :66q99:s   3A B+BBrC   c           
          ddl m}  j                  j                  rft	         j                  j                  t
              r+t         j                   j                  j                        n> j                  j                  n'%t        t         j                  j                        J  fd j                  st        }|S  j                  j                  rt        d  j                  D              }|S  j                   swg }i } fd}t#         | j                              }|D ]  }t%         j                        }	|j&                  t        urAt	        |j&                  t)        |	      xs |	      rt+        |      dk(  sJ |j&                  c S |j,                  rW|}
|j,                  d d D ]  }|
j/                  |i       }
 |
j/                  |j,                  d   g       j1                  |       n|j1                  |       |s|st3         	       |r j4                  rx j4                  j6                   j4                  j8                  u rLt;         j                        d    j=                         \  }}t?        fd
tA        ||      D              }|S   j                  t?        |            }|S |r j4                  rz j4                  j6                   j4                  jB                  u rN j,                  sB|jE                         D ci c]%  \  }}| t;         j                        d   |      ' }}}|S   j                  |      }|S  jF                  rtI         	      t        S i }t        } jJ                  r jK                  d      } jJ                  rX j                  rL  jJ                   j                        }|t	        |t"              rtM        tN        jP                  |      n|z  } jS                         r j                  r j                  jU                  d      }	 tW        jX                  |jZ                        }ta        | j                  |        | jb                  je                  d      |i|jf                   jh                  dd        j                  r jj                  r jm                         S  j                  rP jJ                  sD j                  D cg c]  }|j,                  r| }}|r  j                  t?        |            S  j                   D ]  }t+        |j,                        t+         j,                        dz   k(  sJ |jn                  r#|jq                        ||j,                  d   <   b|jF                  so|}|j,                  D ]  }	 ||   }
 d|_:          jw                  |        jJ                  r8|ty         jJ                  | j                  j                        z  }|st        }|S |rt{         j                  |      }|S  jF                  rtI         	      t        }|S c c}}w # tV        j\                  $ r}t_        | j                        |d }~ww xY wc c}w # tr        $ r tI        |	      d w xY w)Nr   )update_argument_collection)name_transformc                    t        |t              r
	  | |      S 	 t        j                        r |      S  | |      S # t        t        t        f$ r/}t        |j                  r|j                  d   nd |       |d }~ww xY w# t        t        t        f$ rE}t        |      dk(  r|d   nd }t        |j                  r|j                  d   nd | |      |d }~ww xY w)Nr   )msgr   target_typer3   )r   r   r   r   )
r]   ri   AssertionErrorr`   rl   r   r}   inspectismethodr   )rD   r?   r   r   rC   rX   s       r   safe_converterz)Argument._convert.<locals>.safe_converterQ  s    &$'s$T622''	2(00  )v66 '
I> s'AFF1ITTXfjkqrrs '
I> ),V)9F1ItE')*AFF1ITDVZbgs4   A B	 B	 B*BB	C"A CC"c              3   Z   K   | ]#  }|j                   t        us|j                    % y wr   )r   r/   )r   r   s     r   r   z$Argument._convert.<locals>.<genexpr>i  s$     iuuG[G[chGhe**is   ++c              3   T  K   | D ]  }j                  |      r	 t        j                  |j                        }t        |t              st        |j                        |s|j                  dg        s|D ]o  }||j                  d|       t        |t              r(|j                  t        j                  |             S|j                  t        |             q |  y # t        j                  $ r}t        |j                        |d }~ww xY ww)Nr   r    )rH   r   )rH   )r   jsonloadsrH   JSONDecodeErrorr   rD   r]   listevolveri   dumpsrj   )r?   r   parsed_jsonr   elementrX   s        r   expand_tokensz(Argument._convert.<locals>.expand_tokensn  s    # $E55e<[*.**U[[*AK  *+t<"/e"SS*"',,R,"KK+6 K#*?*/,,RPW,*X$X%/%>*/,,TZZ=P,*Q$Q*/,,S\,*J$JK $+$  $33 ["/e"SYZZ[s(   D(C5B;D(5D%D  D%%D(r3   r   c              3   0   K   | ]  } |        y wr   rF   )r   rq   rD   r   s     r   r   z$Argument._convert.<locals>.<genexpr>  s     stV <ss   r   r   rF   F)	root_keysallow_unknownrC   T)>rY   r   rA   rC   r]   rj   getattrrD   r   r   r   rc   r/   rZ   sumr?   rP   r   r   r   r   r   rG   
setdefaultr   r"   r@   rd   r   r
   r   r   r0   rr   r   r   r!   rU   r   operatoror_r   popr   r   rH   r   r   r   rg   r   sourcer   r   r   r   convert_and_validate	Exceptionr   _run_missing_keys_checkerr4   r   )rX   rC   r   r   
positionalkeywordr   expanded_tokensr   ru   lookupr   tokens_per_elementr   rH   dataconverted_flagsr   r   positional_tokensr   objkrD   r   s   ``                     @@r   _convertzArgument._convertC  s   L>>##$..22C8#DIIt~~/G/GH	 NN44	8U8UVI$$$	* zzC@ 
 ^^!!iiiC| 
{ &(JG$0 #=#=>O( < 0 ;''u4((*]*C*T}: /1444 ///::$F$zz#2 <!'!2!23!;<%%ejjnb9@@G%%e,',d;;#<& ??t';';t?]?]']#DII.q1D,0,<,<,>)&s7S]_qKrssCR 
O )E*4EFCN 
M ??t';';t?Z?Z'Zcgclcl`g`m`m`opR\RUW\3x		/B1/Eu MMpCpH 
E )G<CD 
C *D99DC##**1-##"01E1Et{{"S
?\`@avhllO<gvv--/kk KKOOA.EW&*jj&= .k499eL.))#.<//"$&+ kk ..--//{{4#7#78<$Vu5::U$V!$V$)$))U;L5MNN )5::3tyy>A+=>>>##+0+E+EPY+E+ZDB(^^C"ZZ QQ"%a&CQ
 %)EM) **40##*4+?+?t~~GdGdeeC 
 +DIIt< 
 *D99
I q.  // W+%TYYOUVVW %W  ) Q"6"FDPQs6   "*Y(Y. Z!Z!	Z&.ZZZ&Z=c                 >   | j                   s$	 | j                  |      | _        | j                  S | j                  S # t        $ r6}|j                  | |_        |j
                  | j                  |_         d}~wt        $ r}|j                  | |_         d}~ww xY w)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  rH   r   r   r   rD   r    )rX   rC   r   s      r   r   zArgument.convert  s     ||!]]Y]?
 zztzz ! ::%!%AJ==($(IIAM  ::%!%AJs!   = 	B1A77BBBc                     t         j                  j                  t              sJ dt        j
                  v r!ddlt        j                        }|dk  rdnd fd}	  j                  s j                  r j                  j                   j                  j                  u r|t         j                        d   } j                  j                  D ]   }|j                         D ]  } |||        "  |t         t"         j                  j$                  f   |       y j                  r j                  j                   j                  j&                  u rjt         j                        d   } j                  j                  D ]  }|D ]  } |||          |t         j                  j$                  df   |       y j                  j                  D ]  } | j                  |         | j                  j$                  |       y# t(        t*        t,        f$ r.}t/        |j0                  r|j0                  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   N)   c                     sy j                   ry 	 j                  |       j                  |       y # j                  $ r}j	                  |       Y d }~y d }~wj
                  $ r Y y w xY wr   )r   r   r   r$   r   PydanticUserError)rD   r   r   r   rX   s      r   validate_pydanticz,Argument.validate.<locals>.validate_pydantic   sk    ..$$T*::3?++ :66q99-- s    4 A.AA.-A.r3   .r   exception_messager   )r]   rA   	validatorr   sysmodulesr   r2   __version__rG   r@   rd   rr   r
   rD   rq   ri   rj   rs   r   r   r`   rl   r$   r}   )	rX   rH   pydantic_versionr  rD   r  r   r   r   s	   `       @r   validatezArgument.validate  s    $..22E::: $,X-A-AB$&H		g99T__5I5IT__MhMh5h		*1-!%!9!9 -I$||~ -!$,-- "$sDOO,F,F'F"GOT__%9%9T__=[=[%[		*1-!%!9!9 -I$ -!$,-- "%(B(BC(G"H%P!%!9!9 0Idii/0!$//"<"<eD
I6 	g!AFF1IRZ^_eff	gs'   %B?H %B!H AH I')IIc                     | j                  |      }|t        ur| j                  |       |S | j                  j                  t
        j                  ur%| j                  | 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@   rB   r%   rf   )rX   rC   r   s      r   r  zArgument.convert_and_validateA  sb     llYl/eMM# 
 __$$IOO;MM$//112
r   c                 F   | j                   j                  ry| j                   j                  | j                   j                  dk(  ryt        |      dkD  r| j                  }n/t        |      dk(  r| j                  |d         }n| j                  }t        |      \  }}| j                   j                  |fS t        |      dkD  r| j                  }n>t        |      dk(  r| j                  |d         }n| j                  }| j                  r|sy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   Fr   )r3   Tr3   r   )	rA   rZ   n_tokensr   rN   r   rD   r   rU   )rX   rG   rD   r   consume_all_from_typer  r   s          r   r   zArgument.token_countU  s   " >>
 >>"".~~&&", t9q===DY!^2247;D99D ,7t+<((~~..0EEEt9q===DY!^**473D99D##D*5d*;'K!;..r   c                 r    | j                   j                  t        | j                  j                              S )z5Negative flags from :meth:`.Parameter.get_negatives`.)rA   r   r   r@   rs   r   s    r   	negativeszArgument.negatives  s)     ~~++,=doo>X>X,YZZr   c                      | j                   d   S )z2The **first** provided name this argument goes by.r   )r   r   s    r   rg   zArgument.name  s     zz!}r   c                     ddl }t        | j                  j                  t              sJ t	        |j                  | j                  j                  | j                              S )z8Names the argument goes by (both positive and negative).r   N)	itertoolsr]   rA   rg   r   chainr(  )rX   r+  s     r   r   zArgument.names  sE     	$..--u555Y__T^^%8%8$..IJJr   c                 R    | j                   j                  | j                  ||      S )z:Split a given value with :meth:`.Parameter.env_var_split`.)r   )rA   env_var_splitrD   )rX   rH   r   s      r   r.  zArgument.env_var_split  s"    ~~++DIIu	+RRr   c                     | j                   ry| j                  j                  | j                  j                  S | j                  S )zShow this argument on the help page.

        If an argument has child arguments, don't show it on the help-page.
        Returns False for arguments that won't be parsed (including underscore-prefixed params).
        F)rP   rA   showrc   r   s    r   r0  zArgument.show  s8     ==>>*>>&&&zzr   c                 N   | j                   j                  yt        | j                   j                  t        j                        rBt        | j                   j                  j                  | j                  j                              S t        | j                   j                        S )zWhether this argument should be parsed from CLI tokens.

        If ``Parameter.parse`` is a regex pattern, parse if the pattern matches
        the field name; otherwise don't parse.
        T)	rA   rc   r]   rePatternr[   searchr@   rg   r   s    r   rc   zArgument.parse  sn     >>'dnn**BJJ7,,33DOO4H4HIJJDNN(())r   c                     | j                   j                  | j                  j                  S | j                   j                  S )z<Whether or not this argument requires a user-provided value.)rA   r   r@   r   s    r   r   zArgument.required  s4     >>""*??+++>>***r   c                 .    | j                   j                  S r   )r@   is_positional_onlyr   s    r   r7  zArgument.is_positional_only  s    111r   c                 \    | j                   j                  | j                   j                  k(  S r   )r@   rd   r   r   s    r   is_var_positionalzArgument.is_var_positional  s!    ##t'E'EEEr   c                 (    | j                         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    r   is_flagzArgument.is_flag  s    * !Z//r   forcec                     |s| j                   j                  sy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)rA   show_choicesr6   rD   r   r   )rX   r<  choicess      r   get_choiceszArgument.get_choices  sA    6 T^^88'		4>>3P3PQ!(uW~2d2r   c                    i }| j                   rs| j                  D ]d  }|}|j                  dd D ]  }|j                  |i       } |j                  t
        u r|j                  n|j                  ||j                  d   <   f | j                  D ]  }d|_        |j                  s|j                  t        | j                        d }|j                   r|j                         }|sY|||d   <   bt        |j                        xs |j                  t        v r|j                  D ]  }|j                  t
        ur/|j                  |d   g       j                  |j                         D|j                  }t!        |t"              r;|j%                         r+|j%                         d   dv r	 t'        j(                  |      }|j                  |d   g       j-                  |        Z|j                  d   }|j                  t
        u r|j                  n|j                  ||d   <    |S # t&        j*                  $ r Y w xY w)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   )rM   r?   rG   r  r   r/   rH   rP   r   r   r   r   r   rD   r   r   r]   rj   r   r   r   r   r   )	rX   r   r   noder   r   rG   resultrH   s	            r   r   zArgument._json   s     !! n ::cr? 4C??33D46;6J6Je6Su{{Y^YmYmUZZ^$	n
 ]] 	fE EM##::c$))n./D&&#)CQLUZZ(6EJJ>I"\\ CE++58tBx4;;E<P<PQ %%eS1ekkmVWHX\fHf%(,

5(9 tBx4;;EBC Q.3.B.Be.Ku{{QVQeQeDG1	f2 
 $(#7#7 % $%s   +H,,IIc                 `   | j                   r| j                  s|sy | j                  | |      x}sy |d   }| j                  |fz   }| j                  j	                  |      }|rt        |d         | j                  j                  d   dz   dj                  |      z   }t        d| d      )Nr   keys_prefixr   z->zRequired field "z]" is not accessible by Cyclopts; possibly due to conflicting POSITIONAL/KEYWORD requirements.)
rS   r   rG   rP   	filter_byr!   r@   r   joinr`   )rX   r  missing_keysmissing_keyrG   missing_argumentsmissing_descriptions          r   r  z"Argument._run_missing_keys_checker)  s    ))$-- $ : :4 FFF"1oyyK>) MM333E&0A!0DEE"&//"7"7":T"ADIIdO"S"#6"7  8U  V r   c                    dd l }|j                         d   }|d   dk(  r|d   }| j                  j                  | j                  |z         }|sMt        |      dkD  r?|dd  }| j                  j                  | j                  |z         }|st        |      dkD  r?|rt        |d         |t        ||j                        rt        t        |      |       ||)	Nr   r^   missinglocrE  r3   r   r  )
r   errorsr   rG  rG   r   r!   r]   r$   rj   )rX   excr   errorrO  rK  s         r   r   z*Argument._handle_pydantic_validation_error9  s    

Q=I%,C $ 7 7 A AdiiZ]o A ^ (CHqL!"g$($;$;$E$ERVR[R[^aRa$E$b! (CHqL !*4Ea4HIsR c8334!CHtLRUUIr   r   r   )r   r:   )rF   )F)J__name__
__module____qualname____doc__r   r   r?   r.   rW   r%   r@   r-   rA   rj   r   rD   r	   rE   r\   rG   r   r/   rJ   rM   r[   rN   ri   rO   rP   rQ   rR   rS   r   rT   rU   r   rm   propertyrH   setterr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r   r!  r  r   r(  rg   r   r.  r0  rc   r   r7  r9  r;  r@  r   r  r   rF   r   r   r=   r=   E   sy   
  -FDK-
 ")4J	4 !3Iy3 cW5D#5 d+E3:+
 ""-D%S/-%N gu5FC5 $EEJtJ$U?Hc?$)$U$OGT#y.!O%*E%BH"B $EEJtJ%*5u5%QdQ-24eRW-X8d?X+0EPU+VDV"'5u"MOS4ZMdGL/$sI~*> /"   \\  F F ^^'T ' ' CT C C 	/dXseSj%99 	/ 	/ 

D 

 

!c !0E0L X\ 6 bdus{+e3c9D@OTUXZ]U]	< 26
Ci
 SE3J'$.	

 
 
uS#X#	$
F 26U@U@ SE3J'$.	U@
 U@ 
uS#X#	$U@n# %c3h0D*E "E "* MD M M  
d(T/ dLD :9gvho (2/c3h 2/h [ [ c   KuS#X K KS3 S3: Sc S d   
*t 
* 
* +$ + +2D 2F4 F0 0.3 3%S/D2H 3@'t 'R r   r=   )KrV  r   r   r  r2  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   r   cyclopts.exceptionsr   r    r!   r"   r#   r$   cyclopts.field_infor%   r&   r'   r(   r)   r*   r+   cyclopts.parameterr,   r-   cyclopts.tokenr.   cyclopts.utilsr/   r0   r1   r2   utilsr4   r5   r6   r7   r8   rY   r:   r=   rF   r   r   <module>re     s    /    	 
 .  % ; ;         H   D D  @ K K Kr   