o
    vZh                     @  sH  d dl mZ d dlmZ d dlmZmZmZ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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" d dl#m$Z$m%Z% d dl&m'Z' dd	l(m)Z) erld d
l*m+Z+ e"dZ,e"dZ-e"dZ.e"dZ/e"dZ0e"dZ1e"dZ2e"dZ3e"dZ4e"dZ5e"dZ6e"dZ7e"dZ8e"dZ9e"dZ:e"dZ;e"dZ<e"dZ=e"dZ>e"dZ?dZ@d ZAd!ZBd"ZCd#ZDd$ZEd%ZFd&ZGd'ZHd(ZId)ZJd*ZKd+ZLd,ZMeeee>eGfeeee>eHfeee9eIfeeee>eIfeee9eJfeee9eLfeeee>eLfiZNe)ZOdBd1d2ZPdCd7d8ZQdCd9d:ZRdDd?d@ZSdAS )E    )annotations)TYPE_CHECKING)
DerivativeDifferentiabilityInfoSavedAttributeuses_retain_variablesuses_single_grad)ArrayRefCTypeBaseCppType	BaseCTypeBindingboolTdoubleTintArrayRefTiTensorListRefT	ListCTypelongTMutRefCTypeOptionalCTypeoptionalIntArrayRefToptionalSymIntArrayRefTscalarTstringTsymIntArrayRefTSymIntTTENSOR_LIST_LIKE_CTYPEStensorListTtensorTVectorCType)CodeTemplate)ArgumentFunctionSchema)FileManager   )VIEW_FUNCTIONS)Sequenceae  #ifdef _WIN32
struct ${op} : public ${superclass} {
  TORCH_API ${op}() = default;
#else
struct TORCH_API ${op} : public ${superclass} {
#endif
  using ${superclass}::${superclass};
  variable_list apply(variable_list&& grads) override;
  std::string name() const override { return "${op}"; }
  void release_variables() override {
    ${thread_lock}
    ${release_variables}
  }
  ${will_release_variables}
  void compiled_args(CompiledNodeArgs& args) const override;
  variable_list apply_with_saved(const variable_list& inputs, SwapSavedVariables& saved) override;
  ${saved_variables}
  ${saved_list_sizes}
};
zebool retain_variables = true;
void will_release_variables() override {
  retain_variables = false;
}
a^  static variable_list ${op}_apply_functional(
  variable_list&& grads,
  std::array<bool,${num_inputs}> needs_input_grad${,apply_functional_args_signature})
{
  IndexRangeGenerator gen;
  ${compute_index_ranges}
  variable_list grad_inputs(gen.size());
  ${body}
  return grad_inputs;
}
inline variable_list ${op}_apply_functional_ivalue(const variable_list& grads, const ivalue_list& args)
{
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  auto packed_args = PackedArgs(args);
  auto needs_input_grad = packed_args.unpack<std::array<bool, ${num_inputs}>>();
  ${unpack_ivalues}
  return ${op}_apply_functional(variable_list(grads), needs_input_grad${,apply_functional_args});
#endif
}

variable_list ${op}::apply(variable_list&& grads) {
  ${thread_lock}
  ${asserts}
  ${unpacks}
  ${compute_needs_input_grad}
  return ${op}_apply_functional(std::move(grads), needs_input_grad${,apply_functional_args});
}

void ${op}::compiled_args(CompiledNodeArgs& args) const {
    ${compiled_args}
}
variable_list ${op}::apply_with_saved(const variable_list& grads, SwapSavedVariables& saved) {
#ifdef C10_MOBILE
  TORCH_INTERNAL_ASSERT(false, "compiled autograd doesn't work on mobile");
#else
  ${apply_with_saved_before}

  static bool called = false;
  if (!called) {
    called = true;
    ${compute_schema}
    const auto& pyinterface = torch::dynamo::autograd::getPyCompilerInterface();
    pyinterface->bind_function(saved.get_py_compiler(), name(), ${op}_apply_functional_ivalue, schema);
  }

  variable_list output_result;

  PackedArgs packed_args;
  ${asserts}
  ${unpacks}
  ${compute_needs_input_grad}
  packed_args.pack(needs_input_grad);
  ${get_packed_args}

  output_result = compiled_autograd_apply_functional(packed_args, next_edges(), saved, grads, name());

  ${apply_with_saved_after}
  return output_result;
#endif
}

zC  auto grad_input_mask = std::array<bool, ${n}>{
    ${masks}
  };
znIndexRangeGenerator gen;
${compute_index_ranges}
auto needs_input_grad = std::array<bool, ${n}>{
  ${masks}
};zif (needs_input_grad[/*${name}*/${idx}]) {
  auto grad_result = ${derivative};
  copy_range(grad_inputs, ${name}_ix, grad_result);
}
ax  if (needs_input_grad[/*${name}*/${idx}]) {  // ${name}
  std::vector<Tensor> grad_result;
  grad_result.reserve(grads.size());
  for (const auto & i : c10::irange(grads.size())) {
    if (grads[i].defined()) {
      grad_result.emplace_back(${derivative});
    } else {
      grad_result.emplace_back(Tensor());
    }
  }
  copy_range(grad_inputs, ${name}_ix, grad_result);
}
zw  if (needs_input_grad[/*${name}*/${idx}]) {
    copy_range(grad_inputs, ${name}_ix, std::get<${i}>(grad_result));
  }
zgif (${needs_input_grad}) {
  ${grad_input_mask}
  auto grad_result = ${derivative};
  ${copy_ranges}
}
z`static PyTypeObject ${op}Class;
addClass<${op}>(module, ${op}Class, "${op}", ${op}_properties);
z${all_getter_definitions}

static struct PyGetSetDef ${op}_properties[] = {
  THP_FUNCTION_DEFAULT_PROPERTIES,
  ${all_getsetdef_structs}
  {nullptr} /* sentinel */
};

zU{(char*)"_saved_${name}", (getter)THP${op}_${name}_getter, nullptr, nullptr, nullptr}z]{(char*)"_raw_saved_${name}", (getter)THP${op}_${name}_raw_getter, nullptr, nullptr, nullptr}zPyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  auto prop = static_cast<${op}*>(self->cdata.get())->${name};
  ${body}
  END_HANDLE_TH_ERRORS
}
zPyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto& prop = static_cast<${op}*>(self->cdata.get())->${name}_;
  ${body}
  END_HANDLE_TH_ERRORS
}
zPyObject* THP${op}_${name}_raw_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto& prop = static_cast<${op}*>(self->cdata.get())->${name}_;
  ${body}
  END_HANDLE_TH_ERRORS
}
aW  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto *node = static_cast<${op}*>(self->cdata.get());
  const auto& prop = node->${name}_;
  if (node->${name}_released_) {
    PyErr_SetString(PyExc_RuntimeError, ERR_BACKWARD_TWICE);
    return nullptr;
  }
  ${body}
  END_HANDLE_TH_ERRORS
}
a[  PyObject* THP${op}_${name}_raw_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto *node = static_cast<${op}*>(self->cdata.get());
  const auto& prop = node->${name}_;
  if (node->${name}_released_) {
    PyErr_SetString(PyExc_RuntimeError, ERR_BACKWARD_TWICE);
    return nullptr;
  }
  ${body}
  END_HANDLE_TH_ERRORS
}
a  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  auto opt_prop = static_cast<${op}*>(self->cdata.get())->${name};
  if (!opt_prop.has_value()) {
    Py_RETURN_NONE;
  }
  auto prop = opt_prop.value();
  ${body}
  END_HANDLE_TH_ERRORS
}
a#  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  auto opt_prop = static_cast<${op}*>(self->cdata.get())->${name};
  if (!opt_prop.list.has_value()) {
    Py_RETURN_NONE;
  }
  auto prop = opt_prop.list.value();
  ${body}
  END_HANDLE_TH_ERRORS
}
z3return THPVariable_Wrap(prop.unpack(self->cdata));
zspybind11::object obj = pybind11::cast(prop, pybind11::return_value_policy::reference);
return obj.release().ptr();
zPyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i: c10::irange(prop.size())) {
  PyTuple_SetItem(tup, (Py_ssize_t) i, THPVariable_Wrap(prop[i].unpack(self->cdata)));
}
return tup;
a  PyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
  pybind11::object obj = pybind11::cast(prop[i], pybind11::return_value_policy::reference);
  PyTuple_SetItem(tup, (Py_ssize_t) i, obj.release().ptr());
}
return tup;
zPyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
  PyTuple_SetItem(tup, (Py_ssize_t) i, PyLong_FromUnsignedLong((uint64_t) prop[i]));
}
return tup;
at  PyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
    auto si = prop[i];
    if (auto m = si.maybe_as_int()) {
      PyTuple_SetItem(tup, (Py_ssize_t) i, PyLong_FromUnsignedLong(*m));
    } else {
      auto py_symint = py::cast(si).release().ptr();
      PyTuple_SetItem(tup, (Py_ssize_t) i, py_symint);
    }
}
return tup;
zPyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i : c10::irange(prop.size())) {
  PyTuple_SetItem(tup, (Py_ssize_t) i, PyFloat_FromDouble((double) prop[i]));
}
return tup;
z0return PyLong_FromUnsignedLong((int64_t) prop);
z~if (auto m = prop.maybe_as_int()) {
  return PyLong_FromUnsignedLong(*m);
} else {
  return py::cast(prop).release().ptr();
}
z*return PyFloat_FromDouble((double) prop);
z<if (prop) {
  Py_RETURN_TRUE;
} else {
  Py_RETURN_FALSE;
}
z>return PyUnicode_FromStringAndSize(prop.data(), prop.size());
a  if (prop.isComplex()) {
  auto cprop = prop.to<c10::complex<double>>();
  return PyComplex_FromDoubles(cprop.real(), cprop.imag());
} else if (prop.isFloatingPoint()) {
  return PyFloat_FromDouble(prop.to<double>());
} else if (prop.isIntegral(/*includeBool=*/false)) {
  return PyLong_FromLong(prop.to<int64_t>());
} else if (prop.isBoolean()) {
  if (prop.to<bool>()) {
    Py_RETURN_TRUE;
  } else {
    Py_RETURN_FALSE;
  }
} else {
  PyErr_SetString(PyExc_RuntimeError, "Unknown scalar type");
  return nullptr;
}
a  PyObject* tup = PyTuple_New((Py_ssize_t) prop.size());
for (auto i: c10::irange(prop.size())) {
  if (prop[i].isComplex()) {
    auto cprop = prop[i].to<c10::complex<double>>();
    PyTuple_SetItem(tup, (Py_ssize_t) i, PyComplex_FromDoubles(cprop.real(), cprop.imag()));
  } else if (prop[i].isFloatingPoint()) {
    auto double_prop = prop[i].to<double>();
    PyTuple_SetItem(tup, (Py_ssize_t) i, PyFloat_FromDouble(double_prop));
  } else if (prop[i].isIntegral(/*includeBool=*/false)) {
    auto long_prop = prop[i].to<int64_t>();
    PyTuple_SetItem(tup, (Py_ssize_t) i, PyLong_FromLong(long_prop));
  } else if (prop[i].isBoolean()) {
    if (prop[i].to<bool>()) {
      PyTuple_SetItem(tup, (Py_ssize_t) i, Py_True);
    } else {
      PyTuple_SetItem(tup, (Py_ssize_t) i, Py_False);
    }
  } else {
    PyErr_SetString(PyExc_RuntimeError, "Unknown scalar type");
    return nullptr;
  }
}
return tup;
differentiability_infos6dict[FunctionSchema, dict[str, DifferentiabilityInfo]]returnlist[DifferentiabilityInfo]c                 C  s$   dd |   D }ttdd |S )Nc                 S  s   g | ]}|  D ]}|qqS  )values).0Zdiffinfo_dictinfor*   r*   `/var/www/auris/lib/python3.10/site-packages/torchgen/packaged/autograd/gen_autograd_functions.py
<listcomp>  s    z3get_infos_with_derivatives_list.<locals>.<listcomp>c                 S     | j S N)args_with_derivativesr-   r*   r*   r.   <lambda>      z1get_infos_with_derivatives_list.<locals>.<lambda>)r+   listfilter)r&   Zdiff_info_listr*   r*   r.   get_infos_with_derivatives_list  s   r8   outstrtemplate_pathNonec              	     sh   t |}dd |D  dd |D d}t| |dddD ]}||  fdd	 qd
S )zFunctions.h and Functions.cpp body

    These contain the auto-generated subclasses of torch::autograd::Node
    for each every differentiable torch function.
    c                 S     g | ]}t |tqS r*   )process_functionFUNCTION_DECLARATIONr,   fr*   r*   r.   r/   "      z.gen_autograd_functions_lib.<locals>.<listcomp>c                 S  r=   r*   )r>   FUNCTION_DEFINITIONr@   r*   r*   r.   r/   #  rB   Z	FunctionsFZinstall_dirZtemplate_dirdry_run)z.hz.cppc                     s    dd   d   dS )N@generated from /)generated_commentZautograd_function_declarationsZautograd_function_definitions)template_dir_for_commentsr*   ZdeclarationsZdefinitionsfmfnamer*   r.   r4   ,  s   z,gen_autograd_functions_lib.<locals>.<lambda>N)r8   r"   Zwrite_with_template)r9   r&   r;   infosZfile_basenamesuffixr*   rK   r.   gen_autograd_functions_lib  s   rP   c              	     sl   t | |dd d d fdd t|} jd|dd d	d
