o i, @sVddlZddlmZmZddlmZddlmZddlm Z ddl m Z m Z m Z mZmZmZddlmZddlmZmZmZdd lmZdd lmZmZmZmZd Zd Zd Z de!fddZ"GdddeZ#dedefddZ$dedefddZ%de dede dedef ddZ&de dede dedef d d!Z'ed"d#d$Z(ed%d&d$Z)Gd'd(d(eZ*dS))N)DictList) TypeChecker) ErrorCode)Errors)CallExpr Decorator ExpressionFuncDefMypyFileNameExpr)Options)CheckerPluginInterfaceFunctionContextPlugin) is_subtype) CallableTypeInstanceType TypeVarTypezthinc.model.Modelzthinc.types.XY_YZ_OutTzthinc.types.XY_XY_OutTversioncCtSN) ThincPlugin)rr>/home/ubuntu/.local/lib/python3.10/site-packages/thinc/mypy.pypluginrcs4eZdZdeddffdd ZdefddZZS) roptionsreturnNcst|dSr)super__init__)selfr __class__rrr!szThincPlugin.__init__fullnamecCrr) function_hook)r"r%rrrget_function_hookrzThincPlugin.get_function_hook)__name__ __module__ __qualname__r r!strr' __classcell__rrr#rrsrctxrcCs$zt|WSty|jYSwr)get_reducers_typeAssertionErrordefault_return_type)r-rrrr&s    r&cCst|jtsJt|jtsJt|jtsJ|jj}t|ts#J|j }t|t t fs/J|j }t|t s9J|j}t|tsCJ|j jtksKJ|jsPJt|jdksYJ|jd}t|tseJ|jsjJ|jtthvrt|jSttj|j}g}tj|jD]}t|tsJ|j jtksJt|jdksJ||qtt|dd|dd} tt|dd|dd} |jtkrt| | D]0\\} } \} }t| tsJt|tsJ| j jtksJ|j jtksJt| | | ||jdqt|jj |djd|djdgS|jtkret| | D]5\\} } \} }t| ts,Jt|ts4J| j jtks=J|j jtksFJt| | | ||jdqt|jj |djd|djdgSJd) 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_typeapirFz;Thinc mypy plugin error: it should return before this point) isinstancer9rr0rcontextrcalleer noder rtyperret_typer%thinc_model_fullnameargslenrintoin_outtoout_out_fullnamechained_out_fullnamelist itertoolschain arg_typesappendzip check_chainedcheck_intoin_outtoout)r-r< callee_nodecallee_node_typecallee_return_typeout_typerArHarg_type arg_pairsarg_types_pairsarg1arg2type1type2rrrr.&sjE           r.r5r6r7r8r9cCsrt|jd|jds7|jd|jdd|jdd|td|jd|jdd|jdd |tddSdS) Nr2rzLayer outputs type (z) but the next layer expects (z ) as an inputcodezLayer input type (z!) is not compatible with output (z) from previous layer)rrAfailerror_layer_outputerror_layer_inputr4rrrrKs rKcCs|jd|jdkr4|jd|jdd|jdd|td|jd|jdd|jdd|td|jd|jdkrj|jd|jdd |jdd|td|jd|jdd |jdd|tddSdS) Nrz Layer input (z() not compatible with next layer input ()rXz,) not compatible with previous layer input (r2zLayer output (z)) not compatible with next layer output (z-) not compatible with previous layer output ()rArZr\r[r4rrrrLs. rLzlayer-mismatch-inputzInvalid layer inputThinczlayer-mismatch-outputzInvalid layer outputcsJeZdZdedeeefdededededee e fffdd Z Z S) IntrospectCheckererrorsmodulesrtreepathrper_line_checking_time_nsc s"g|_t|||||||dSr)_error_messagesr r!)r"r`rarrbrcrrdr#rrr!s zIntrospectChecker.__init__) r(r)r*rrr+r r rintr!r,rrr#rr_s   r_)+rFtypingrr mypy.checkerrmypy.errorcodesr mypy.errorsr mypy.nodesrrr r r r mypy.optionsr mypy.pluginrrr mypy.subtypesr mypy.typesrrrrr@rDrCr+rrr&r.rKrLr\r[r_rrrrsV