a
    h                     @  s  d dl mZ d dlZd dlZd dlmZ d dlmZmZ d dl	m
Z
 d dlm  mZ d dlm  mZ d dlm  mZ d dlmZ d dlmZmZmZmZmZmZmZmZmZmZmZm Z  d dl!m"Z"m#Z# d d	l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. d d
l/m0Z0m1Z1 er d dl2m3Z3 dddddddZ4dddddZ5dddddZ6dddddZ7dddddZ8dddddZ9dddddZ:ed d!G d"d# d#Z;ed d!G d$d% d%e;Z<dS )&    )annotationsN)	dataclass)LiteralTYPE_CHECKING)assert_never)	translate)	BaseCTypeBindingConstRefCTypeCppSignatureCppSignatureGroupDispatcherSignatureExprkernel_signatureMutRefCType
NamedCTypeNativeSignaturetensorT)method_with_native_functionnative_function_manager)
ArgumentBackendIndexDeviceCheckTypeDispatchKey"gets_generated_out_inplace_wrapperis_cuda_dispatch_keyNativeFunctionNativeFunctionsGroup
SchemaKindTensorOptionsArguments)mapMaybeTarget)SelectiveBuilderr   bool	list[str])backend_indexper_operator_headersrocmreturnc                 C  s   |rdg}ndg}| j tjtjfv r0|d n| j tjkrX|rL|d q|d nd| j tjkrp|d nL| j tjkr|d n4| j tjkr|d n|r|g d	7 }n
|d
 |d |S )Nz'#include <ATen/ops/as_strided_native.h>z!#include <ATen/NativeFunctions.h>z#include <ATen/EmptyTensor.h>z!#include <ATen/hip/EmptyTensor.h>z"#include <ATen/cuda/EmptyTensor.h>z!#include <ATen/mps/EmptyTensor.h>z!#include <ATen/xpu/EmptyTensor.h>z)#include <ATen/native/mtia/EmptyTensor.h>)z#include <ATen/ops/empty.h>z##include <ATen/ops/empty_strided.h>z+#include <ATen/ops/_copy_from_and_resize.h>z #include <ATen/ops/_copy_from.h>z#include <ATen/Functions.h>z#include <c10/macros/Macros.h>)	dispatch_keyr   CPUMetaappendCUDAMPSXPUMTIA)r%   r&   r'   headers r2   Q/var/www/auris/lib/python3.9/site-packages/torchgen/dest/register_dispatch_key.pygen_registration_headers/   s(    

r4   ztuple[str | None, str | None])r%   r(   c                 C  sx   d }d }| j tjtjtjtjtjtjfv rNt| j 	 }d| }d| }n"| j tj
tjtjtjfv rpd}d}||fS )Nzat::detail::empty_zat::detail::empty_strided_z	at::emptyzat::empty_strided)r)   r   r+   r*   r-   r.   r/   r0   strlower&CompositeExplicitAutogradNonFunctionalZQuantizedCPUZQuantizedCUDA)r%   
empty_implempty_strided_impldispatchr2   r2   r3   gen_empty_impl_namesU   s,    
r;   c              	   C  sN   | j tjkrd}nd}t| \}}|d u r.g S d| d| d| d| d	gS )Nzoptions.device(at::kMeta)optionsz
Tensor create_out(IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  if (strides.empty()) {
      return z(sizes, z);
  } else {
      return z(sizes, strides, z	);
  }
}
)r)   r   r+   r;   )r%   Zempty_optionsr8   r9   r2   r2   r3   gen_create_out_helperr   s     r=   c                 C  s&   t | \}}|d u rg S d| dgS )Nz
std::optional<Tensor> maybe_create_proxy(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  if (out.strides() != strides) {
    return z8(sizes, strides, options);
  }
  return std::nullopt;
}
)r;   )r%   _r9   r2   r2   r3   gen_maybe_create_proxy_helper   s    r?   c                 C  s   | j tjkrg S dgS )Na  
void resize_out(const Tensor &out, IntArrayRef sizes, IntArrayRef strides, const TensorOptions &options) {
  TORCH_CHECK(options.dtype() == out.dtype(),
      "Expected out tensor to have dtype ", options.dtype(), ", but got ", out.dtype(), " instead");
  TORCH_CHECK(options.device() == out.device(),
      "Expected out tensor to have device ", options.device(), ", but got ", out.device(), " instead");
  const bool resized = at::native::resize_output(out, sizes);
  // Only restride if a resize occurred; otherwise we ignore the (advisory)
  // strides from the meta function and directly use the output tensor's
  // preexisting strides
  if (resized) {
    if (!strides.empty()) {
      TORCH_INTERNAL_ASSERT(!options.memory_format_opt().has_value());
      // TODO: avoid the redispatch here
      out.as_strided_(sizes, strides);
    } else if (options.memory_format_opt().has_value()) {
      out.unsafeGetTensorImpl()->empty_tensor_restride(*options.memory_format_opt());
    }
  }
}
)r)   r   r7   r%   r2   r2   r3   gen_resize_out_helper   s    rA   c                 C  s   dgS )Na  
void check_inplace(const Tensor &self, IntArrayRef sizes, const TensorOptions &options) {
  // These checks are needed on those operators that:
  //   1) don't use 'TensorIterator' (e.g. 'addmm' and 'baddbmm')
  //   2) have particular typing rules (e.g. 'cumsum' and 'cumprod')
  // For other operators (e.g. 'add'), 'TensorIterator' already checks
  // these things separately.
  TORCH_CHECK(options.dtype() == self.dtype(),
      "Bad in-place call: ",
      "input tensor dtype ", self.dtype(), " and output tensor dtype ", options.dtype(), " should match");
  TORCH_CHECK(options.device() == self.device(),
      "Bad in-place call: ",
      "input tensor device ", self.device(), " and output tensor device ", options.device(), " should match");
  TORCH_CHECK(sizes == self.sizes(),
      "Bad in-place call: ",
      "input tensor size ", self.sizes(), " and output tensor size ", sizes, " should match");
}
r2   r@   r2   r2   r3   gen_check_inplace_helper   s    rB   c                 C  s*   dgt | t| t| t| dS )Nz?C10_DIAGNOSTIC_PUSH_AND_IGNORED_IF_DEFINED("-Wunused-function")zC10_DIAGNOSTIC_POP())r=   rA   rB   r?   r@   r2   r2   r3   gen_registration_helpers   s    rC   T)frozenc                   @  s   e Zd ZU ded< ded< ded< ded< ded	< d
ed< ded< edddddddZedddddZdddddZddd
dddZ	d dd!d"d#Z
d'ddd
dd%d&Zd$S )(RegisterDispatchKeyr   r%   zvLiteral[Target.ANONYMOUS_DEFINITION, Target.NAMESPACED_DEFINITION, Target.NAMESPACED_DECLARATION, Target.REGISTRATION]targetr"   selectorr#   r'   symint
str | Noneclass_method_nameskip_dispatcher_op_registrationr   zlist[Argument]r5   )typeargsmethod_namer(   c              	   C  sR   | t jkrdS d}|d7 }|D ].}|j r|d|j d| d|j d7 }q|S )N  // No device check
z4std::optional<Device> common_device = std::nullopt;
z9(void)common_device; // Suppress unused variable warning
z<
  c10::impl::check_and_update_common_device(common_device, z, "z", "z");)r   ZNoCheckrL   is_tensor_likename)rL   rM   rN   device_checkargr2   r2   r3   gen_device_check  s    

