
    lKj\                         d dl Zd dlZd dlZd dlZd dl mZmZmZ d dlm	Z	 d dl
mZmZmZmZmZmZmZ d dlmZmZ ej*                  dk\  rd dl
mZ nd dlmZ d dlZd dl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' d d
l(m)Z) d dl*m+Z+m,Z,m-Z-m.Z.m/Z/  e0ee1   ee1   ejd                  j                  e1   e3e1   ee1   e4e1df   ee1df   h      Z5 ed      Z6 e0e1degee5      Z7d Z8de9ee9   z  dz  de4e9df   fdZ:dedef   e9z  eedef   e9z     z  dz  de4edef   e9z  df   fdZ;ddde4d   fdZ<de1e9z  ee9   z  dz  de4e9df   dz  fdZ=de1dz  de1fdZ>de1dz  de1fdZ?de1ee%e0e9   ge9ee9   z  dz  f   z  dz  de1ee%e0e9   ge9ee9   z  dz  f   z  fdZ@d ZAde4e9df   fdZBde1eCz  eeC   z  e4eCeCdz  f   z  dz  de4eCeCdz  f   dz  fdZDde1ej                  e9   z  e9z  dz  de1ej                  e9   z  dz  fdZF e.d      e, G d  d!                    ZGeGj                  D  ci c]%  } | j                  r| j                  | j                  ' c} ZL eG       ZMd"efd#ZNd)d$e6d%e1de4e6e3eG   f   fd&ZOe G d' d(             ZPyc c} w )*    N)CallableIterableSequence)deepcopy)AnyListTupleTypeVarcastget_args
get_origin)definefield)      )Self)	ITERABLE_TYPESNoneTypeis_annotatedis_nonetypeis_unionresolveresolve_annotatedresolve_new_typeresolve_optional)	FieldInfoget_field_infossignature_parameters)Group)default_name_transformfrozenoptional_to_tuple_converterrecord_initto_tuple_converter.Tc                 j    |D ].  }||j                  d      st        |j                   d       y )N-z value must NOT start with "-".)
startswith
ValueErroralias)instance	attributevaluesvalues       c/Users/ahmed/devFolder/Ultron/claude-voice/.venv/lib/python3.12/site-packages/cyclopts/parameter.py_not_hyphen_validatorr0   @   s7    !1!1#!6	00OPQQ     r.   returnc                 F    t        t        t        df   t        |             S N.)r   tuplestrr$   r.   s    r/   _str_tuple_converterr8   F   s    c3h!3E!:;;r1   c                 f    t        t        t        dt        f   t        z  df   t        |             S r4   )r   r5   r   r   r6   r$   r7   s    r/   _validator_tuple_converterr:   J   s/     hsCx(3.346H6OPPr1   z*None | Group | str | Iterable[Group | str]zGroup | str.c                 :    t        t        d   t        |             S )Nr;   )r   r5   r$   r7   s    r/   _group_tuple_converterr=   P   s    ()+=e+DEEr1   c                     t        |       S N)r"   r7   s    r/   _optional_str_tuple_converterr@   T   s    &u--r1   c                     | | S dS )NT r7   s    r/   _default_if_none_truerC   X   s    %5/4/r1   c                     | | S dS NFrB   r7   s    r/   _default_if_none_falserF   \   s    %5050r1   c                     | dS | S rE   rB   r7   s    r/   _short_alias_converterrH   `   s     M5,u,r1   c                 :    t        |t              rt        d      y )NzParameter.short_alias does not accept a string. Pass a bool to auto-generate a short flag, or a callable for custom logic. To set an explicit flag like "-z", use Parameter.alias or Parameter.name instead.)
isinstancer6   	TypeError)r+   r,   r.   s      r/   _short_alias_validatorrL   f   s%     %9
 	
 r1   defaultc                 `     dt         t        t            z  d z  dt        t         df   f fd}|S )Nr.   r2   .c                 "    | S t        |       S r?   )r$   )r.   rM   s    r/   	converterz&_negative_converter.<locals>.converterr   s    =N%e,,r1   )r6   r   r5   rM   rP   s   ` r/   _negative_converterrR   q   s4    -x},t3 -c3h - r1   c                    | | du ry| du ryt        | t              r| dk  rt        d|  d      | dfS t        | t              rt	        |       dk7  rt        d	t	        |        d      | \  }}||dfS t        |t              r0t        |t
              s t        |t              rt        |t
              r8t        d
