o
    0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
  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-m.Z.m/Z/m0Z0 erd d
l1m2Z2 d'ddZ3d(ddZ4d)ddZ5d)ddZ6d)ddZ7d)ddZ8d)dd Z9ed!d"G d#d$ d$Z:ed!d"G d%d& d&e:Z;dS )*    )annotationsN)	dataclass)LiteralTYPE_CHECKING)	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)assert_nevermapMaybeTarget)SelectiveBuilderbackend_indexr   per_operator_headersboolrocmreturn	list[str]c                 C  s   |rdg}ndg}| j tjtjfv r|d n:| j tjkr,|r&|d n,|d n&| j tjkr8|d n| j tjkrD|d n|rM|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/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)r#   r$   r&   headers r1   W/var/www/vscode/kcb/lib/python3.10/site-packages/torchgen/dest/register_dispatch_key.pygen_registration_headers.   s$   

r3   tuple[str | None, str | None]c                 C  sz   d }d }| j tjtjtjtjtjfv r(t| j  }d| }d| }||fS | j tj	tj
tjtjfv r9d}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/   strlower&CompositeExplicitAutogradNonFunctionalQuantizedCPUQuantizedCUDA)r#   
empty_implempty_strided_impldispatchr1   r1   r2   gen_empty_impl_namesR   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#   empty_optionsr:   r;   r1   r1   r2   gen_create_out_helpern   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#   _r;   r1   r1   r2   gen_maybe_create_proxy_helper   s   rB   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#   r1   r1   r2   gen_resize_out_helper   s   rD   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");
}
r1   rC   r1   r1   r2   gen_check_inplace_helper   s   rE   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@   rD   rE   rB   rC   r1   r1   r2   gen_registration_helpers   s   rF   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Zed*ddZd+ddZd,d!d"Z	d-d$d%Z
	&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_registrationtyper   argslist[Argument]method_namer5   r'   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   NoCheckrO   is_tensor_likename)rO   rP   rR   device_checkargr1   r1   r2   gen_device_check  s   


z$RegisterDispatchKey.gen_device_checkf%NativeFunctionsGroup | NativeFunctionr(   c                   sl   t |tr|  jr S tt fdd  S t |tr0|}|d u r-g S |gS t	| d S )Nc                       |  S Ngen_unstructuredrZ   gselfr1   r2   <lambda>&      z.RegisterDispatchKey.__call__.<locals>.<lambda>)

isinstancer   
structuredgen_structuredlistr    	functionsr   r_   r   )rc   rZ   rr1   ra   r2   __call__  s   



zRegisterDispatchKey.__call__r   %NativeSignature | DispatcherSignaturec                 C  s,   t j|jd| jj d|jjj d| jdS )Nwrapper_rA   prefixrK   )r   from_schemafuncr#   r)   rV   overload_namerK   )rc   rZ   r1   r1   r2   wrapper_kernel_sig.  s
   z&RegisterDispatchKey.wrapper_kernel_sigrb   NativeFunctionsGroup | Nonec                   s  |d u rd S |j  }|tju rd n|tju rd ntd| |}| }| dt	|}t
|dkrWd fddt|D }|   d	d
| d}nNt
|dkro|d }	  d	 d
|	 d}|	}n6t
|j jjdkszJ d}|j jjd }
|
j rd 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 op_tmp   z
  c              	   3  s0    | ]\}}  d | d d| dV  qdS )z
(std::get<z>(z), );Nr1   ).0iret_namecopy_opfunc_resr1   r2   	<genexpr>K  s
    