z$RegisterDispatchKey.gen_device_checkz%NativeFunctionsGroup | NativeFunctionr$   fr(   c                   sn   t |tr<|  jr S tt fdd  S n.t |trb|}|d u r\g S |gS t	| d S )Nc                   s    |  S Ngen_unstructuredrV   gselfr2   r3   <lambda>*      z.RegisterDispatchKey.__call__.<locals>.<lambda>)

isinstancer   
structuredgen_structuredlistr    	functionsr   rY   r   )r]   rV   rr2   r[   r3   __call__   s    



zRegisterDispatchKey.__call__r   z%NativeSignature | DispatcherSignaturec                 C  s,   t j|jd| jj d|jjj d| jdS )Nwrapper_r>   prefixrH   )r   Zfrom_schemafuncr%   r)   rQ   Zoverload_namerH   )r]   rV   r2   r2   r3   wrapper_kernel_sig2  s
    z&RegisterDispatchKey.wrapper_kernel_sigzNativeFunctionsGroup | None)rV   r\   r(   c                   s  |d u rd S |j  }|tju r&d n|tju r6d ntd| |}| }| dt	|}t
|dkrd fddt|D }|   d	d
| d}nt
|dkr|d }	  d	 d
|	 d}|	}nnt
|j jjdksJ d}|j jjd }
|
j r4d d  d	 d|
j d	}n  d	 d
|
j d}| |j}| }|j|d d d|  d	d
dd t| | D  d| d| dS )Nzat::_copy_fromzat::_copy_from_and_resizez1gen_out_inplace_wrapper called on a functional opZ_tmp   z
  c              	   3  s.   | ]&\}}  d | d d| dV  qdS )z
