o j9:j7@s,ddlZddlZddlZddlmZddlZddlmZmZmZmZddl m Z ddl m Z m Z mZejZe dddd ejd edBd efd d ZdeejBdedededef ddZddZedejedeededededejdiZddZeZdej d efd d!Z!d"ee"d eefd#d$Z#dS)%N) GenericAlias)devicedtypeTensortypes) exposed_in)_resolve_opaque_type_infois_opaque_reference_typeis_opaque_typez torch.library)op_nameprototype_functionr returnc sd}|jdt|fdddtffdd dttttBd fd tttjd ft fffd d d tttBd ttjt fffdd g}t }d}t j D]m\}\}} t| skd| jtjjkr{|s{|dd}| jtjjurd|d| j\} } d} | tvrt| rt| j} nT| tjjkrd|dnEt| dr| jturt| } d}| tvrd| d}d|d| jd|dtd nd|d| jdtdnt| } | durt d |t|tur&||krt!d!| "d"r%d#|d$| t#d"d} n!||vrG| "d"s9d|d%d#|d$| t#d"d} |$|| j%tjjur_|| d&|q\d}| j%dusqt&| j%t't(t frwt| 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)sigb/home/nk/hobo-godmode/plappi-mvp/.venv/lib/python3.10/site-packages/torch/_library/infer_schema.pyerror_fnIszinfer_schema..error_fnannotation_typecs4zt|WStyd|dYdSw)NzUnsupported type annotation z. It is not a type.)eval Exception)r)r pf_globals pf_localsrrconvert_type_stringLs   z)infer_schema..convert_type_stringtys.rcsHg}d}|D]}|\}}||||O}q|r t|dfS|dfS)NFT)appendtuple)rreschangedty ty_changed)unstringify_typerrunstringify_typesTs    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$bs  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'rtypeobjectr(Anyboolset enumerate parametersitemssupported_paramkind Parameter KEYWORD_ONLYr annotationemptySUPPORTED_PARAM_TYPESr r class_nametorch_C ScriptObjecthasattrr/ 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_seenrWretr)rrrrrr$r%r infer_schemas*  *                       rk base_typecpp_type list_baseoptional_base_listoptional_list_basecs|ftj|dfg}dttjBfdd}|r(|fdd||D|r;|fdd|tj|D|rK|fdd||D|S) N?typcSs,tj|tj|ttjj|ftt|ffSN)r(SequenceListr collectionsabclist)rrrrrderived_seq_typess  z(derived_types..derived_seq_typesc3|] }|dfVqdS)z[]Nr.0seq_typrmrr s z derived_types..c3rz)z?[]Nrr{r~rrrs  c3s$|] }tj|dfVqdS)z[]?N)r(Optionalr{r~rrrs  )r(rr: _SpecialFormextend)rlrmrnrorpresultryrr~r derived_typess" rc Cstddddftddddftddddftddddftddddftjddddftd dddftd dddfg}t j rLd d l m }|tt|ddddfg}|D] }|t|qPt|S) NrTFSymIntrVr=r'Scalar ScalarTypeDevicer) GroupName)rrUrVr=r'rNumberrrrJ distributed is_available"torch.distributed.distributed_c10drrr(castr:rrdict)datarrlinerrrget_supported_param_typess        rrzTensor[]rrVr=rcs|durdS|tjjur|dt|}|tur5|tvr1t|r&t|j S|d|dtdt|St |}|D]}|tvrQt|sQ|d|dtdq._return_type_strr6c3s|]}|VqdSrsr)r|rrrrrHszparse_return..rr5r) r8rDrGr(r)rrr r rIr*rYrR)rFrr+r,r output_tyrrrrX(s:       rXracCs|jtjjtjjfvSrs)rCr8rDPOSITIONAL_OR_KEYWORDrE)rarrrrBSsrB 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__Nrrr)getattrr(TuplerrxrREllipsisUnion)r type_argsrrrrNZs     rN)$rvr8r(rrrJrrrtorch.utils._exposed_inr opaque_objectr r r _TestTensorCallabler'rkr:rr=rrrurxrUrVrrrXrHrDrBrrNrrrrsV    G '  (