z>RegisterDispatchKey.gen_out_inplace_wrapper.<locals>.<genexpr>(, )r   rx    z    for (int64_t i = 0; i < z.size(); ++i) {
        z[i], z[i]);
    }rV   z
 {
  auto z = c                 s      | ]}|j V  qd S r]   exprry   er1   r1   r2   r   e      z);
  

  return ;
}
)rr   kindr   inplaceoutAssertionErrorrt   rV   cppreturn_nameslenjoin	enumeratereturns_typecpp_type	argumentsrO   is_list_like
functionaldefnr   )rc   rZ   rb   ksigrV   r   updatesreturnsr{   out_argfunctional_sigwrapper_namer1   r|   r2   gen_out_inplace_wrapper8  sb   





 


 z+RegisterDispatchKey.gen_out_inplace_wrapperr   c              	     s   j  }j jtjkrj  jrJ dn(j jtjkr,j  jr+J dn|d u s3|jsAt	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                   r\   r]   r^   r`   ra   r1   r2   rd   {  re   z4RegisterDispatchKey.gen_structured.<locals>.<lambda>)r#   
get_kernelr)   r   r+   
has_kernelr   r7   rg   ri   r    rj   StructuredRegisterDispatchKeyrI   rJ   r&   rK   rM   rN   gen_one)rc   rb   metadatastructured_genr1   ra   r2   rh   k  s0   
z"RegisterDispatchKey.gen_structuredNc                   s  t |8 d}d}| j|sH| jjtjkr-|j tj	u r-|j
s-t|jjdkr-d}n| jjs?|d ur?t||| jr?d}n		 W d    d S |jrT	 W d    d S | jtju ri| j|si	 W d    d S | |   }   }  }ddd |D }tj|ddd}	| jtju rd}
|	j| jd	D ]}|
d
|   d7 }
q|
W  d    S | jtj!u rd- 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 |r| %||W  d    S | j&|}|d u r2	 W d    d S | j'd u rB|j( d|j) }n|j( d| j' d|j) }t*|| j}ddd t+  | ddD }d}| jj,rt-.|jjj/|jjj0}t12|j3t4||}d}|j,r| jj,rt5dd |jjj6D }|rd}t7| jjrd| }n3|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 r0|js| j9r	 W d    d S d(| d)}d*|jj d+| d,W  d    S t:| j W d    d S 1 sAw   Y  d S ).NFrw   Tr   c                 s  s    | ]}|  V  qd S r]   )r   ry   ar1   r1   r2   r         z7RegisterDispatchKey.gen_unstructured.<locals>.<genexpr>methodfallback_bindingr   rK   
TORCH_API ;
cpp_sigr
   r'   r5   c                   >   d|    d   dddd t|    D  dS )N

 {
return r   r   c                 s  r   r]   r   r   r1   r1   r2   r     r   zNRegisterDispatchKey.gen_unstructured.<locals>.generate_defn.<locals>.<genexpr>);
}
r   rV   r   r   r   r   r   r1   r2   generate_defn      z;RegisterDispatchKey.gen_unstructured.<locals>.generate_defnr    r   z") {
  TORCH_CHECK_NOT_IMPLEMENTED(z[.is_meta(),
    "Cannot inplace into non-meta tensor with meta tensor argument");
  return r   z::c                 s  r   r]   r   r   r1   r1   r2   r     
    
r   rS   z// DeviceGuard omittedc                 s  s    | ]}t |tV  qd S r]   )rf   r   r   r1   r1   r2   r     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 r]   )rO   rU   rV   r   r1   r1   r2   r     s    
z1const OptionalDeviceGuard device_guard(device_of());znamespace {

z) {
  z

  r   z);
}

} // anonymous namespace
z	TORCH_FN(r   m.impl("z",
z);
r   r
   r'   r5   );r   r#   r   r)   r   r+   rr   r   r   r   has_composite_kernelr   r   use_out_as_primaryr   manual_kernel_registrationrI   r!   REGISTRATIONrJ   is_native_function_selectedrt   rV   r   r   r   r   r   from_native_functionNAMESPACED_DECLARATION
signaturesrK   declNAMESPACED_DEFINITIONANONYMOUS_DEFINITIONself_argargumentr   r   rM   cpp_namespacekernelr   r   device_guard	itertoolschainr   flat_positionalrH   rY   rW   ri   anynon_outr   nextrN   r   )rc   rZ   rb   inplace_metagets_out_inplace_wrapperrV   r   rP   args_strcpp_sig_groupresultr   r   self_arg_namer   	impl_name
kernel_sigargs_exprs_strrW   device_check_argsr   has_tensor_optionsr   candidate_args	device_ofpayloadr1   r   r2   r_     s$  

!3AP
S
V



  &  *  - $z$RegisterDispatchKey.gen_unstructured)rO   r   rP   rQ   rR   r5   r'   r5   )rZ   r[   r'   r(   )rZ   r   r'   rm   )rZ   r   rb   ru   r'   rL   )rb   r   r'   r(   r]   )__name__
__module____qualname____annotations__staticmethodrY   r   rl   rt   r   rh   r_   r1   r1   r1   r2   rH      s"   
 	



3rH   c                   @  sL   e Zd ZU ded< dd
dZdddZdddZdddZed ddZ	dS )!r   r   rb   r   r   parent_classr5   generate_superr%   r'   c                   sH   |r| dn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);r   rV   r5   maybe_create_proxyr%   r'   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)rV   r   r   rc   set_output_superr1   r2   gen_set_output_functionM  s   
z]StructuredRegisterDispatchKey.gen_class_set_output_functions.<locals>.gen_set_output_functionr   stridedT)r   raw_stridedF)rV   r5   r   r%   r'   r5   r1   )rc   r   r   r   r   r1   r   r2   gen_class_set_output_functionsE  s   

z<StructuredRegisterDispatchKey.gen_class_set_output_functionsr   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fv s9J | dS |tju rJ| d| S |tju rV| d| S |tju s`|tju rgt| d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   r   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*   r   r   mutablescratchr   r   )rc   r   r   maybe_set_guardmaybe_set_guard_linecreate_proxyr1   r1   r2   r   b  sF   
	