d   d idd ddhd d S )NFrD      zpython_functions.hc                     s8   dd    d dd tD dd tD dS )NrF   rG   z/python_functions.hc                 S     g | ]}d | dqS )z(void initialize_autogenerated_functions_z(PyObject* module);r*   r,   ir*   r*   r.   r/   B      
zCgen_autograd_functions_python.<locals>.<lambda>.<locals>.<listcomp>c                 S  rR   )Z#initialize_autogenerated_functions_z	(module);r*   rS   r*   r*   r.   r/   F  rU   )rI   Zshard_forward_declareZ
shard_call)rJ   ranger*   rL   
num_shardsr*   r.   r4   ?  s   z/gen_autograd_functions_python.<locals>.<lambda>zpython_functions.cppc                 S  r0   r1   namer3   r*   r*   r.   r4   S  r5   rI   rF   rG   z/python_functions.cppc                 S  s   t | tgt | tgdS )N)py_function_initializerspy_function_props_and_getters)r>   PY_FUNCTION_DEFINITIONPY_FUNCTION_PROPS_AND_GETTERSr3   r*   r*   r.   r4   X  s
   r[   r\   )Zkey_fnZbase_envZenv_callablerX   Zsharded_keys)r"   writer8   Zwrite_shardedrJ   )r9   r&   r;   rN   r*   rW   r.   gen_autograd_functions_python6  s&   
