o ei16@s<ddlZddlZddlZddlmZddlmZmZddlZddlmZm Z m Z mZddl m Z ddl mZmZej Ze ddd d ejd eed efd dZdeeejfdedededef ddZddZe deje dee dedededejdiZddZeZ d ej!d efd!d"Z"d#ee#d eefd$d%Z$dS)&N) GenericAlias)OptionalUnion)devicedtypeTensortypes) exposed_in) _OPAQUE_TYPESis_opaque_typez torch.library)op_nameprototype_functionr returnc s"d}|jdt|fdddtffdd dtttttfd fd tttj d ft fffd d d ttttfd ttj t fffdd g}t }d}t j D]m\}\}} t| sod| jtjjkr|s|dd}| jtjjurd|d| j\} } d} | tvrt| rt| j} nT| tjjkrd|dnEt| dr| jturt| } d}| tvrd| d}d|d| jd|dt d nd|d| jdt dnt| } | durt!d |t|tur*||krt"d!| #d"r)d#|d$| t$d"d} n!||vrK| #d"s=d|d%d#|d$| t$d"d} |%|| j&tjjurc|| d&|q`d}| j&dusut'| j&t(t)t fr{t| j&}nFt'| j&ttj*frd'| j&d'}n4t'| j&tj+rt| j&}d(}|#|st!d)|d*|t$|d}nd|d+t| j&d,|| d&|d-|q`||krt ||}t$|d.kr|d/j,\}} t-|}|dur|d0d1.|d2|Sd0d1.|d2|S)3aJParses the schema of a given function with type hints. The schema is inferred from the function's type hints, and can be used to define a new operator. We make the following assumptions: * None of the outputs alias any of the inputs or each other. * | String type annotations "device, dtype, Tensor, types" without library specification are | assumed to be torch.*. Similarly, string type annotations "Optional, List, Sequence, Union" | without library specification are assumed to be typing.*. * | Only the args listed in ``mutates_args`` are being mutated. If ``mutates_args`` is "unknown", | it assumes that all inputs to the operator are being mutates. Callers (e.g. the custom ops API) are responsible for checking these assumptions. Args: prototype_function: The function from which to infer a schema for from its type annotations. op_name (Optional[str]): The name of the operator in the schema. If ``name`` is None, then the name is not included in the inferred schema. Note that the input schema to ``torch.library.Library.define`` requires a operator name. mutates_args ("unknown" | Iterable[str]): The arguments that are mutated in the function. Returns: The inferred schema. Example: >>> def foo_impl(x: torch.Tensor) -> torch.Tensor: >>> return x.sin() >>> >>> infer_schema(foo_impl, op_name="foo", mutates_args={}) foo(Tensor x) -> Tensor >>> >>> infer_schema(foo_impl, mutates_args={}) (Tensor x) -> Tensor unknownNcstd|dd)Nzinfer_schema(func): z Got func with signature )) ValueError)what)sige/var/www/addictedbytheproject.nl/epg/venv/lib/python3.10/site-packages/torch/_library/infer_schema.pyerror_fnFszinfer_schema..error_fnannotation_typecs4zt|WStyd|dYdSw)NzUnsupported type annotation z. It is not a type.)eval Exception)r)r pf_globals pf_localsrrconvert_type_stringIs   z)infer_schema..convert_type_stringtys.rcsHg}d}|D]}|\}}||||O}q|r t|dfS|dfS)NFT)appendtuple)rreschangedty ty_changed)unstringify_typerrunstringify_typesQs    z'infer_schema..unstringify_typesr#csPt|tr |dfSt|}r$t|\}}|r$t||dfS|dfS)NTF) isinstancestrtyping get_originget_argsr)r#originargs args_changed)rr&rrr%_s  z&infer_schema..unstringify_typeFz>We do not support positional-only args, varargs, or varkwargs.*Tz Parameter z must have a type annotation.z's type cannot be inferred from the schema as it is a ScriptObject. Please manually specify the schema using the `schema=` kwarg with the actual type of the ScriptObject. __origin__z z For example, z. z has unsupported type z]. We do not support Tuple inputs in schema. As a workaround, please try to use List instead. zThe valid types are: .. The valid types are: zschema_type is None for param zomutates_args must either be a sequence of the names of the arguments that are mutated or the string 'unknown'. rzTensor(az!)zM is in mutable_args but only Tensors or collections of Tensors can be mutated "ztorch.z dtype repr z must start with 'torch.'z' has an unsupported default value type z;. Please file an issue on GitHub so we can prioritize this.=rz in mutates_args were not found in the custom op's signature. mutates_args should contain the names of all args that the custom op mutates, or just the string 'unknown' if you don't know.(, z) -> )/ __globals__inspect signaturer(r rtypeobjectr)Anyboolset enumerate parametersitemssupported_paramkind Parameter KEYWORD_ONLYr annotationemptySUPPORTED_PARAM_TYPESr r class_nametorch_C ScriptObjecthasattrr0 tuple_to_listkeysAssertionErrorr startswithlenadddefaultr'intfloatrrreturn_annotation parse_returnjoin)r mutates_argsr UNKNOWN_MUTATESparams seen_argssaw_kwarg_only_argidxnameparamr_ schema_type list_typeexample_type_str default_repr dtype_repr torch_dotmutates_args_not_seenrXretr)rrrrrr%r&r infer_schemas*  .                       rl base_typecpp_type list_baseoptional_base_listoptional_list_basecs|ftj|dfg}dtttjffdd}|r*|fdd||D|r=|fdd|tj|D|rM|fdd||D|S) N?typcSs,tj|tj|ttjj|ftt|ffSN)r)SequenceListr collectionsabclist)rsrrrderived_seq_typess  z(derived_types..derived_seq_typesc3|] }|dfVqdS)z[]Nr.0seq_typrnrr s z derived_types..c3r{)z?[]Nrr|rrrrs  c3s$|] }tj|dfVqdS)z[]?N)r)rr|rrrrs  )r)rrr; _SpecialFormextend)rmrnrorprqresultrzrrr derived_typess" rc Cstddddftddddftddddftddddftddddftjddddftd dddftd dddfg}t j rLd d l m }|tt|ddddfg}|D] }|t|qPt|S) NrTFSymIntrWr>r(Scalar ScalarTypeDevicer) GroupName)rrVrWr>r(rNumberrrrK distributed is_available"torch.distributed.distributed_c10drrr)castr;rrdict)datarrlinerrrget_supported_param_typess        rrzTensor[]rrWr>rcCs|durdS|tjjur|dt|}|tur,|tvr(|d|dtdt|St|}|D]}|tvrD|d|dtdq3ddd|D}t |d kr[d |d }d |d S) Nz()z7No return type annotation was provided. Please add one.zReturn has unsupported type r2r1r7cSsg|]}t|qSr)SUPPORTED_RETURN_TYPES)r}argrrr =sz parse_return..r r6r) r9rErHr)r*r rr+rZrS)rGrr,r-r output_tyrrrrY%s4      rYrbcCs|jtjjtjjfvSrt)rDr9rEPOSITIONAL_OR_KEYWORDrF)rbrrrrCHsrC tuple_typecCst|dd}|tjus|tus|dks|durtSt|dkr%t|dSt|dkr7|dtur7t|dSttjt|S)z} Convert `tuple_type` into a list type with the same type arguments. Assumes that `tuple_type` is typing.Tuple type. __args__Nrr r)getattrr)Tupler ryrSEllipsisr)r type_argsrrrrOOs     rO)%rwr9r)rrrrrKrrrtorch.utils._exposed_inr opaque_objectr r _TestTensorCallabler(rlr;rr>rrrvryrVrWrrrYrIrErCr rOrrrrsX   G  '