(std::get<z>(z), );Nr2   ).0iret_nameZcopy_opZfunc_resr2   r3   	<genexpr>O  s   z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>(, )r   rm    z    for (int64_t i = 0; i < z.size(); ++i) {
        z[i], z[i]);
    }rQ   z
 {
  auto z = c                 s  s   | ]}|j V  qd S rW   exprrn   er2   r2   r3   rr   i  r_   z);
  

  return ;
}
)rj   kindr   inplaceoutAssertionErrorrk   rQ   cppreturn_nameslenjoin	enumeratereturns_typecpp_type	argumentsrL   Zis_list_like
functionaldefnr   )r]   rV   r\   ksigrQ   r   Zupdatesreturnsrp   out_argZfunctional_sigZwrapper_namer2   rq   r3   gen_out_inplace_wrapper<  sb    





 

 z+RegisterDispatchKey.gen_out_inplace_wrapperr   )r\   r(   c              	     s   j  }j jtjkr2j  jrJ dnPj jtjkrXj  jrJ dn*|d u sf|jst	t
 fdd  S tj jjjjjj }t	t
|j  S )NzqDo not explicitly specify Meta dispatch key on structured functions, they will be automatically generated for youzDo not explicitly specify CompositeExplicitAutograd dispatch key on structured functions, they will be automatically generated for youc                   s    |  S rW   rX   rZ   r[   r2   r3   r^     r_   z4RegisterDispatchKey.gen_structured.<locals>.<lambda>)r%   
get_kernelr)   r   r+   
has_kernelr   r7   ra   rc   r    rd   StructuredRegisterDispatchKeyrF   rG   r'   rH   rJ   rK   gen_one)r]   r\   metadataZstructured_genr2   r[   r3   rb   o  s2    
z"RegisterDispatchKey.gen_structuredNc                   s  t |v d}d}| j|s| jjtjkrZ|j tj	u rZ|j
sZt|jjdkrZd}n4| jjs~|d ur~t||| jr~d}nW d    d S |jrW d    d S | jtju r| j|sW d    d S | |   }   }  }ddd |D }tj|ddd}	| jtju rdd}
|	j| jd	D ]}|
d
|   d7 }
q6|
W  d    S | jtj!u rddd fdd}d}
|	j| jd	D ]}|
||7 }
q|
W  d    S | jtj"u r|r&|jjj#d usJ |jjj#j$j}d| d| d| d| d| dW  d    S |rF| %||W  d    S | j&|}|d u rlW d    d S | j'd u r|j( d|j) }n|j( d| j' d|j) }t*|| j}ddd t+  | ddD }d}| jj,rt-.|jjj/|jjj0}t12|j3t4||}d}|j,r| jj,rt5dd |jjj6D }|rdd}t7| jjrd| }nf|jjj#d ur|jjj#j$gng }t-.||jjj/|jjj0}t8dd |D d }|d urd | d!}d"| d| d| d#| d$| d%| d| d&W  d    S | jtju rh|js&| j9r6W d    d S d'| d(}d)|jj d*| d+W  d    S n
t:| j W d    n1 s0    Y  d S ),NFrl   Trt   c                 s  s   | ]}|  V  qd S rW   )r   rn   ar2   r2   r3   rr     r_   z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>methodZfallback_bindingrv   rH   
TORCH_API ;
r   r5   cpp_sigr(   c                   s>   d|    d   dddd t|    D  dS )N

 {
return rs   rt   c                 s  s   | ]}|j V  qd S rW   rx   rz   r2   r2   r3   rr     r_   zNRegisterDispatchKey.gen_unstructured.<locals>.generate_defn.<locals>.<genexpr>);
}
r   rQ   r   r   r   r   r   r2   r3   generate_defn  s     z;RegisterDispatchKey.gen_unstructured.<locals>.generate_defnr    rs   z") {
  TORCH_CHECK_NOT_IMPLEMENTED(z[.is_meta(),
    "Cannot inplace into non-meta tensor with meta tensor argument");
  return r}   z::c                 s  s   | ]}|j V  qd S rW   rx   rz   r2   r2   r3   rr     s   r   rO   z// DeviceGuard omittedc                 s  s   | ]}t |tV  qd S rW   )r`   r   r   r2   r2   r3   rr     s   z=
  const DeviceGuard device_guard(device_or_default(device));z7globalContext().lazyInitDevice(c10::DeviceType::CUDA);