r`   r-   r   templater   c                   s  g g 
g }g g g }g g 	g g g g  g i t jD ]<\}}|jtv rI|j d}|d|j d  |j d d nd}|d|j d| d ||j< q!dS 	
fdd}tjdd dD ]}||dd qytjdd dD ]}||dd qt	
dkrd}	nd}	t
r d d t }
nd}
g }tr|d n|fddtjD  dTfd$d%}g }d}jD ]}||j\}}|| ||O }qވD ]}|d&| d' q|r|t	j d( jtv rd)}nd*}t		dkr&d+	d, nd}d-}tjt	|||d.}d/d0 t D }d-d1d  D }g }t D ]\}}|d2}|d| d3| d4 qRd5t	 d6g}D ]}|d2}|d7}||  qtd8g}|D ]}|d9| d: q|d; |jdUi d<d-d=jd>d-|d? d@|dA|dBt	dCd-|dD|dEdF
dG|dHdI|	dJ|
dK|dL|dM|dN|dOdPdQdR|S )VNZ_size_zsize_t z_size_;Zsize_t1auto z_ix = gen.range();varr   	is_outputboolr(   r<   c              	     sz  | j j}| j j}d}d}|}d}d }|ttks2|tttks2|ttttks2|ttkr}|r}d}
d| d 	| d |rIdnd}	d| d	| d
|	 d t	j
j|td tj
j|td d}| d}d}n|ttks|ttks|tttkr|tttkrjjjjjdr|sJ d}
d| d 
d| d 	| d 	| d |rdnd}	d| d| d|	 d d| d tj
j|td tj
j|td d}| d}d}nE|ttttkrtd}
d| d 
d| d 	| d 	| d d| d| d d| d tj
j|td tj
j|td d}| d}d}n|ttkr
d| d tj
j|td n|ttkr
d | d tj
j|td n|ttkrΈ
d!| d t j
j|td n|tt!kr
d"| d t j
j|td nf|tttkr
d!| d t j
j|td nF|tttkr,
d"| d t j
j|td n&|tt"tt#krN
d#| d t j
j|t$d n|tt%kro
|&  d$| d% tj
j|t'd n|tt(kr
d&| d tj
j|t)d n|tt*kr
d'| d tj
j|t+d n|ttt*krȈ
d(| d t,j
j|t+d n|t"tt-d)d*d+d,d-kr
d.| d d/}
d| d 	| d0 t.d1j
j|t/d nPd2|& 0 vr"d3|& 0 vr"d4|& vr"d5|& vs+J |&  d6
|&  d$| d |t1v rPt1| \}
}|
j
j||d nd}|r`t2j
j|d7 |rnt3j
j|d7 |rd8| d9|r|d:nd; d n	d8| d d<| d d=| d |d u r
d> 4d$d?  d5} t5| | d S )@NTFzSavedVariable z_;z_.reset_data();zshared_from_this() rc   z = z	_.unpack(rd   )oprZ   body_zTensor&Z_foreachzstd::vector<SavedVariable> zbool z_released_ = false;z
_.clear();z_released_ = true;Znullptrz = unpack_list(z_, zTORCH_CHECK(!z _released_, ERR_BACKWARD_TWICE);zstd::vector<Tensor>&z = unpack_opt_list(z_);z#torch::List<std::optional<Tensor>>&zstd::vector<int64_t> ;zstd::vector<c10::SymInt> zc10::OptionalArray<int64_t> z c10::OptionalArray<c10::SymInt> zc10::OptionalArray<double>  z = 0;zc10::SymInt zstd::string zstd::optional<std::string> atZScalar)nsrZ   )type)elemzstd::vector<at::Scalar> zstd::vector<at::Scalar>&z	.clear();ar  PyObject* THP${op}_${name}_getter(THPCppFunction *self, void *_unused) {
  HANDLE_TH_ERRORS
  const auto *node = static_cast<${op}*>(self->cdata.get());
  const auto& prop = node->${name};
  if (node->${name}_released_) {
    PyErr_SetString(PyExc_RuntimeError, ERR_BACKWARD_TWICE);
    return nullptr;
  }
  ${body}
  END_HANDLE_TH_ERRORS
}
                            refview*&z. looks like it contains a non-owning reference)ri   rZ   zargs.collect(z, truefalsezsaved.before(zsaved.after(r   )6nctyperZ   rp   r   r   r   r   r   appendGETTER_DEFINITION_SAVEDVAR
substituteri   GETTER_BODY_SAVEDVARGETTER_DEFINITION_RAW_SAVEDVARGETTER_BODY_RAW_SAVEDVARr   r   r   funcbase
startswithGETTER_DEFINITION_VEC_SAVEDVARGETTER_BODY_VEC_SAVEDVAR"GETTER_DEFINITION_RAW_VEC_SAVEDVARGETTER_BODY_RAW_VEC_SAVEDVARr   r   GETTER_DEFINITIONGETTER_BODY_ARRAYREF_LONGr   GETTER_BODY_ARRAYREF_SYMINTr   GETTER_DEFINITION_OPT_ARRAYREFr   r	   r   GETTER_BODY_ARRAYREF_DOUBLEr   Zcpp_typeGETTER_BODY_INT64_Tr   GETTER_BODY_SYMINTr   GETTER_BODY_STRINGGETTER_DEFINITION_OPTr
   r   GETTER_BODY_VEC_SCALARlowerMISC_GETTER_DEFSPY_GETSETDEF_STRUCTPY_RAW_GETSETDEF_STRUCTsplitr:   )re   rf   rZ   rp   Zshould_append_getsetdefZshould_append_raw_getsetdefZ
visit_nameZuses_cpp_saved_variable_clsZunpacked_ref_typeZptrZ
getter_defrj   )apply_functional_argsapply_functional_args_ref_typesapply_with_saved_afterapply_with_saved_beforeassertscompiled_argsgetter_definitionsr-   py_getsetdef_structsrelease_variablessaved_variablesunpackr*   r.   save_var  s  