z7StructuredRegisterDispatchKey.gen_class_set_output_body
class_namer   intc                 C  s   |t ju rdS |t ju r| dS |t ju r9ddd t|D }ddd t|D }| d| d| d	S |t ju sC|t ju rJt| d
t	| d S )Nr   z,(Tensor& self) : outputs_{std::ref(self)} {}r   c                 s  s    | ]}d | V  qdS )zTensor& outNr1   ry   rz   r1   r1   r2   r     s    z?StructuredRegisterDispatchKey.gen_class_ctor.<locals>.<genexpr>c                 s      | ]	}d | dV  qdS )zstd::ref(outr   Nr1   r  r1   r1   r2   r     s    r   z) : outputs_{ z } {}r   )
r   r   r   r   r   ranger   r   r   r   )rc   r   r   r   out_argsout_refsr1   r1   r2   gen_class_ctor  s   



z,StructuredRegisterDispatchKey.gen_class_ctorrZ   r   c                C  sz  |t ju rd}d}d}n/|t ju r d}d}dt|jj d}n|t ju r4d}d}dt|jj d}ntd| | jj	t
jkrK| jrHd	}	n#d
}	n | jj	t
jkrUd}	n| jj	t
jkr_d}	n| jj	t
jkrid}	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 )NTensorzoutputs_[output_idx]r   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<r   z> outputs_;z};r   c                 s  s    | ]}|r|V  qd S r]   r1   )ry   liner1   r1   r2   r     r   z:StructuredRegisterDispatchKey.gen_class.<locals>.<genexpr>)r   r   r   r   rr   r   r   RuntimeErrorr#   r)   r   r-   r&   r7   r.   r/   r  r   r   r   r   )rc   rZ   r   r   r   r   output_typeoutput_valueproxy_fieldguard_fieldr   class_ctor_strlinesr1   r1   r2   	gen_class  sP   
	


z'StructuredRegisterDispatchKey.gen_classrL   c              
     s  |j rJ | jtju r| j|sd S | jjtj	kr$|j
 tju r$d S tj|ddd}| j|}t|j
d| jj d|d uoC| d | jtju rdd}|j| jdD ]}|d|  d	7 }qU|S | jtju rdB fdd}d}|j| jdD ]}|||7 }qz|S | jtju r|j
 }g }t  }	| jjtju rdt| j d|j }
dt| j }n>| jjtj	u rdt| j d|j }
dt| j }n | 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 r$|%|
 d n-|tj*u r3|%|
 d n|tju rQd+dd |j
jjD }|%|
 d| d d+dd t,|	t-.| jddD }| jjj/r|%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 ]7\}}t6t7t8|j9j:ksJ |tju rd"| d#}nd$| d%}|	%t;|t<|j9jt=t7t8d& q| jjtj	krtj| jjd|j>d}|? }| }d+d'd t,|	| ddD }|%d(| d)| d n$| jjtjkrAd+d*d t,|	t-@| jddD }|%d+| d |tju sM|tj*u rhtAtB|j