c                 s  s    | ]}|j  r|j V  qd S rW   )rL   rP   rQ   r   r2   r2   r3   rr     s   
z1const OptionalDeviceGuard device_guard(device_of());znamespace {

z) {
  z

  r|   z);
}

} // anonymous namespace
z	TORCH_FN(ru   m.impl("z",
z);
);r   r%   r   r)   r   r+   rj   r~   r   r   Zhas_composite_kernelr   r   Zuse_out_as_primaryr   manual_kernel_registrationrF   r!   REGISTRATIONrG   is_native_function_selectedrk   rQ   r   r   r   r   r   from_native_functionNAMESPACED_DECLARATION
signaturesrH   declNAMESPACED_DEFINITIONANONYMOUS_DEFINITIONself_argargumentr   r   rJ   cpp_namespacekernelr   r   device_guard	itertoolschainr   flat_positionalrE   rT   rR   rc   anyZnon_outr   nextrK   r   )r]   rV   r\   Zinplace_metaZgets_out_inplace_wrapperrQ   r   rM   args_strcpp_sig_groupresultr   r   Zself_arg_namer   Z	impl_nameZ
kernel_sigZargs_exprs_strrR   device_check_argsr   Zhas_tensor_optionsr   Zcandidate_argsZ	device_ofpayloadr2   r   r3   rY     s   



	



&z$RegisterDispatchKey.gen_unstructured)N)__name__
__module____qualname____annotations__staticmethodrT   r   rf   rk   r   rb   rY   r2   r2   r2   r3   rE      s    
	
3 rE   c                   @  s|   e Zd ZU ded< dddddddZdddd	d
dZdddddddZdddddddddZedddddZ	dS )r   r   r\   r   r5   r#   )r   parent_classgenerate_superr(   c                   sP   |r| dnddddd fdd}d|d	d
d d|ddd dS )NzE::set_output_raw_strided(output_idx, sizes, strides, options, names);rv   r5   r#   )rQ   maybe_create_proxyr(   c              	     s0   d|  dt  |d dt d dS )Nz
void set_output_z|(
    int64_t output_idx, IntArrayRef sizes, IntArrayRef strides,
    TensorOptions options, DimnameList names
) override {
    z
    if (!names.empty()) {
      namedinference::propagate_names(outputs_[output_idx], names);
    }
    // super must happen after, so that downstream can use maybe_get_output
    // to retrieve the output

}
)textwrapindentgen_class_set_output_body)rQ   r   r   r]   Zset_output_superr2   r3   gen_set_output_functionQ  s    
z]StructuredRegisterDispatchKey.gen_class_set_output_functions.<locals>.gen_set_output_functionr   ZstridedT)r   Zraw_stridedFr2   )r]   r   r   r   r   r2   r   r3   gen_class_set_output_functionsI  s    

z<StructuredRegisterDispatchKey.gen_class_set_output_functions)r   r   r(   c                 C  s   | j jtjtjtjtjfv r*d}|d }nd }}|r<d}nd}|tju r| j jtj	tj
tjtjtjtjtjfv svJ | dS |tju r| d| S |tju r| d| S |tju s|tju rt| dnt| d S )	Na  
auto current_device = guard_.current_device();
if (C10_UNLIKELY(current_device.has_value())) {
  TORCH_INTERNAL_ASSERT(*current_device == options.device(),
    "structured kernels don't support multi-device outputs");
} else {
  guard_.reset_device(options.device());
}
r   rv   z
auto maybe_proxy = maybe_create_proxy(out, sizes, strides, options);
if (C10_UNLIKELY(maybe_proxy.has_value())) {
    proxy_outputs_[output_idx] = std::move(maybe_proxy).value();
}
z<
outputs_[output_idx] = create_out(sizes, strides, options);zS
const auto& out = outputs_[output_idx].get();
check_inplace(out, sizes, options);
zY
const auto& out = outputs_[output_idx].get();
resize_out(out, sizes, strides, options);
1 structured operators are currently not supported)r%   r)   r   r-   r.   r/   r7   r   r   r+   r*   r0   r   r   mutablescratchr   r   )r]   r   r   Zmaybe_set_guardZmaybe_set_guard_lineZcreate_proxyr2   r2   r3   r   f  sH    	


	


