
    !<iG                        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 d d	l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j0        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Z8 e,d          e* G d d                                  Z9d e9j:        D             Z; e9            Z<defdZ=dde4de/de2e4e1e9         f         fdZ>e G d d                      Z?dS )     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                 l    |D ]0}|,|                     d          rt          |j         d          1d S )N-z value must NOT start with "-".)
startswith
ValueErroralias)instance	attributevaluesvalues       /Users/kimhansen/Desktop/03 Workspace/ceo-agents/chl-effectiveness/mcp-servers/whoop/.venv/lib/python3.11/site-packages/cyclopts/parameter.py_not_hyphen_validatorr.   ?   sR     R R!1!1#!6!6	PPPQQQR R    defaultc                 <     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>.converterF   s    =N%e,,,r/   )tuplestrr0   r5   s   ` r-   _negative_converterr9   E   s8    -E#s(O - - - - - - r/   _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j                            d          d          Ze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j                            d          d          Zeed<    edd          Zedz  ed<    edej                            d          d          Zeed<    edd d          Zdez  ee         z  ed<    eej        j         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d(          Z(e
egef         dz  ed)<    edd          Z)edz  ed*<    edej                            d          d          Z*eed+<    edd          Z+edz  ed,<    edd          Z,edz  ed-<    edej                            d          d          Z-eed.<    edd          Z.e/dz  ed/<    ee0dd0          Z1e0edf         ed1<   e2d2efd3            Z3e2d4             Z4d2e0edf         fd5Z5d6 Z6e7d@d9            Z8e7d2e9fd:            Z:e7d;ed<d8d2e0ed f         fd=            Z;d>e<d2e<fd?Z=dS )A	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                 `    t          t          t          df         t          |                     S N.r   r6   r7   r"   xs    r-   <lambda>zParameter.<lambda>t   !    DsCx2DQ2G2GHH r/   r8   nameT)r0   kw_only.r5    c                     t          t          t          t          t          gt          f         df         t	          |                     S r>   )r   r6   r   r   r"   r@   s    r-   rB   zParameter.<lambda>   s1    Dxc
C'@#'E!FHZ[\H]H]^^ r/   )r0   r5   rE   	validatorc                 `    t          t          t          df         t          |                     S r>   r?   r@   s    r-   rB   zParameter.<lambda>   rC   r/   r(   negativeF)r0   r5   rE   hashgroupparseshow)r0   r(   rE   _showshow_defaultshow_choiceshelpshow_env_varc                 `    t          t          t          df         t          |                     S r>   r?   r@   s    r-   rB   zParameter.<lambda>   rC   r/   env_varenv_var_split)zno-)r0   r5   rH   rE   negative_bool)zempty-negative_iterablenegative_nonerequiredallow_leading_hyphenname_transform)r(   r0   rE   _name_transformaccepts_keysconsume_multiple	json_dict	json_listcountn_tokens)factoryiniteqr:   r2   c                 ,    | j         | j         n| j        S r4   )rO   rM   selfs    r-   rN   zParameter.show
  s    !Z3tzzCr/   c                 ,    | j         r| j         nt          S r4   )r]   r   rh   s    r-   r\   zParameter.name_transform  s    '+';Wt##AWWr/   c           	         | j         r	| j        dS t          |          }t          |          rht	          |          }t          |d           }g }|D ]3}|                     |          D ]}||vr|                    |           4t          |          S t          |          }|t          vr|r|t          vrdS ndS g g }}| j        rG| j        D ].}	|	                    d          r|n|                    |	           /|st          |          S t          | j        t                    sJ | j        D ]}
|
                    d          s|
dd          }
|
                    d          }|t          u s	|t           v r| j        }n t%          |          s|| j        }n| j        }d                    |d d                   }|r|dz  }t          |t                    sJ | j        *|D ]&}|r"|                    d| | |d                     '|D ]}	|                    d| |	            t          |          S )	NrF   c                 (    t          |           p| d u S r4   )r   r@   s    r-   rB   z)Parameter.get_negatives.<locals>.<lambda>  s    KNN<WaSWi r/   )keyr%   z--   .)rb   rJ   r   r   r   sortedget_negativesappendr6   r   _NEGATIVE_FLAG_TYPESr&   
isinstancerD   splitboolITERATIVE_BOOL_IMPLICIT_VALUErW   r   rY   rX   join)ri   type_
union_argssorted_argsoutrA   negoriginuser_negativesrJ   rD   name_componentsnegative_prefixesname_prefixnegative_prefixs                  r-   rr   zParameter.get_negatives  s   : 	$-/2!%((E?? 	!%J !1X1XYYYKC  ( (--a00 ( (C#~~

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

#[#[_#[oVXFY#[#[\\\] !/ = =HJJ;K;;;<<<<=Szzr/   c                      d                      fd j        D                       }t                     j         d| dS )zOnly shows non-default values.z, c                 j    g | ]/}|j         j        v |j          d t          |j                  0S )=)r(   r:   getattrrD   ).0ari   s     r-   
<listcomp>z&Parameter.__repr__.<locals>.<listcomp>R  sO       7d111 766WT162266111r/   ())ry   __attrs_attrs__type__name__)ri   contents   ` r-   __repr__zParameter.__repr__O  sa    ))   -  
 
 t**%222222r/   