t        |      j                   dt        |      j                   d      |dk  s|dk  rt        d| d| d      ||kD  rt        d| d| d      ||fS t        dt        |       j                   d      )zNormalize consume_multiple into (min, max) or None.

    Returns
    -------
    tuple[int, int | None] | None
        ``None`` if consume_multiple is disabled (``None`` or ``False``).
        ``(min, max)`` where ``max=None`` means unlimited.
    NFT)r   Nr   z5consume_multiple int value must be non-negative, got .   zGconsume_multiple sequence must have exactly 2 elements (min, max), got z5consume_multiple sequence elements must be int, got (, z).z<consume_multiple sequence values must be non-negative, got (z*consume_multiple min must be <= max, got (zHconsume_multiple must be None, bool, int, or a (min, max) sequence, got )	rJ   intr)   r   lenboolrK   type__name__)r.   mnmxs      r/   _consume_multiple_converterr^   {   s~    }}%19TUZT[[\]^^t}%"u:?fgjkpgqfrrstuuB::"c"jT&:*RQTBUYcdfhlYmGRHYHYGZZ\]abd]e]n]n\ooqr  6R!V[\^[__abdaeeghii7I"RPRtSUVWWBx
^_cdi_j_s_s^ttuv
wwr1   c                 P    t        | t              rt        j                  |       S | S )zConvert string patterns to compiled regex, pass through other types.

    Note: re.compile() internally caches compiled patterns, so no additional
    caching is needed here.
    )rJ   r6   recompiler7   s    r/   _parse_converterrb      s"     %zz%  Lr1   _provided_argsc            	          e Zd ZU dZ ede      Zdez  ee   z  e	d<    edd      Z
