o iq@sjUddlZddlZddlZddlZddlZddlZddlmZmZm Z ddl m Z m Z m Z ddl mZmZddlmZmZddlmZmZmZmZmZmZmZejdkr[ddlmZndZdd lmZmZmZm Z m!Z!dd l"m#Z#m$Z$dd l%m&Z&m'Z'dd l(m)Z)m*Z*m+Z+m,Z,m-Z-ejdkrddlmZndZerdd l.m/Z/edZ0ededZ1ededZ2ee3e4ej e3e4e e3e4e5e5e4e3e3e4e6e6e4e7e7e4dfiZ8e9e:e:fe;d<eej e e5e3e6e7hZfddZ?de4de@fddZAde4deBfddZCde4deDfddZEde4de fdd ZFde4de fd!d"ZGde4de fd#d$ZHd%e:e1d&ed'e4fd(ee4ge4fde1fd)d*ZId+e:e2d,ee4ed'Bd(ee4ge4fde2fd-d.ZJe>e?e@eAeBeCeDeEe eFe eGe eHiZKe9eefe;d/<d%e:ed,d'd0ee:e4gefdBd(ee4ge4fde7f d1d2ZLd%ed3e9d4e9d0edBd(ee4ge4ff d5d6ZMd&d'd%ed7ejNde4fd8d9ZOd%e:e0d3e9e4efde0fd:d;ZPd%e:e0d&e d'd4e9e4dd?ZQd&ed'e d'fd0eee4gefdBd(ee4ge4ffd@dAZR  dEd%ed,e e4e d'Be=Bd0ee:e4gefdBd(ee4ge4fdBfdBd=ZSd%ede7e@e>ffdCdDZTdS)FN)CallableIterableSequence)datedatetime timedelta)EnumFlag)partialreduce) TYPE_CHECKINGAnyLiteralTypeVarUnionget_args get_origin) ) TypeAliasType) is_annotated is_enum_flag is_nonetypeis_unionresolve) CoercionErrorValidationError) FieldInfoget_field_infos)UNSETdefault_name_transformgrouper is_builtinis_class_and_subclassTokenTE)boundF._implicit_iterable_type_mapping NestedCliArgssreturncCs*|}|dvr dS|dvrdSttd)N>0fnnofalseF>1tyyestrueT) target_type)lowerrboolr,r<W/var/www/html/karishye-ai-python/venv/lib/python3.10/site-packages/cyclopts/_convert.py_boolCs  r>cCsd|}|drt|dS|drt|dS|dr"t|dSd|vr.ttt|St|S)N0x0o0b.)r9 startswithintroundfloatr;r<r<r=_intNs      rJcCs t|ddS)Nutf8)encoding)bytesr;r<r<r=_bytes_ rNcCs tt|SN) bytearrayrNr;r<r<r= _bytearraycrOrRcCs t|S)zDParse a date string. Returns ------- datetime.date )r fromisoformatr;r<r<r=_dategs rTc Cs8zt|WStyt|dddYSw)zLParse a datetime string. Returns ------- datetime.datetime  r&)rrS ValueErrorstripreplacer;r<r<r= _datetimeqs   rZcCsd}|drd}|dd}td|}|std|d}|D]S\}}}t|}|d kr4||7}q"|d kr?||d 7}q"|d krJ||d 7}q"|dkrU||d7}q"|dkr`||d7}q"|dkrk||d7}q"|dkru||d7}q"|r{| }t|dS)zParse a timedelta string.F-TrVNz((\d+\.\d+|\d+)([smhdwMy]))z!Could not parse duration string: rr,m<hidiQwi: Mi'r5i3)seconds)rFrefindallrWrIr)r,negativematchesrb_valueunitr<r<r= _timedeltas8      rjtype_tokenr%name_transformc Csnddlm}t||}|r|jn|}||}|jD]\}}|||kr)|Sqt|r2||dd|d)zqMatch a token's value to an enum's member. Applies ``name_transform`` to both the value and the member. rr$Nrlr8)cyclopts.argumentr% isinstancerh __members__itemsr) rkrlrmr%is_tokenrhvalue_transformednamememberr<r<r=get_enum_members  rw enum_typetokenscs"ttjfdd|DdS)aConvert tokens to a Flag enum value. Parameters ---------- enum_type : type[F] The Flag enum type to convert to. tokens : Iterable[str] | Iterable[Token] The tokens to convert. Can be member names or :class:`Token` objects. name_transform : Callable[[str], str] | None Function to transform names for comparison. Returns ------- F The combined flag value. Raises ------ CoercionError If a token is not a valid flag member. c3s|] }t|VqdSrP)rw).0rlrxrmr<r= z$convert_enum_flag..r)r operatoror_)rxryrmr<r{r=convert_enum_flags r _converters converterc s<tt||dtddt|D}t|\}td|r]t|}|r5tddt|ddt|dkr@|d n t|d krItnt d tfd dt |DSt|krqtd dt|ddd d|D}t |fdd|D}dd|D}tfddt ||ddD} | S)Nrrmcss|] }|dur|VqdS).Nr<rzxr<r<r=r|r}z!_convert_tuple..rVz4Incorrect number of arguments: expected multiple of z but got rE)msgrz%A tuple must have 0 or 1 inner-types.c3s*|]}dkr|dn|VqdS)rVrNr<)rzchunk)convertinner_token_count inner_typer<r=r|s  z(Incorrect number of arguments: expected cSsg|]}t|dqS)r token_countrr<r<r= sz"_convert_tuple..cs"g|] }fddt|DqS)csg|]}tqSr<)next)rzrgitr<r=rsz-_convert_tuple...)range)rzsizerr<r=rs"cSs$g|]}t|dkr|dn|qS)rVr)len)rzelemr<r<r=rs$c3s|] \}}||VqdSrPr<)rzrargrr<r=r|F)strict) r _converttuplerrmaxrrstrrWr!iterzip) rkrrmry inner_types consume_all remainderargs_per_convertbatchedoutr<)rrrrr=_convert_tuples8        rdata field_infosc Csddlm}i}|D]9\}}||vrE||} | dur?t|jts?|t| ttBr/t | nt| d} t |j| g||} n| } | ||<q |di|S)aConvert JSON dict to dataclass with proper type conversion for fields. Parameters ---------- type_ : Type The dataclass type to create. data : dict The JSON dictionary containing field values. field_infos : dict Field information from the dataclass. converter : Callable | None Optional converter function. name_transform : Callable[[str], str] Function to transform field names. Returns ------- Instance of type_ with properly converted field values. rr$Nrhr<) cyclopts.tokenr%rrr#hintrrpdictlistjsondumpsr) rkrrrrmr%converted_data field_name field_inforhrlconverted_valuer<r<r= _convert_jsons &rerrorc Cs|j}t|dr |jn t|dr|jdnd}td|d}tt||d}|||}|dkr7d|}|t|krA|d}||}|dkrM|d7}d} t d |rXd } nt d |rad } nt d |rjd} nd|vrpd} d|j d|dd|d|j | S)aCreate a helpful error message for JSON decode errors. Parameters ---------- token : Token The token containing the invalid JSON. type_ : Type The target type we were trying to convert to. error : json.JSONDecodeError The JSON decode error that occurred. Returns ------- str A formatted error message with context and hints. poscolnorVrz...rz\bTrue\bz8 Hint: Use lowercase 'true' instead of Python's Truez \bFalse\bz: Hint: Use lowercase 'false' instead of Python's Falsez\bNone\bz. Hint: Use 'null' instead of Python's None'z9 Hint: JSON requires double quotes, not single quoteszInvalid JSON for z: z rUz^ ) rhrXhasattrrrrminrrcsearch__name__r) rlrkr value_str error_pos snippet_start snippet_endsnippet marker_posrr<r<r=!_create_json_decode_error_messageCs, (     (rcst|}|s |di|Sg}i}|D]\}}||}|r.|jtjkr.|||fq|||<qt||j fddd|dd|Di|S)a%Instantiate a type with proper handling of parameter kinds. Respects POSITIONAL_ONLY, KEYWORD_ONLY, and POSITIONAL_OR_KEYWORD parameter kinds when constructing the object. This function is necessary because `inspect.signature().bind(**data)` has the same limitation we're solving: it cannot accept positional-only parameters as keyword arguments. For example, `def __init__(self, a, /, b)` requires `a` to be passed positionally, but when we have a dict `{"a": 1, "b": 2}`, we need to transform this into the call `type_(1, b=2)`. Parameters ---------- type_ : type[T] The type to instantiate. data : dict[str, Any] Dictionary mapping field names to values. Returns ------- T Instance of type_ constructed from data. cs|dS)Nr)index)rfield_names_orderr<r=sz'instantiate_from_dict..)keycss|]\}}|VqdSrPr<)rzrgvr<r<r=r|sz(instantiate_from_dict..Nr<) rrrgetkindrPOSITIONAL_ONLYappendrkeyssort)rkrrpos_argskwargsrrhrr<rr=instantiate_from_dict{s   rrrc Csd}i}|}|D]O\}}|j}t|tr"||j} |d7}d} n't|\} } | dkr8||||} |d7}n|||||| } || 7}| } | ||<| rQn |t|krYnq |t|ksbJt||S)aConvert tokens to a structured type with proper positional/keyword argument handling. Respects the parameter kind of each field: - POSITIONAL_ONLY: passed as positional argument - KEYWORD_ONLY or POSITIONAL_OR_KEYWORD: passed as keyword argument This correctly handles types with keyword-only fields (e.g., dataclasses with kw_only=True). Parameters ---------- type_ : type[T] The target structured type to instantiate. token : Sequence[Token] The tokens to convert. field_infos : dict[str, FieldInfo] Field information for the structured type. convert : Callable Conversion function for nested types. Returns ------- T Instance of type_ constructed from the tokens. rrVF)rrrr#rrhrrr) rkrlrrirrrrrh should_breaktokens_per_elementrr<r<r=_convert_structured_types0      rc sddlmddlm}d}t|r3ddlm}||\}jr,d}fdd}|}jr2j}ndtt ||d tt ||d }t |}t ||t urZt ttf|} nE|tvrgt||} n8|tjjtjjfvrtd ksyJtd|} ntdurt|tr|j|} n t|rÈD]} t| rqz| |} WntyYqwt|trtt||d n|turd} t |D](} z t| |} Wnty}z|} WYd}~qd}~ww| | kr| } nq| r|| _ | tt|tr |d|d ||d n|t!ur4t|r'||||d } nx||g|Rd |i} nk|t"vrt#d\}}t|tsItd}|d krft$fdd|Drf|turf|}n|d krxt%t&|g|ddi}n|}|fdd|D} nt'|t(rt)|t|tr|n|g|} nt'|t*rt|trt|durt+|||} n|||j,} nt-|}t.|s|s-t|sJz*|j/t0ur|j/} n|durt12|||j,} n|r|||} n|||j,} Wnty}z|j dur||_ |j3dur||_3d}~wty,t||d dwt|r|j,45dr|turzt67|j,}t|t sPt8t9|||||} WnEt6j:yu}zt;|||}t|||d|d}~wt8yt|ts|g}t<|||} Ynwt|ts|g}t<|||} rzj=D]}||| qW| St>tt8fy}zt?|j@r|j@dnd| d|d}~ww| S)zInner recursive conversion function for public ``convert``. Parameters ---------- converter: Callable name_transform: Callable rr$) ParameterFTcsjsJ||fSrPr)t_rh)cparamr<r=converter_with_tokens z&_convert..converter_with_tokenNrrVrnrrc3s*|]}t|o|jdVqdS){N)rprhrXrF)rzr4r$r<r=r|Ks(z_convert..rc3s|] }d|VqdS)rNr<)rze)rrr<r=r|Trr)rrlr8r)exception_messagerh)Aror%cyclopts.parameterrrfrom_annotationrrmr rrrrrrr* collectionsabcrrrrrrp __value__rr ExceptionrWrrtyper8rITERABLE_TYPESranyrrr#r rrrwrhrr"implicit_valuerrrrlrXrFrloads TypeErrorrJSONDecodeErrorrr validatorAssertionErrorrargs)rkrlrrmrconverter_needs_tokenr convert_tuple origin_typerr4last_coercion_errorchoiceresrcountrgrgenrrrrr<)r%rrrr=rs           &        "         (       rc sddlm|s tt|ts!t|dtr!tfdd|D}dur'ttt dtt d}t t ur?tt t}|pL}|turY|g|RS|tvsc|tjjurh|S|turt|tsstztdWn tytYnwfdd |D}t||di|St|trtd d t|rt||St|dkrÈ|dSt\}} |dkrׇfd d |DSt||kr|Std)aCoerce variables into a specified type. Internally used to coercing string CLI tokens into python builtin types. Externally, may be useful in a custom converter. See Cyclopt's automatic coercion rules :doc:`/rules`. If ``type_`` **is not** iterable, then each element of ``tokens`` will be converted independently. If there is more than one element, then the return type will be a ``Tuple[type_, ...]``. If there is a single element, then the return type will be ``type_``. If ``type_`` **is** iterable, then all elements of ``tokens`` will be collated. Parameters ---------- type_: Type A type hint/annotation to coerce ``*args`` into. tokens: Union[Sequence[str], NestedCliArgs] String tokens to coerce. Generally, either a list of strings, or a dictionary of list of strings (recursive). Each leaf in the dictionary tree should be a list of strings. converter: Optional[Callable[[Type, str], Any]] An optional function to convert tokens to the inner-most types. The converter should have signature: .. code-block:: python def converter(type_: type, value: str) -> Any: "Perform conversion of string token." This allows to use the :func:`convert` function to handle the the difficult task of traversing lists/tuples/unions/etc, while leaving the final conversion logic to the caller. name_transform: Optional[Callable[[str], str]] Currently only used for ``Enum`` type hints. A function that transforms enum names and CLI values into a normalized format. The function should have signature: .. code-block:: python def name_transform(s: str) -> str: "Perform name transform." where the returned value is the name to be used on the CLI. If ``None``, defaults to ``cyclopts.default_name_transform``. Returns ------- Any Coerced version of input ``*args``. rr$c3s|] }t|dVqdS)rN)rrr$r<r=r|rzconvert..NrrVc s"i|] \}}|t|dqS)rr)rzkr)rrm value_typer<r= szconvert..z*Dictionary of tokens provided for unknown rEcsg|]}|qSr<r<)rzitem) convert_privrkr<r=r szconvert..z Unreachable?r<)ror%rWrprrrr r rrrr r*rrrrrrr IndexErrorrrrrrrrNotImplementedError) rkryrrmrrmaybe_origin_typedict_convertedrrgr<)r%rrrmrkrr=rsV :          c Cst|}t|}|p |tur#t|}|r!tdd|Dd|vfSdS|p&|tur+dS|tvs;|tvr=tt|dkr=dSt|rCdS|tvsM|t j j ur_tt|r_t t|dddfSt durmt|t rmt |jSt|rt|}t |d}|d dD]}t |}||krtd |dd |q|St|rd St|}d\}} |D]} | j| jurd} n| jsqt | j\} } || 7}| | O} q|sd S|| fS) aThe number of tokens after a keyword the parameter should consume. Parameters ---------- type_: Type A type hint/annotation to infer token_count from if not explicitly specified. Returns ------- int Number of tokens to consume. bool If this is ``True`` and positional, consume all remaining tokens. The returned number of tokens constitutes a single element of the iterable-to-be-parsed. css$|] }|durt|dVqdS).rNrrr<r<r=r|(s"ztoken_count...)rVT)rFrTNrVz=Cannot Union types that consume different numbers of tokens: rU)rVF)rrrrsumr:rrrrrrrrrprrrWr"rvaluesrVAR_POSITIONALrequiredr) rkrrsub_argstoken_count_target sub_type_thisrrrrh elem_countelem_consume_allr<r<r=rsV         r)NN)Ucollections.abcrrr~rcsystypingrrrrrrenumrr functoolsr r r r rrrrr version_inforcyclopts.annotationsrrrrrcyclopts.exceptionsrrcyclopts.field_inforrcyclopts.utilsrr r!r"r#ror%r&r'r)rr frozensetsetrr*rr__annotations__rr+r:r>rGrJrMrNrQrRrTrZrjrwrrrrrrrrrrrr<r<r<r=s $           %     #   +  . "8-  @  < r