h, rSSKrSSKJrJr SSKJr SSKJr SSKJ r SSK J r J r J r JrJrJr SSKJr SSKJrJrJr SS KJr SS KJrJrJrJr S rS rS r S\!4Sjr""SS\5r#S\S\4Sjr$S\S\4Sjr%S\ S\S\ S\S\4 Sjr&S\ S\S\ S\S\4 Sjr'\"SSS5r(\"S S!S5r)"S"S#\5r*g)$N)DictList) TypeChecker) ErrorCode)Errors)CallExpr Decorator ExpressionFuncDefMypyFileNameExpr)Options)CheckerPluginInterfaceFunctionContextPlugin) is_subtype) CallableTypeInstanceType TypeVarTypezthinc.model.Modelzthinc.types.XY_YZ_OutTzthinc.types.XY_XY_OutTversionc[$N) ThincPlugin)rs D/home/james-whalen/.local/lib/python3.13/site-packages/thinc/mypy.pypluginrs cB^\rSrSrS\SS4U4SjjrS\4SjrSrU=r $) roptionsreturnNc$>[TU]U5 gr)super__init__)selfr __class__s rr$ThincPlugin.__init__s !rfullnamec[$r) function_hook)r%r(s rget_function_hookThincPlugin.get_function_hooksr) __name__ __module__ __qualname____firstlineno__rr$strr+__static_attributes__ __classcell__r&s@rrrs'""D"#rrctxr!cR[U5$![a URs$f=fr)get_reducers_typeAssertionErrordefault_return_type)r6s rr*r*s-' %% '&&&'s &&c [UR[5(de[UR[5(de[UR [ 5(deUR Rn[U[5(deURn[U[[45(deURn[U[5(deURn[U[5(deURR[ :XdeUR"(de[%UR"5S:XdeUR"Sn[U[&5(deUR(deUR[([*1;a UR$[-[.R0"UR"65n/n[.R0"UR26Hfn[U[5(deURR[ :Xde[%UR"5S:XdeUR5U5 Mh [-[7USSUSS55n [-[7USSUSS55n UR[*:Xa[7X5Huupup[U [5(de[U[5(deU RR[ :XdeURR[ :Xde[9XXURS9 M [ URRUSR"SUSR"S/5$UR[(:Xa[7X5Huupup[U [5(de[U[5(deU RR[ :XdeURR[ :Xde[;XXURS9 M [ URRUSR"SUSR"S/5$S5e)a Determine a more specific model type for functions that combine models. This function operates on function *calls*. It analyzes each function call by looking at the function definition and the arguments passed as part of the function call, then determines a more specific return type for the function call. This method accepts a `FunctionContext` as part of the Mypy plugin interface. This function context provides easy access to: * `args`: List of "actual arguments" filling each "formal argument" of the called function. "Actual arguments" are those passed to the function as part of the function call. "Formal arguments" are the parameters defined by the function definition. The same actual argument may serve to fill multiple formal arguments. In some cases the relationship may even be ambiguous. For example, calling `range(*args)`, the actual argument `*args` may fill the `start`, `stop` or `step` formal arguments, depending on the length of the list. The `args` list is of length `num_formals`, with each element corresponding to a formal argument. Each value in the `args` list is a list of actual arguments which may fill the formal argument. For example, in the function call `range(*args, num)`, `num` may fill the `start`, `end` or `step` formal arguments depending on the length of `args`, so type-checking needs to consider all of these possibilities. * `arg_types`: Type annotation (or inferred type) of each argument. Like `args`, this value is a list of lists with an outer list entry for each formal argument and an inner list entry for each possible actual argument for the formal argument. * `arg_kinds`: "Kind" of argument passed to the function call. Argument kinds include positional, star (`*args`), named (`x=y`) and star2 (`**kwargs`) arguments (among others). Like `args`, this value is a list of lists. * `context`: AST node representing the function call with all available type information. Notable attributes include: * `args` and `arg_kinds`: Simple list of actual arguments, not mapped to formal arguments. * `callee`: AST node representing the function being called. Typically this is a `NameExpr`. To resolve this node to the function definition it references, accessing `callee.node` will usually return either a `FuncDef` or `Decorator` node. * etc. This function infers a more specific type for model-combining functions by making certain assumptions about how the function operates based on the order of its formal arguments and its return type. If the return type is `Model[InT, XY_YZ_OutT]`, the output of each argument is expected to be used as the input to the next argument. It's therefore necessary to check that the output type of each model is compatible with the input type of the following model. The combined model has the type `Model[InT, OutT]`, where `InT` is the input type of the first model and `OutT` is the output type of the last model. If the return type is `Model[InT, XY_XY_OutT]`, all model arguments receive input of the same type and are expected to produce output of the same type. It's therefore necessary to check that all models have the same input types and the same output types. The combined model has the type `Model[InT, OutT]`, where `InT` is the input type of all model arguments and `OutT` is the output type of all model arguments. Raises: AssertionError: Raised if a more specific model type couldn't be determined, indicating that the default general return type should be used. Nl1_argl1_typel2_argl2_typeapirz;Thinc mypy plugin error: it should return before this point) isinstancerDrr:rcontextrcalleer noder r typerret_typer(thinc_model_fullnameargslenrintoin_outtoout_out_fullnamechained_out_fullnamelist itertoolschain arg_typesappendzip check_chainedcheck_intoin_outtoout)r6rG callee_nodecallee_node_typecallee_return_typeout_typerLrSarg_type arg_pairsarg_types_pairsarg1arg2type1type2s rr8r8&sJ cgg{ + ++ + c--x 8 88 8 ckk8 , ,, , [[  F fh ' '' '++K kGY#7 8 88 8"'' & 5 55 5 *22 (( 3 33 3  " " + +/C CC C  " "" " !&& '1 ,, ,"&&q)H h , ,, ,    !=?S TT&&&  * +DIOOS]]3(H----}}%%)====8==!Q&&&" 4ScrDH-.I3y"~y}=>O00-0 ,K (LT.5eX.. ..eX.. ..::&&*>> >>::&&*>> >> 4CGG  -L  # # ( (9Q<+<+> >>::&&*>> >> !4CGG  -L  # # ( (9Q<+<+/Ul[TU] XX4XVU5 gr)_error_messagesr#r$) r%rorpr rqrrrrsr&s rr$IntrospectChecker.__init__s$+-  WD:S r)ru)r.r/r0r1rrr2r rrintr$r3r4r5s@rrmrmsb    c8m$          $(S>   rrm)+rQtypingrr mypy.checkerrmypy.errorcodesr mypy.errorsr mypy.nodesrr r r r r mypy.optionsr mypy.pluginrrr mypy.subtypesr mypy.typesrrrrrKrOrNr2rrr*r8rVrWrhrgrmr-rrrs$%SS GG$@@*/7C&''4'ZP?ZPtZPz         *         @46KWU68NPWX  r