
    KiwR                        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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" d d	l#m$Z$m%Z% d d
l&m'Z' d dl(m)Z)m*Z*m+Z+m,Z,m-Z-  e.ee/   ee/   ej`                  j                  e/   e1e/   ee/   e2e/df   ee/df   h      Z3 ed      Z4 e.e/degee3      Z5d Z6de2e7df   fdZ8de2e9e9dz  f   dz  fdZ:d Z; e,d      e* G d d                    Z<e<jz                  D  ci c]%  } | j|                  r| j~                  | j                  ' c} ZA e<       ZBdefdZCdde4de/de2e4e1e<   f   fdZDe G d d             ZEy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_optional)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       ^/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/cyclopts/parameter.py_not_hyphen_validatorr.   @   s>     R!1!1#!6	00OPQQR    defaultc                 2     dt         t        df   f fd}|S )Nreturn.c                 "    | S t        |       S N)r"   )r,   r0   s    r-   	converterz&_negative_converter.<locals>.converterG   s    =N%e,,r/   )tuplestrr0   r5   s   ` r-   _negative_converterr9   F   s    -E#s(O - r/   r2   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 )	
isinstanceintr'   r   lenbool	TypeErrortype__name__)r,   mnmxs      r-   _consume_multiple_converterrG   P   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wr/   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.
    )r>   r7   recompile)r,   s    r-   _parse_converterrK   t   s"     %zz%  Lr/   _provided_argsc            	          e Zd ZU dZ edd       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
d d      Zde
eegef   z  ee
eegef      z  ed<    edd 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j.                  z  dz  ed<    eddd      Zedz  ed<    edd      Zdez  e
egef   z  ed<    edej6                  j9                  d      d      Zeed<    edd      Zedz  ed<    edej6                  j9                  d      d      Zeed<    edd d      Z dez  ee   z  ed<    ee!jD                  jF                  d      Z#e
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ej6                  j9                  d      d      Z5eed/<    edd      Z6edz  ed0<    edd      Z7e0dz  ed1<    ee2dd2      Z8e2edf   ed3<   e9d4edz  fd5       Z:e9d6        Z;d4e2edf   fd7Z<d8 Z=e>dAd:       Z?e>d4e@fd;       ZAe>d<ed=d9d4e2ed f   fd>       ZBd?eCd4eCfd@ZDy)B	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
    Nc                 F    t        t        t        df   t        |             S N.r   r6   r7   r"   xs    r-   <lambda>zParameter.<lambda>       DsCx2DQ2GH r/   r8   nameT)r0   kw_only.r5    c                 l    t        t        t        t        t        gt        f   df   t	        |             S rP   )r   r6   r   r   r"   rR   s    r-   rT   zParameter.<lambda>   s+    Dxc