edef   ez  dz  e	d<    ed	ed
      Zdedef   z  ez  eedef   ez     z  e	d<    eded
      Zdez  ee   z  e	d<    eded
      Zdez  ee   z  e	d<    ededd      Zdez  ez  eeez     z  e	d<    eded
      Zeej2                  z  dz  e	d<    eddd      Zedz  e	d<    edd      Zdez  ez  eegef   z  e	d<    eded
      Zee	d<    edd      Zedz  e	d<    eded
      Zee	d<    eded
      Z dez  ee   z  e	d<    ee!jD                  jF                  d      Z#edef   e	d<    ed e$d      e%d      Z&dez  ee   z  e	d<    ed e$d      e%d      Z'dez  ee   z  e	d<    ed e$d	      e%d      Z(dez  ee   z  e	d <    edd      Z)edz  e	d!<    edd      Z*ee	d"<    edd      Z+ee	d#<    ed$dd%      Z,eegef   dz  e	d&<    edd      Z-edz  e	d'<    ede.d
      Z/dez  e0z  e1e0   z  e2e0e0dz  f   z  e	d(<    edd      Z3edz  e	d)<    edd      Z4edz  e	d*<    ede5d
      Z6ee	d+<    ede7e8d      Z9eee:e;e   geee   z  dz  f   z  e	d,<    edd      Z<edz  e	d-<    edd      Z=e0dz  e	d.<    ee2dd/      Z>e2edf   e	d0<   e?d1edz  fd2       Z@e?d3        ZAd1e2edf   fd4ZBd5 ZCeDd>d7       ZEeDd1eFfd8       ZGeDd9ed:d6d1e2ed f   fd;       ZHd<eId1eIfd=ZJy)?	Parametera  Cyclopts configuration for individual function parameters with :obj:`~typing.Annotated`.

    Example usage:

    .. code-block:: python

        from cyclopts import app, Parameter
        from typing import Annotated

        app = App()


        @app.default
        def main(foo: Annotated[int, Parameter(name="bar")]):
            print(foo)


        app()

    .. code-block:: console

        $ my-script 100
        100

        $ my-script --bar 100
        100
    NrQ   nameT)rM   kw_only.rP   rB   )rM   rP   rg   	validatorr*   negativeF)rM   rP   rg   hashgroupparseshow)rM   r*   rg   _showshow_defaultshow_choiceshelpshow_env_varenv_varenv_var_split)zno-)rM   rP   rh   rg   negative_bool)zempty-negative_iterablenegative_nonerequiredallow_leading_hyphenrequires_equalsname_transform)r*   rM   rg   _name_transformaccepts_keysconsume_multiple	json_dict	json_listcountshort_aliasallow_repeatingn_tokens)factoryiniteqrc   r2   c                     | j                   | j                   S | j                  $t        | j                  t        j                        ry t        | j                        S r?   )rn   rl   rJ   r`   PatternrY   selfs    r/   rm   zParameter.showy  sC    ::!::::DJJ

!CDJJr1   c                 >    | j                   r| j                   S t        S r?   )r|   r    r   s    r/   r{   zParameter.name_transform  s    '+';';t##WAWWr1   c           	      2   | j                   r| j                  yt        |      }t        |      rYt	        |      }t        |d       }g }|D ].  }| j                  |      D ]  }||vs|j                  |        0 t        |      S t        |      }|t        vr|r	|t        vryyg g }}| j                  rB| j                  D ]&  }	|	j                  d      r|n|j                  |	       ( |st        |      S t        | j                  t              sJ | j                  D ]  }
|
j                  d      s|
dd  }
|
j                  d      }|t        u s|t         v r| j"                  }n&t%        |      s|| j&                  }n| j(                  }dj+                  |d d       }|r|dz  }t        |t              sJ | j                  &|D ]   }|s|j                  d| | |d           " |D ]  }	|j                  d| |	          t        |      S )	NrB   c                 $    t        |       xs | d u S r?   )r   )xs    r/   <lambda>z)Parameter.get_negatives.<locals>.<lambda>  s    ;q>;VQRVY;Vr1   )keyr'   z--rU   rT   )r   ri   r   r   r   sortedget_negativesappendr5   r   _NEGATIVE_FLAG_TYPESr(   rJ   rf   splitrY   ITERATIVE_BOOL_IMPLICIT_VALUEru   r   rw   rv   join)r   type_
union_argssorted_argsoutr   negoriginuser_negativesri   rf   name_componentsnegative_prefixesname_prefixnegative_prefixs                  r/   r   zParameter.get_negatives  s   ::$--/!%(E?!%J !1VWKC --a0C#~

3 1 ! :E",,!55 "^== MM ++C0nLLXV * "Sz!$))U+++IID??4(8D"jjoO})F F$($6$6!U#u}$($6$6!$($:$:!((?3B#78Ks"/777}}$'8O&

R}_4EoVXFYEZ#[\ (9 !/HJJK=
;< !/+ . Szr1   c                 
   dj                  | j                  D cg c]?  }|j                  | j                  v r%|j                   dt	        | |j
                        A c}      }t        |       j                   d| dS c c}w )zOnly shows non-default values.rV   =())r   __attrs_attrs__r*   rc   getattrrf   rZ   r[   )r   acontents      r/   __repr__zParameter.__repr__  s    )) ---A77d111 77)1WT166256-
 t*%%&ay22s   AB Parameter | Nonec                     i }|D cg c]  }||	 }}t        |      dk(  r|d   S |st        S |D ])  }|j                  D ]  }t        |t        |         ||<    +  | di |S c c}w )a)  Returns a new Parameter with combined values of all provided ``parameters``.

        Parameters
        ----------
        *parameters : Parameter | None
             Parameters who's attributes override ``self`` attributes.
             Ordered from least-to-highest attribute priority.
           r   rB   )rX   EMPTY_PARAMETERrc   r   _parameter_alias_to_name)cls
parameterskwargsr   filtered	parameterr*   s          r/   combinezParameter.combine  s     );z!Q]Az; x=AA;""!I"11 '	3KE3R Su 2 " }V} <s
   A&A&c           	           | di | j                   D ci c]&  }|j                  s|j                  |j                  ( c}S c c}w )zCreate a Parameter with all Cyclopts-default values.

        This is different than just :class:`Parameter` because the default
        values will be recorded and override all upstream parameter values.
        rB   )r   r   r*   rM   )r   r   s     r/   rM   zParameter.default  sF      
+.+>+>I+>a!&&qww		!+>I
 	
Is
   AAr   default_parametersc                     |t         j                  j                  u r|r| | j                  | fS |t        fS t        |      \  }}| | j                  g || fS )z1Resolve the immediate Parameter from a type hint.)inspectre   emptyr   r   get_parameters)r   r   r   r   s       r/   from_annotationzParameter.from_annotation  sk     G%%+++!kckk+=>>>o-- .u 5E:+#++G'9GJGGGr1   objc                     t        |d      st        |      |_        n3|j                  j                  |k7  rt	        |j                        |_        |j                  j
                  j                  |        |S )zDecorator interface for annotating a function/class with a :class:`Parameter`.

        Most commonly used for directly configuring a class:

        .. code-block:: python

            @Parameter(...)
            class Foo: ...
        __cyclopts__)r   )hasattrCycloptsConfigr   r   r   r   r   )r   r   s     r/   __call__zParameter.__call__  sa     sN+-#6C!!S('(8(89C##**40
r1   )r   r   r2   re   )Kr[   
__module____qualname____doc__r   r8   rf   r6   r   __annotations__rP   r   r   r:   rh   r*   r@   ri   r=   rk   r   rb   rl   rY   r`   r   rn   ro   rC   rp   rq   rr   rs   cyclopts_env_varrt   rR   r0   ru   rv   rw   rx   ry   rz   r|   r}   r^   r~   rW   r   r5   r   r   rF   r   rH   rL   r   r   	frozensetr   r   rc   propertyrm   r{   r   r   classmethodr   r   rM   r   r%   r   rB   r1   r/   re   re      so   @ (-&(D$*x}
$  272IxS!C'$.  W\,WIthsCx((3.(38:Ls:R1SS  ).&)E4#:%  ,1/,HdSj8C=(  9>(	9E4%<# 55  ',"'E4"**t#  E4$;  >C>L$+#hucz&:: 
 'L$  T48D#*8'L$  +0&+GTCZ(3-'  ).!!//)M8CH%  16%h/'	1M4#:-  5:%k2'	5tczHSM1  16%b)'	1M4#:-  "HdTk 
 "'"$ 
 "OT 
 494OXseSj)D0  !&!L$+ 
 TY-TdTkC'(3-7%S4Z:PP  #4>Itd{>"4>Itd{>(E4  ]b((	]K)Ys^!<cHSM>QTX>X!XYY  $)$OTD[ 
 !HcDj  ',E%&PNE#s(OP dTk     X X;eCHo ;z	3  0 
 
 
 	HC 	H>P 	HUZ[^`k[kUl 	H 	HA ! r1   re   fc                 <   | j                   xs dj                  d      ryt        |       j                         D ]  }t	        |j
                        }|st        |j
                  dd      s3t        j                  |j
                        \  }}|j                  ot        |j                  t        j                        sK|j                  s?|j                  |j                  u }|j                  |j                   u}|s|st#        d      d|j$                  v s|j                  |j                   u s|j
                  }t'        |      }t)        |      }t+        d |j                         D              }	|	s>|j,                  r|j,                  d   nd}
|
rd	|
 d
nd}t#        d| d|  d|
 d|j
                  j.                   d|j
                  j.                   d|
 d|j
                  j.                   d|
 d|
 d|
 d|j
                  j.                   d       y)zValidate if a function abides by Cyclopts's rules.

    Raises
    ------
    ValueError
        Function has naming or parameter/signature inconsistencies.
     r   Nr   zuParameter.parse=False must be used with either a KEYWORD_ONLY function parameter or a parameter with a default value.*c              3   6   K   | ]  }|j                      y wr?   )rx   ).0
field_infos     r/   	<genexpr>z#validate_command.<locals>.<genexpr>@  s     %kPj***=*=&=Pjs   r   "z" z
Parameter zin function z has all optional values, uses Parameter(name="*"), but itself has no default value. Consider either:
    1) If immutable, providing a default value "z: z = z2()"
    2) Otherwise, declaring it optional like "z# | None = None" and instanting the z, object in the function body:
           if z is None:
               z())r   r(   r   r-   r   
annotationr   re   r   rl   rJ   r`   r   kindKEYWORD_ONLYrM   r   r)   rf   r   r   allnamesr[   )r   r   field_info_is_annotated_cparamis_keyword_onlyhas_default	annotatedclass_field_infosall_fields_optional
param_namequoted_param_names               r/   validate_commandr     sA    	
&&z2*1-446
".z/D/D"E&wz7L7Ln^b/c --j.C.CD	6<<#Jv||RZZ,PY_YeYe(oo1H1HHO$,,J4D4DDK#{ ;  6;;""j&6&66 #--I	*I /	 :"%%kPaPhPhPj%k"k"4>4D4DZ--a0"
:Da
|2$6"!  !2 3<s CGGQlRTU_UjUjUsUsTttw  yC  yN  yN  yW  yW  xX XEEOLPRS]ShShSqSqRr  sV  Wa  Vb b%%/L 1&&0\Z5J5J5S5S4TTVX E 7r1   hintskip_converter_paramsc                 ~   g }	 | }t        t        t        |             } t        |       } t	        |       r8t        |       }|d   } |dd D cg c]  }t        |t              s| c}|dd j| |k(  rnpg }t        | dd      x}r|j                  |j                         g }|s	||z   D ]   }	|	j                  s|	j                  }
t        |
t              rt        | |
      }
t        |
d      r'|j                  |
j                  j                          nt        |
d      syt        |
d      st        |
j                  d      s|
j                  j                   j#                  |
j$                        }|st        |d      s|j                  |j                  j                          n ||z   |z   }| |fS c c}w )a  At root level, checks for cyclopts.Parameter annotations.

    Includes checking the ``__cyclopts__`` attribute on both the type and any converter functions.

    Parameters
    ----------
    hint
        Type hint to extract parameters from.
    skip_converter_params
        If True, skip extracting parameters from converter's __cyclopts__.
        Used to prevent infinite recursion in token_count.

    Returns
    -------
    hint
        Annotation hint with :obj:`Annotated`, :obj:`Optional`, and :obj:`NewType` resolved.
    list[Parameter]
        List of parameters discovered, ordered by priority (lowest to highest):
        converter-decoration < type-decoration < annotation.
    r   r   Nr   __self__r[   __dict__)r   r%   r   r   r   r   rJ   re   r   extendr   rP   r6   r   r   r   r   getr[   )r   r   annotated_params	hint_previnnerr   type_cyclopts_config_paramscyclopts_configconverter_paramsparamrP   