z7StructuredRegisterDispatchKey.gen_class_set_output_bodyint)r   
class_namer   r(   c                 C  s   |t ju rdS |t ju r"| dS |t ju rrddd t|D }ddd t|D }| d| d| d	S |t ju s|t ju rt| d
nt	| d S )Nrv   z,(Tensor& self) : outputs_{std::ref(self)} {}rt   c                 s  s   | ]}d | V  qdS )zTensor& outNr2   rn   ro   r2   r2   r3   rr     r_   z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>c                 s  s   | ]}d | dV  qdS )zstd::ref(outru   Nr2   r   r2   r2   r3   rr     r_   rs   z) : outputs_{ z } {}r   )
r   r   r   r   r   ranger   r   r   r   )r]   r   r   r   out_argsZout_refsr2   r2   r3   gen_class_ctor  s    



z,StructuredRegisterDispatchKey.gen_class_ctorr   )rV   r   r   r   r   r(   c                C  s  |t ju rd}d}d}n^|t ju r@d}d}dt|jj d}n6|t ju rhd}d}dt|jj d}ntd| | jj	t
jkr| jrd	}	qd
}	nT| jj	t
jkrd}	n@| jj	t
jkrd}	n,| jj	t
jkrd}	n| jj	t
jkrd}	nd}	d}
| ||t|jj}d| d| dt||
 t| ||||
 dd| ddd| dt|jj dt||
 t|	|
 df
}ddd |D S )NZTensorzoutputs_[output_idx]rv   zstd::reference_wrapper<Tensor>zaproxy_outputs_[output_idx].has_value() ? *proxy_outputs_[output_idx] : outputs_[output_idx].get()z$std::array<::std::optional<Tensor>, z> proxy_outputs_;zUnsupported SchemaKind z4c10::hip::OptionalHIPGuardMasqueradingAsCUDA guard_;z$c10::cuda::OptionalCUDAGuard guard_;z c10::OptionalDeviceGuard guard_;r   zstruct z final : public z {zA    const Tensor& maybe_get_output(int64_t output_idx) override {z      return r   z    }z    std::array<rt   z> outputs_;z};r   c                 s  s   | ]}|r|V  qd S rW   r2   )rn   liner2   r2   r3   rr     r_   z:StructuredRegisterDispatchKey.gen_class.<locals>.<genexpr>)r   r   r   r   rj   r   r   RuntimeErrorr%   r)   r   r-   r'   r7   r.   r/   r0   r   r   r   r   r   )r]   rV   r   r   r   r   output_typeZoutput_valueZproxy_fieldZguard_fieldr   Zclass_ctor_strlinesr2   r2   r3   	gen_class  sV    	



z'StructuredRegisterDispatchKey.gen_classrI   rU   c              
     s$  |j r
J | jtju r&| j|s&d S | jjtj	krH|j
 tju rHd S tj|ddd}| j|}t|j
d| jj d|d uo| d | jtju rd}|j| jdD ]}|d|  d	7 }q|S | jtju rd
dd fdd}d}|j| jdD ]}|||7 } q|S | jtju r|j
 }g }t  }	| jjtju rzdt| j d|j }
dt| j }n| jjtj	u rdt| j d|j }
dt| j }nB| j| j}|d usJ d|j d|j }
|j  d|j }| jj!r:t"#|j
jj|j
jj$}|%t&'|j(t|   |tj)u rX|%|
 d nZ|tj*u rv|%|
 d n<|tju rd+dd |j
jjD }|%|
 d| d d+dd t,|	t-.| jddD }| jjj/rB|%d| d g | jjj/j01 | jjj/j2}|D ]}|	3dd |D  q|%d n|%d | d t-4| j}t5|D ]n\}}t6t7t8|j9j:ksJ |tju rd!| d"}nd#| d$}|	%t;|t<|j9jt=t7t8d% qh| jjtj	krJtj| jjd|j>d}|? }| }d+d&d t,|	| ddD }|%d'| d(| d nH| jjtjkrd+d)d t,|	t-@| jddD }|%d*| d |tju s|tj*u rtAtB|j