C'@#'E!FHZ[\H]^ r/   )r0   r5   rW   	validatorc                 F    t        t        t        df   t        |             S rP   rQ   rR   s    r-   rT   zParameter.<lambda>   rU   r/   r(   negativeF)r0   r5   rW   hashgroupparseshow)r0   r(   rW   _showshow_defaultshow_choiceshelpshow_env_varc                 F    t        t        t        df   t        |             S rP   rQ   rR   s    r-   rT   zParameter.<lambda>   rU   r/   env_varenv_var_split)zno-)r0   r5   rZ   rW   negative_bool)zempty-negative_iterablenegative_nonerequiredallow_leading_hyphenrequires_equalsname_transform)r(   r0   rW   _name_transformaccepts_keysconsume_multiple	json_dict	json_listcountallow_repeatingn_tokens)factoryiniteqrL   r2   c                     | j                   | j                   S | j                  $t        | j                  t        j                        ry t        | j                        S r4   )ra   r_   r>   rI   PatternrA   selfs    r-   r`   zParameter.showD  sC    ::!::::DJJ

!CDJJr/   c                 >    | j                   r| j                   S t        S r4   )rp   r   r}   s    r-   ro   zParameter.name_transformL  s    '+';';t##WAWWr/   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 )	NrX   c                 $    t        |       xs | d u S r4   )r   rR   s    r-   rT   z)Parameter.get_negatives.<locals>.<lambda>Z  s    KN<WaSWi r/   )keyr%   z--r<   r;   )ru   r\   r   r   r   sortedget_negativesappendr6   r   _NEGATIVE_FLAG_TYPESr&   r>   rV   splitrA   ITERATIVE_BOOL_IMPLICIT_VALUEri   r   rk   rj   join)r~   type_
union_argssorted_argsoutrS   negoriginuser_negativesr\   rV   name_componentsnegative_prefixesname_prefixnegative_prefixs                  r-   r   zParameter.get_negativesP  s5   ::$--/!%(E?!%J !1XYKC  (--a0 (C#~

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

R}_4EoVXFYEZ#[\] !/ =HJJK=
;<=+	=. Szr/   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.r=   =())r   __attrs_attrs__r(   rL   getattrrV   rC   rD   )r~   acontents      r-   __repr__zParameter.__repr__  s    )) --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   rX   )r@   EMPTY_PARAMETERrL   r   _parameter_alias_to_name)cls
parameterskwargsrS   filtered	parameterr(   s          r-   combinezParameter.combine  s     );!Q]A;; x=AA;""! 	TI"11 T '	3KE3R SuT	T }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.
        rX   )r   ry   r(   r0   )r   r   s     r-   r0   zParameter.default  s@      
+.+>+>Ia!&&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.)inspectrN   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Gr/   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
r/   )r   r   r2   rN   )ErD   
__module____qualname____doc__r   rV   r7   r   __annotations__r5   r   r   rZ   r(   r    r\   r"   r^   r   rK   r_   rA   rI   r|   ra   rb   attrs
convertersdefault_if_nonerc   rd   re   rg   cyclopts_env_varrh   r9   r.   ri   rj   rk   rl   rm   rn   rp   rq   rG   rr   r?   r   r6   rs   rt   ru   rv   rw   rL   propertyr`   ro   r   r   classmethodr   r   r0   r   r#   r   rX   r/   r-   rN   rN      sI   @ (-H(D$*x}
$  272IxS!C'$.  Y^^YIthSz3//(8S#JPSO;T2UU  ).H)E4#:%  ,1-,HdSj8C=(  9>$	9E4%<# 55  ',"'E4"**t#  E4$;  8=8L$+# 44 
 ""2248L$  T48D#*8""2248L$  +0H+GTCZ(3-'  $!!//M8  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{>""2259E4  $)$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 ! r/   rN   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r4   )rl   ).0
field_infos     r-   	<genexpr>z#validate_command.<locals>.<genexpr>  s     %k***=*=&=%ks   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   rN   r   r_   r>   rI   r|   kindKEYWORD_ONLYr0   r   r'   rV   r   r   allnamesrD   )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     sF    	
&&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)r/   hintskip_converter_paramsc                 *   t        |       } g }t        |       r6t        |       }|d   } |j                  d |dd D               t        |       } g }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 )	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` and :obj:`Optional` resolved.
    list[Parameter]
        List of parameters discovered, ordered by priority (lowest to highest):
        converter-decoration < type-decoration < annotation.
    r   c              3   B   K   | ]  }t        |t              s|  y wr4   )r>   rN   )r   rS   s     r-   r   z!get_parameters.<locals>.<genexpr>6  s     Qa
1i8PQs   r   Nr   __self__rD   __dict__)r   r   r   extendr   r   r5   r>   r7   r   r   r   r   getrD   )r   r   annotated_paramsinnertype_cyclopts_config_paramscyclopts_configconverter_paramsparamr5   
descriptorr   s              r-   r   r     s   * D!D DQxQ59QQ% #%!$===#**?+E+EF  %(CC 	E!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-	4 "$??BRRJr/   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)rx   ry   r   )rD   r   r   r   r   r   r   r   listr   rN   rX   r/   r-   r   r   a  s'     CO"'5"AJYAr/   r   )F)Fcollections.abccollectionsr   rI   sysr   r   r   copyr   typingr   r   r	   r
   r   r   r   r   r   r   version_infor   typing_extensionscyclopts._env_varr   cyclopts.annotationsr   r   r   r   r   r   r   r   cyclopts.field_infor   r   cyclopts.groupr   cyclopts.utilsr   r   r    r!   r"   	frozensetrA   abcr   r6   r   r#   r   r.   r7   r9   r?   rG   rK   rN   r   ry   r(   rV   r   r   r   r   r   )ps   0r-   <module>r      s     	 
 8 8     w& 	 	 	 F    !*  &T
T
dCidCi
!  CL $h!h!hJg!hi RsCx !x%S4Z*@4*G !xH W W  Wx
 &&	vv GGQVVO  +3 3lD D4 DE!TR[_J\D] DN B B BOs   ,*F	