descriptorr   s                r/   r   r   O  s   6 
	A'-.%TNE8D/4QRy#Uy!Jq)<TAy#URa 9  #%!$===#**?+E+EF  %(CCE!OO	 i- 'i 8I 9n5$++I,B,B,M,MN Iz2	:6	 2 2J? "+!3!3!<!<!@!@ASAS!TJ!gj.&I(//
0G0G0R0RS- D4 "$??BRRJS $Vs   F:"F:c                   D    e Zd ZU dZdZeed<    eed      Z	ee
   ed<   y)r   z^
    Intended for storing additional data to a ``__cyclopts__`` attribute via decoration.
    Nr   F)r   r   r   )r[   r   r   r   r   r   r   r   listr   re   rB   r1   r/   r   r     s'     CO"'5"AJYAr1   r   )F)Qcollections.abccollectionsr   r`   sysr   r   r   copyr   typingr   r   r	   r
   r   r   r   attrsr   r   version_infor   typing_extensionscyclopts._env_varr   cyclopts.annotationsr   r   r   r   r   r   r   r   r   cyclopts.field_infor   r   r   cyclopts.groupr   cyclopts.utilsr    r!   r"   r#   r$   r   rY   abcr   r5   r   r%   r   r0   r6   r8   r:   r=   r@   rC   rF   rH   rL   rR   rW   r^   r   rb   re   r   r   r*   rf   r   r   r   r   r   )ps   0r/   <module>r     s     	 
 8 8     w& 
 
 
 Q P    !*  &T
T
dCidCi
!  CL $h!h!hJg!hi R<hsm 3d : <uS#X <QCH#hxS/AC/G&HH4OQ
8CH#S()QF"N FSXYkSl F.hsm)Cd)J .uUXZ]U]aeOe .0 0 01$+ 1$ 1-(Iy~6hsm8Kd8RRSSVZZ-	Hi30#2E2LLMM-
sCx #x#:%c3:o(>>E#x
3d
?d"#xLD2::c?2S84? D2::VY?DZ]aDa  _ _  _H &&&vv GGQVVO&  +3 3lM M4 ME!TR[_J\D] M` B B Bas   .*J