jCD ]$}|%d+| d,| d-| d. q|tj)u r2tB|j
jCd/krd0}n,d+d1d tAtB|j
jCD }d2| d"}nh|tj*u rDd3}nV|tju rtB|j
jCd/krt|j
jjd4 j}n&d+d5d |j
jjD }d6| d"}|%d7| d8 d9+|}| jD|||
|| jjjEd ud: d; F  d<| d=S | jtju rd>|j
j d?   d@S tG| j d S d S )ANFr   rg   r>   rh   rv   r   r   r   r   r5   r   c                   s>   d|    d   dddd t|    D  dS )Nr   r   rs   rt   c                 s  s   | ]}|j V  qd S rW   rx   rz   r2   r2   r3   rr   ,  r_   zOStructuredRegisterDispatchKey.gen_one.<locals>.generate_defn.<locals>.<genexpr>r   r   r   r   r2   r3   r   )  s     z<StructuredRegisterDispatchKey.gen_one.<locals>.generate_defnZstructured_Z_meta_zat::meta::structured_Z_default_backend_z::structured_z op;z
 op(self);rt   c                 s  s   | ]}|j V  qd S rW   rw   r   r2   r2   r3   rr   _  r_   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>z op(rm   c                 s  s   | ]}|j V  qd S rW   rx   rz   r2   r2   r3   rr   d  s   r   zauto precompute = op.meta(c                 s  s.   | ]&}t d |j tj||jddV  qdS )zprecompute.)Zbindsry   rL   N)r   rQ   ra   Zargument_type)rn   rS   r2   r2   r3   rr   y  s
   
z(void)precompute;zop.meta(zop.maybe_get_output(ru   zop.outputs_[]r   c                 s  s   | ]}|j V  qd S rW   rx   rz   r2   r2   r3   rr     s   zat::rs   c                 s  s   | ]}|j V  qd S rW   rx   rz   r2   r2   r3   rr     s   zop.impl(zif (op.proxy_outputs_[z].has_value()) op.outputs_[z!].get().copy_(*op.proxy_outputs_[z]);rl   zstd::move(op.outputs_[0])c                 s  s   | ]}d | dV  qdS )zstd::move(op.outputs_[z])Nr2   r   r2   r2   r3   rr     s   zstd::make_tuple(r]   r   c                 s  s   | ]}|j V  qd S rW   rw   r   r2   r2   r3   rr     r_   zstd::forward_as_tuple(zreturn ;r   )r   r   r   z

z {
r   r   z", TORCH_FN(r   )Hr   rF   r!   r   rG   r   r%   r)   r   r7   rj   r~   r   r   r   r   r   r   Zsupports_symintr   r   rH   r   r   r   rc   r   r+   metarQ   r\   r   r   r   r   r   r   r,   rE   rT   rR   r   r   r   r   ra   Zmeta_argumentsZprecomputedreplacevaluesaddextendZout_argumentsr   r
   r   r   ZnctyperL   r   r   r   Zmanual_cpp_bindingZmost_faithful_signatureZimpl_argumentsr   r   r   r   Zstructured_inheritsr   r   )r]   rV   r   kernr   r   r   r   Zsig_bodycontextr   r   r   r   Zout_args_strZ
meta_exprsZprecomputed_valuesZprecomputed_elemsr   ro   r   ry   Zout_sig_groupZout_sigZapi_nameZ	out_exprsZ
impl_exprsZret_exprmovedrefsZsig_body_strr2   r   r3   r     s6   













z%StructuredRegisterDispatchKey.gen_oneN)
r   r   r   r   r   r   r   r   r   r   r2   r2   r2   r3   r   E  s   
==r   )=
__future__r   r   r   Zdataclassesr   typingr   r   Ztyping_extensionsr   Ztorchgen.api.cppapir   Ztorchgen.api.metar   Ztorchgen.api.structuredra   Ztorchgen.api.translater   Ztorchgen.api.typesr   r	   r
   r   r   r   r   r   r   r   r   r   Ztorchgen.contextr   r   Ztorchgen.modelr   r   r   r   r   r   r   r   r   r   Ztorchgen.utilsr    r!   Z!torchgen.selective_build.selectorr"   r4   r;   r=   r?   rA   rB   rC   rE   r   r2   r2   r2   r3   <module>   s8   80&  Y