parametersParameter | Nonec                     i }d |D             }t          |          dk    r|d         S |st          S |D ]*}|j        D ] }t          |t          |                   ||<   !+ | di |S )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.
        c                     g | ]}||S r4   rF   r   rA   s     r-   r   z%Parameter.combine.<locals>.<listcomp>e  s    ;;;!Q]A]]]r/      r   rF   )lenEMPTY_PARAMETERr:   r   _parameter_alias_to_name)clsr   kwargsfiltered	parameterr(   s         r-   combinezParameter.combineZ  s     ;;z;;; x==AA; 	#""! 	T 	TI"1 T T '	3KE3R S SuT s}}V}}r/   c                 0     | di d | j         D             S )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.
        c                 6    i | ]}|j         	|j        |j        S rF   )re   r(   r0   )r   r   s     r-   
<dictcomp>z%Parameter.default.<locals>.<dictcomp>{  s%    IIIa!&Iqw	IIIr/   rF   )r   )r   s    r-   r0   zParameter.defaults  s6     s 
 
II3+>III
 
 	
r/   rz   default_parametersc                     |t           j        j        u r|r| | j        | fS |t          fS t          |          \  }}| | j        g ||R  fS )z1Resolve the immediate Parameter from a type hint.)inspectr<   emptyr   r   get_parameters)r   rz   r   r   s       r-   from_annotationzParameter.from_annotation~  sr     G%+++! .kck+=>>>o-- .u 5 5E:+#+G'9GJGGGGGr/   objc                     t          |d          st          |          |_        n)|j        j        |k    rt	          |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   rs   )ri   r   s     r-   __call__zParameter.__call__  so     sN++ 	:-#666C!S(('(899C#**4000
r/   )r   r   r2   r<   )>r   
__module____qualname____doc__r   rD   r7   r   __annotations__r5   r   r   rH   r(   r    rJ   r"   rL   r   attrs
convertersdefault_if_nonerM   rw   rO   rP   rQ   rR   rS   rU   cyclopts_env_varrV   r9   r.   rW   rX   rY   rZ   r[   r]   r^   r_   r`   ra   rb   rc   intr6   r:   propertyrN   r\   rr   r   classmethodr   r   r0   r   r#   r   rF   r/   r-   r<   r<   O   s         @ (-uHH( ( (D$*x}
$    272 2 2IxS!C'$.    Y^X]^^Y Y YIthSz3//(8S#JPSO;T2UU    ).HH) ) )E4#:%    ,15-, , ,HdSj8C=(    9>$	9 9 9E4%<# 55    %"22488  E4      E4$;    8=u8 8 8L$+# 44   
 "22488  L$    uT4888D#*888"22488  L$    +0%HH+ + +GTCZ(3-'    $e!/  M8    16%%h//'	1 1 1M4#:-    5:E%%k22'	5 5 5tczHSM1    16%%b))'	1 1 1M4#:-    "E  HdTk   
 "'" " "$   
 4954 4 4OXseSj)D0    !&! ! !L$+   
 #U"22599  d    #U4>>>Itd{>>>"U4>>>Itd{>>>%"22599  E4    !5  HcDj    ',eE%&P&P&PNE#s(OPPPDd D D D XD X X XX;eCHo ; ; ; ;z	3 	3 	3    [0 
 
 
 
 [
 	HC 	H>P 	HUZ[^`k[kUl 	H 	H 	H [	HA !      r/   r<   c                 6    i | ]}|j         	|j        |j        S rF   )re   r(   rD   )r   ps     r-   r   r     s6       	vGQV  r/   fc                 8   | j         pd                    d          rdS t          |                                           D ]X}t	          |j                  }|st          |j        dd          s0t                              |j                  \  }}|j	        s|j
        |j        urt          d          d|j        v r|j        |j        u r|j        }t!          |          }t#          |          }t%          d |                                D                       }|ry|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          ZdS )zValidate if a function abides by Cyclopts's rules.

    Raises
    ------
    ValueError
        Function has naming or parameter/signature inconsistencies.
     r   Nr   zJParameter.parse=False must be used with a KEYWORD_ONLY function parameter.*c              3   &   K   | ]}|j          V  d S r4   )rZ   )r   