z"process_function.<locals>.save_varc                 S     t | jjS r1   r:   ry   rZ   sar*   r*   r.   r4         z"process_function.<locals>.<lambda>)keyF)rf   c                 S  r   r1   r   r   r*   r*   r.   r4     r   Tr   z)std::lock_guard<std::mutex> lock(mutex_);rh   Zretain_variableszconst auto& grad = grads[0];c                 3  s*    | ]}d | d j | dV  qdS )zconst auto& z	 = grads[z];N)Zavailable_named_gradientsindexr,   rZ   r3   r*   r.   	<genexpr>  s
    
z#process_function.<locals>.<genexpr>
derivativer   r2   Sequence[Binding]tuple[bool, str]c                   s@  | j }| j t dkrVd}d|vr; fdd|D }t|dkr;|d }t|jtr;t|jjdv r;d| d	 }d
}j	drDt
}nt}||j d | d  dfS d|v rmfdd D }tjt |d}nd}fdd D }	d|	}	g }
t D ]\}}|
tj||| d qdtj|	|
||dfS )Nr#   Fnot_implementedc                   s   g | ]}|j  d  kr|qS )r   rY   )r,   arg	var_namesr*   r.   r/     s    z=process_function.<locals>.emit_derivative.<locals>.<listcomp>r   )ZTensorzTensor?zany_grad_defined ? (z) : Tensor()TZ	_foreach_)rZ   r   idxgrad_input_maskc                      g | ]
}d  |  dqS )needs_input_grad[z],r*   r   input_name_to_idxr*   r.   r/     s    )nmasksrh   c                   r   )r   ]r*   r   r   r*   r.   r/     s    z || )rZ   rT   r   )needs_input_gradcopy_rangesr   r   )formular   len
isinstanceargumentr    r:   rp   rZ   r   DERIVATIVE_SINGLE_FOREACHDERIVATIVE_SINGLEr|   GRAD_INPUT_MASKjoin	enumeraterz   DERIVATIVE_MULTI_COPY_RANGEDERIVATIVE_MULTI)r   r2   r   checks_any_grad_definedZmatching_argsr   Zderivative_templater   r   r   r   rT   r   )r-   r   r   r.   emit_derivative  sh   






