o ߗiA* @sddlZddlZddlmZmZmZmZddlZddlmZmZm Z m Z ddl m Z e ddddej deed efd d Zd d ZddZe deje dededede jdiZddZeZdejd efddZdejejd ejejfddZdS)N)ListOptionalSequenceUnion)devicedtypeTensortypes) exposed_inz torch.library)op_nameprototype_functionr returnc sZd}t|fdddtffdd }g}t}d}tjD]>\}\} } t| s3d| jtj j krC|sC| d d }| j tj j urRd | d | j } t| tkr_|| } | tvr| jturt| } d } | tvr|d| d} d | d| j d| dtd nd | d| j dtdt| }t|tkr||krtd|drd|d|tdd}n| |vr|dsوd | dd|d|tdd}|| | jtj j ur| |d| q$d}| jdust| jtttfrt| j}n@t| jttjfr(d| jd}n.t| jtjrHt| j}d}||s?J|t|d}nd | dt| jd| |d| d |q$||kr}t||}t|d!kr}|d"j }t|tkr||}t!|}|dur|d#d$"|d%|Sd#d$"|d%|S)&aJParses 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 unknowncstd|dd)Nzinfer_schema(func): z Got func with signature )) ValueError)what)sigY/home/ubuntu/transcripts/venv/lib/python3.10/site-packages/torch/_library/infer_schema.pyerror_fn9szinfer_schema..error_fnannotation_typec sBzt|WSty }zd|dWYd}~dSd}~ww)NzUnsupported type annotation z. It is not a type.)eval Exception)re)rrrconvert_type_string>s  z)infer_schema..convert_type_stringFz>We do not support positional-only args, varargs, or varkwargs.*Tz Parameter z must have a type annotation.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: zomutates_args must either be a sequence of the names of the arguments that are mutated or the string 'unknown'. rzTensor(az!)NzM is in mutable_args but only Tensors or collections of Tensors can be mutated "ztorch.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) -> )#inspect signaturestrset enumerate parametersitemssupported_paramkind Parameter KEYWORD_ONLYappend annotationemptytypeSUPPORTED_PARAM_TYPESkeys __origin__tuple tuple_to_listr startswithlenadddefault isinstanceintfloatbooltorchrrreturn_annotation parse_returnjoin)r mutates_argsr UNKNOWN_MUTATESrparams seen_argssaw_kwarg_only_argidxnameparamr list_typeexample_type_str schema_type default_repr dtype_repr torch_dotmutates_args_not_seenr@retr)rrr infer_schema s*                    rScs|ftj|dfg}dd}|r"|fdd||D|r5|fdd|tj|D|rE|fdd||D|S)N?cSstj|tj|gSN)typingrr)typrrrderived_seq_typessz(derived_types..derived_seq_typesc3|] }|dfVqdS)z[]Nr.0seq_typcpp_typerr s z derived_types..c3rY)z?[]NrrZr]rrr_s  c3s$|] }tj|dfVqdS)z[]?N)rVrrZr]rrr_s  )rVrextend) base_typer^ list_baseoptional_base_listoptional_list_baseresultrXrr]r derived_typess" rfc Cstddddftddddftddddftddddftddddftjddddftd dddftd dddfg}g}|D] }| t |q7t |S) NrTFSymIntr=r>r%Scalar ScalarTypeDevice) rr<r=r>r%r Numberrrr`rfdict)datarelinerrrget_supported_param_typess        rorzTensor[]rgr=r>rhcCs|durdS|tjjur|dt|}|tur.|tvr*|d|dtdt|St|}|D]}|tvrF|d|dtdq5dd dd |Dd S) Nz()z7No return type annotation was provided. Please add one.zReturn has unsupported type rrr!r"cSsg|]}t|qSr)SUPPORTED_RETURN_TYPES)r[argrrr sz parse_return..r) r#r,r0rV get_originr5rpr3get_argsrB)r/roriginargsrqrrrrAs.    rArJcCs|jtjjtjjfvSrU)r+r#r,POSITIONAL_OR_KEYWORDr-)rJrrrr*sr* tuple_typecCst|dd}|tjus|dks|durtjSt|dkr#tj|dSt|dkr6|dtur6tj|dStjtjt|S)z} Convert `tuple_type` into a list type with the same type arguments. Assumes that `tuple_type` is typing.Tuple type. __args__Nrr)getattrrVTuplerr8Ellipsisrr5)rx type_argsrrrr6s  r6)r#rVrrrrr?rrrr torch.utils._exposed_inr Callabler%rSrfror<r=r>rkrprAr2r,r*Typer}r6rrrrs:    &