field_infos     r-   	<genexpr>z#validate_command.<locals>.<genexpr>  s(      %k%k***=&=%k%k%k%k%k%kr/   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   r<   r   rM   kindKEYWORD_ONLYr'   rD   r0   r   r   r   allnamesr   )
r   r   field_info_is_annotated_cparam	annotatedclass_field_infosall_fields_optional
param_namequoted_param_names
             r-   validate_commandr     sr    	
&&z22 *1--4466 # #
".z/D"E"E& 	wz7Ln^b/c/c 	 --j.CDD	6| 	k
z7N N Nijjj
 6;"j&666 #-I	**I /	 : :"%%k%kPaPhPhPjPj%k%k%k"k"k" 
4>4DLZ-a00"
:D$L$6
$6$6$6$6"! X!2 X X X XGQX XU_UjUsX X yC  yN  yWX X FPX X T^ShSqX X WaX X &0	X X
 '1X X
 6@5J5SX X X  9# #r/   Fhintskip_converter_paramsr2   c                 ,   t          |           } g }t          | dd          x}r|                    |j                   g }t	          |           r>t          |           }|d         } |                    d |dd         D                        g }|s||z   D ]}|j        r|j        }t          |t                    rt          | |          }t          |d          r!|                    |j
        j                    nt          |d          r|t          |d          rlt          |j        d          rW|j        j                            |j                  }	|	r1t          |	d          r!|                    |	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   Nr   c              3   D   K   | ]}t          |t                    |V  d S r4   )ru   r<   r   s     r-   r   z!get_parameters.<locals>.<genexpr>  s1      QQa
1i8P8PQQQQQQQr/   r   __self__r   __dict__)r   r   extendr   r   r   r5   ru   r7   r   r   r   r   getr   )r   r   type_cyclopts_config_paramscyclopts_configannotated_paramsinnerconverter_paramsparamr5   
descriptorr   s              r-   r   r     s   * D!!D #%!$=== G#**?+EFFF D RQxQQ59QQQQQQ   %(CC 	 	E !O	 i-- 9 'i 8 8I 9n55 $++I,B,MNNNE Iz22		:66	  	 2J??	 "+!3!<!@!@AS!T!TJ! gj.&I&I (//
0G0RSSS "$??BRRJr/   c                   R    e Zd ZU dZdZeed<    eed          Z	ee
         ed<   dS )r   z^
    Intended for storing additional data to a ``__cyclopts__`` attribute via decoration.
    Nr   F)rd   re   r   )r   r   r   r   r   r   r   r   listr   r<   rF   r/   r-   r   r     sN           COOO"'%5"A"A"AJYAAAAAr/   r   )F)@collections.abccollectionsr   sysr   r   r   copyr   typingr   r   r	   r
   r   r   r   r   r   r   version_infor   typing_extensionscyclopts._env_varr   cyclopts._convertr   cyclopts.annotationsr   r   r   r   r   r   r   cyclopts.field_infor   r   cyclopts.groupr   cyclopts.utilsr   r   r    r!   r"   	frozensetrw   abcr   r6   rx   r#   rt   r.   r7   r9   r<   r   r   r   r   r   r   rF   r/   r-   <module>r      s        



 8 8 8 8 8 8 8 8 8 8                                w&&&&&&     , , , , , ,                  F E E E E E E E                          !*	 &T
T
dCidCi
! 
!  GCLL y$h!h!hJg!hii R R RsCx     I I I I I I I  IX
 &    )++- - - - -`B B B4 BE!TR[_J\D] B B B BJ B B B B B B B B B Br/   