z)process_function.<locals>.emit_derivativeztask_should_compute_output({ z_ix }),z4bool any_grad_defined = any_variable_defined(grads);NodeZTraceableFunctionz,
,
)r   compute_index_rangesr   c                 S  s   g | ]\}}| d | qS )rm   r*   )r,   Txr*   r*   r.   r/     s    z$process_function.<locals>.<listcomp>c                 s  s    | ]	}d | dV  qdS )zpacked_args.pack(rd   Nr*   r   r*   r*   r.   r     s    
ru   z = packed_args.unpack<z>();zstd::array<bool, >constz#std::vector<at::TypePtr> schema = {z(  torch::dynamo::autograd::IValuePacker<z>::packed_type(),z};Zunpacksri   compute_schemar   apply_functional_args_signaturecompute_needs_input_gradZ
num_inputsunpack_ivaluesr   r   r   saved_list_sizesr   thread_lockwill_release_variablesrj   
superclassall_getter_definitionsall_getsetdef_structsr   r   r   get_packed_args)re   r   rf   rg   r(   r<   )r   r   r2   r   r(   r   r*   )r   r2   rp   r   rZ   rz   sortedZall_saved_inputsZall_saved_outputsr   r   WILL_RELEASE_VARIABLESr|   r   extendZused_named_gradientsZderivativesinsertUNTRACEABLE_FUNCTIONSr   COMPUTE_NEEDS_INPUT_GRADzipremovesuffixremoveprefixstripri   )r-   ra   r   r   r   r   sizer   re   r   r   rj   r   r   Zneed_any_grad_defined_varr   r   Zderivative_textrZ   r   r   r   r   r   r   r   typZschema_argsr   Z
schema_argr*   )r   r   r   r   r   r   r   r-   r   r   r   r   r   r.   r>   e  s  
$ ~


?















	
r>   N)r&   r'   r(   r)   )r9   r:   r&   r'   r;   r:   r(   r<   )r-   r   ra   r   r(   r:   )T
__future__r   typingr   Ztorchgen.api.autogradr   r   r   r   r   Ztorchgen.api.typesr	   r
   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   Ztorchgen.code_templater   Ztorchgen.modelr    r!   Ztorchgen.utilsr"   Zgen_inplace_or_view_typer$   collections.abcr%   r?   r   rC   r   r   r   r   r   r   r]   r^   r   r   r   r{   r~   r   r   r   r   r}   r   r   r   r   r   r   r   r   ZGETTER_BODY_DOUBLEZGETTER_BODY_BOOLr   ZGETTER_BODY_SCALARr   r   r   r8   rP   r`   r>   r*   r*   r*   r.   <module>   s   `D	


"/