
    Ki"                     f   d 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 ddlmZmZmZmZmZmZmZ erddlmZ  ed	e	
      Zddl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$ ddl%m&Z& ejN                  dk\  rddlm(Z( ndZ( e&ddddddd      Z)i e!e!fe!e!e fe e!efee!e#fe#e!e"fe"e e!fe e e fe e efde e#fe#e e"fdee!feee fdeefeee#fdee"fe"e#e!fe e#e fe e#efde#e#fe#e#e"fde"e!fee"e fde"efee"e#fde"e"fe"iZ*de+dee,ge,f   de-e,   fdZ.d Z/deege0e,e$f   f   dede0e,ef   ge-e,   f   fdZ1d Z2de+e   de0e,e3f   dee,ge,f   defdZ4dede0e5e,df   e&f   fd Z6d! Z7d"e5e,df   de5e,df   fd#Z8	 d(d$e5e,df   dz  dee5e5e,df   ef      fd%Z9d&e,de,fd'Z:y))z?Shared helper functions and constants for the argument package.    N)CallableIterator)suppress)EnumFlag)partial)TYPE_CHECKING	AnnotatedAnyLiteralTypeVarget_args
get_origin)ArgumentF)bound)convert_enum_flag)ITERABLE_TYPESis_class_and_subclassis_unionresolve_annotated)KEYWORD_ONLYPOSITIONAL_ONLYPOSITIONAL_OR_KEYWORDVAR_KEYWORDVAR_POSITIONAL	FieldInfo)	Parameter)      )TypeAliasType)namealias	converter	validatoraccepts_keysconsume_multipleenv_vartype_name_transformreturnc                 :   t        t              }g }t        |       }t        | t              r6t        | t              r&|j                  fd| j                  D               |S t        |      r;t        |       D cg c]
  } ||       }}|D ]  }|s|j                  |        |S |t        u r#|j                  d t        |       D               |S |t        v rVt        |       }t        |      dk(  s!|t        u r3t        |      dk(  r%|d   t        u r|j                   ||d                |S |t         u r"|j                   |t#        |                    |S t$        1t        | t$              r!|j                   || j&                               |S c c}w )a  Extract completion choices from a type hint.

    Recursively extracts choices from Literal types, Enum types, and Union types.

    Parameters
    ----------
    type_ : type
        Type annotation to extract choices from.
    name_transform : Callable[[str], str]
        Function to transform choice names (e.g., for case conversion).

    Returns
    -------
    list[str]
        List of choice strings extracted from the type hint.
    )r*   c              3   .   K   | ]  } |        y wN ).0xr*   s     c/home/jay/workspace/scripts/.codegraph-venv/lib/python3.12/site-packages/cyclopts/argument/utils.py	<genexpr>z(get_choices_from_hint.<locals>.<genexpr>a   s     DQ~a(Ds   c              3   2   K   | ]  }t        |        y wr.   )strr0   r1   s     r2   r3   z(get_choices_from_hint.<locals>.<genexpr>h   s     7!s1v7s         r   )r   get_choices_from_hintr   
isinstancetyper   r   extend__members__r   r   r   r   lentupleEllipsisr
   r   r!   	__value__)	r)   r*   get_choiceschoices_origininnerinner_choicesr1   argss	    `       r2   r9   r9   L   sv   " /OKGG%#8#ED%2C2CDD  N 
'	9A%IU+II 	"Aq!	" N 
G	7x77 N 
N	"t9>g.3t9>d1gQYFYNN;tAw/0
 N	 
I	{#4U#;<= N 
	"z%'G{5??34N Js   >Fc                 B    d } ||       j                   ||            S )Nc                 &    | j                  dd      S )N_-)replace)ss    r2   	normalizezstartswith.<locals>.normalizeu   s    yyc""    )
startswith)stringprefixrN   s      r2   rP   rP   t   s$    # V''	&(9::rO   get_field_infor   c                 X     dddt         t        t        f   dt        t           f fd}|S )Nargumentr   datar+   c                     t        |      } | j                        }|j                         D cg c]  \  }}|j                  s||vs| c}}S c c}}w r.   )sethintitemsrequired)rU   rV   provided_keys
field_infokvrS   s         r2   rE   z#missing_keys_factory.<locals>.inner~   sH    D	#HMM2
(..0\daQZZA]DZ\\\s   AAA)dictr5   r   list)rS   rE   s   ` r2   missing_keys_factoryrb   {   s4    ]
 ]$sCx. ]T#Y ]
 LrO   c                 d    t        |       dd  D ]  }	 |j                  c S  y # t        $ r Y w xY w)Nr7   )r   discriminatorAttributeError)