jCD ]}|%d,| d-| d.| d/ qU|tj)u rtB|j
jCd0krzd1}nKd+d2d tAtB|j
jCD }d3| d#}n4|tj*u rd4}n+|tju rtB|j
jCd0kr|j
jjd5 j}nd+d6d |j
jjD }d7| d#}|%d8| d9 d:+|}| jD|||
|| jjjEd ud; d< F  d=| d>S | jtju rd?|j
j d@   dAS tG| j d S )CNFr   rn   rA   ro   r   r   r   r   r   r
   r'   r5   c                   r   )Nr   r   r   r   c                 s  r   r]   r   r   r1   r1   r2   r   %  r   zOStructuredRegisterDispatchKey.gen_one.<locals>.generate_defn.<locals>.<genexpr>r   r   r   r   r1   r2   r   "  r   z<StructuredRegisterDispatchKey.gen_one.<locals>.generate_defnstructured__meta_zat::meta::structured__default_backend_z::structured_z op;z
 op(self);r   c                 s  r   r]   r   r   r1   r1   r2   r   X  r   z8StructuredRegisterDispatchKey.gen_one.<locals>.<genexpr>z op(rx   c                 s  r   r]   r   r   r1   r1   r2   r   ]  r   r   zauto precompute = op.meta(c                 s  s0    | ]}t d |j tj||jddV  qdS )zprecompute.)bindsr   rO   N)r   rV   rg   argument_type)ry   rX   r1   r1   r2   r   r  s    

z(void)precompute;zop.meta(zop.maybe_get_output(r   zop.outputs_[]r  c                 s  r   r]   r   r   r1   r1   r2   r     r   zat::r   c                 s  r   r]   r   r   r1   r1   r2   r     r   zop.impl(zif (op.proxy_outputs_[z].has_value()) op.outputs_[z!].get().copy_(*op.proxy_outputs_[z]);rw   zstd::move(op.outputs_[0])c                 s  r  )zstd::move(op.outputs_[z])Nr1   r  r1   r1   r2   r     s
    

zstd::make_tuple(rc   r   c                 s  r   r]   r   r   r1   r1   r2   r     r   zstd::forward_as_tuple(zreturn ;r   )r   r   r   z

z {
r   r   z", TORCH_FN(r   r   )Hr   rI   r!   r   rJ   r   r#   r)   r   r7   rr   r   r   r   r   r   r   r   supports_symintr   r   rK   r   r   r   ri   r   r+   metarV   rb   r   r   r   r   r   r   r,   rH   rY   rW   r   r   r   r   rg   meta_argumentsprecomputedreplacevaluesaddextendout_argumentsr   r	   r   r   nctyperO   r   r   r   manual_cpp_bindingmost_faithful_signatureimpl_argumentsr  r   r   r  structured_inheritsr   r   )rc   rZ   r   kernr   r   r   r   sig_bodycontextr   r   r   r   out_args_str
meta_exprsprecomputed_valuesprecomputed_elemsr  rz   r   r   out_sig_groupout_sigapi_name	out_exprs
impl_exprsret_exprmovedrefssig_body_strr1   r   r2   r     s,  












z%StructuredRegisterDispatchKey.gen_oneN)r   r   r   r5   r   r%   r'   r5   )r   r   r   r%   r'   r5   )r   r   r   r5   r   r  r'   r5   )rZ   r   r   r   r   r5   r   r5   r   r%   r'   r5   )rZ   r   r'   rL   )
r   r   r   r   r   r   r  r  r   r   r1   r1   r1   r2   r   A  s   
 


<
;r   )r#   r   r$   r%   r&   r%   r'   r(   )r#   r   r'   r4   )r#   r   r'   r(   )<
__future__r   r   r   dataclassesr   typingr   r   torchgen.api.cppapir   torchgen.api.metar  torchgen.api.structuredrg   torchgen.api.translater   torchgen.api.typesr   r   r	   r
   r   r   r   r   r   r   r   r   torchgen.contextr   r   torchgen.modelr   r   r   r   r   r   r   r   r   r   torchgen.utilsr   r    r!   !torchgen.selective_build.selectorr"   r3   r=   r@   rB   rD   rE   rF   rH   r   r1   r1   r1   r2   <module>   s8    80

$




  Y