annotationmetas     r2   get_annotated_discriminatorrh      sG    $QR( 	%%%
   		s   #	//	enum_typerV   c                 F    t        | d |j                         D        |      S )a5  Convert a dictionary of boolean flags to a Flag enum value.

    Parameters
    ----------
    enum_type : type[F]
        The Flag enum type to convert to.
    data : dict[str, bool]
        Dictionary mapping flag names to boolean values.

    Returns
    -------
    F
        The combined flag value.
    c              3   ,   K   | ]  \  }}|s	|  y wr.   r/   )r0   r^   r_   s      r2   r3   z&enum_flag_from_dict.<locals>.<genexpr>   s     (Itq!q(Is   
)r   rZ   )ri   rV   r*   s      r2   enum_flag_from_dictrl      s    & Y(Itzz|(I>ZZrO   f.c           	      j   ddl m} t        t              5  | j                  } d d d        i }t        | dd       x}rjt        |d d       D ]W  }	  ||      }|j                  D ]=  }t        |j                        |t        |j                  j                  d            <   ? Y |S 	  ||       }|j                  D ]=  }t        |j                        |t        |j                  j                  d            <   ? 	 |S # 1 sw Y   xY w# t        t        f$ r Y w xY w# t        t        f$ r Y |S w xY w)Nr   )parse_from_object__mro__)help.)docstring_parserro   r   re   funcgetattrreversedparamsr   descriptionr?   arg_namesplit	TypeError)rm   ro   resultmro
base_classparseddparams          r2   extract_docstring_helpr      sB   2	.	! FF F aD))s) #3s8, 	J*:6$mm cF@IvOaOa@bF5!6!6s!;<=c	$ M	&q)F -- _<E6K]K]<^uV__223789_ ME * ~.  >* 	M		s1   C>AD
'AD >D
DDD21D2c                     | j                  d      r| d d j                  d      } | r| j                  d      sd| z   } | S )N*rq   rs   rK   --)endswithrstriprP   )elems    r2   resolve_parameter_name_helperr      s@    }}SCRy$DOOC(d{KrO   argssc                  t   t        d | D              } t        |       dk(  ryt        |       dk(  rt        d | d   D              S g }| d   D ]S  }t        |      }| d   D ]>  }|j                  d      s|s|j	                  |       (|j	                  |dz   |z          @ U t        t        |      g| dd	  S )
a  Resolve parameter names by combining and formatting multiple tuples of strings.

    Parameters
    ----------
    *argss
        Each tuple represents a group of parameter name components.

    Returns
    -------
    tuple[str, ...]
        A tuple of resolved parameter names.
    c              3   &   K   | ]	  }|s|  y wr.   r/   r6   s     r2   r3   z)resolve_parameter_name.<locals>.<genexpr>   s     (a!(s   r   r/   r7   c              3   @   K   | ]  }|d k(  rd n
t        |        yw)r   N)r   r6   s     r2   r3   z)resolve_parameter_name.<locals>.<genexpr>   s!     ]qAHS*G*JJ]s   rK   rs   r8   N)r?   r>   r   rP   appendresolve_parameter_name)r   outa1a2s       r2   r   r      s     (U((E
5zQ	Uq]TYZ[T\]]]
CAh **2.( 	*B}}S!

2

28b=)		** "%*9uQRy99rO   parent_keysc              #      K   |d}t        | t              rJ| j                         D ]6  \  }}||fz   }t        |t              rt        ||      E d {    1||f 8 y d| f y 7 w)Nr/   )r:   r`   rZ   walk_leaves)dr   keyvaluecurrent_keyss        r2   r   r      sw      !T'') 	*JC&#/L%&&ul;;;"E))	* !e	 <s   AA*A(A*keysc                  *    ddj                  |       z   S )Nr   rs   )join)r   s    r2   to_cli_option_namer     s    #((4.  rO   r.   );__doc__syscollections.abcr   r   
contextlibr   enumr   r   	functoolsr   typingr	   r
   r   r   r   r   r   cyclopts.argument._argumentr   r   cyclopts._convertr   cyclopts.annotationsr   r   r   r   cyclopts.field_infor   r   r   r   r   r   cyclopts.parameterr   version_infor!   PARAMETER_SUBKEY_BLOCKERKIND_PARENT_CHILD_REASSIGNMENTr;   r5   ra   r9   rP   r`   rb   rh   boolrl   r?   r   r   r   r   r   r/   rO   r2   <module>r      si   E 
 .    X X X4Ct /   )w$M$	
 "124I"O,o" L)<" N+^	"
 K(+" +,o" o&" l#T" n%~" k"D" ()<" ?#T" < ," >"D" ;"  *+_!"" _%#"$ \"D^$n[!4'(,/"D,.!4+3" :% %xs
7K %PTUXPY %P;cUDi$889z4S>*DI56[Aw[
sDy/[ cUCZ([ 	[,%h %4c3h0J+K %P:5c? :uS#X :D +/sCx4' eE#s(OS()*$!c !c !rO   