+ jE9Rt^RIHt^RIHt^RIt^RIHtH t ]'d^RI H t .ROt !RR4tRR ltR R ltR R ltRRltRRltRRltRR/RRlltR#)aPython access to ATen's TensorIterator build pipeline. :class:`TensorIterator` builds an iterator from a set of operands and flags that mirror ``at::TensorIteratorConfig``, then exposes the post-build shape / dtype / device / stride information for inspection. This is a build-pipeline-only surface: there is no ``for_each`` here. Use it to debug shape and dtype inference, validate custom-op contracts, or inspect how ATen would lay out a kernel's iteration. Construction is canonical, *not* a faithful replay of arbitrary ``TensorIteratorConfig`` call sequences. Operands are always registered in the order ``outputs -> inputs -> const_inputs`` and setters are applied in one fixed order. Notably: * The C++ builder distinguishes ``add_input(a); add_const_input(b)`` from ``add_const_input(b); add_input(a)`` -- ``input(0)`` refers to different operands. This Python surface cannot express that distinction: every ``inputs[i]`` precedes every ``const_inputs[j]``. * Some C++ setters have order-dependent side effects (e.g. ``promote_inputs_to_common_dtype(true)`` also flips ``check_all_same_dtype`` to ``false``). The Python surface materializes the *final* boolean state of each knob, not the call order, so it can't reproduce a sequence where an intermediate setter observed a since-overwritten value. Every in-tree caller of ``at::TensorIteratorConfig`` fits the canonical- recipe shape; the lossiness is theoretical, not practical. ) annotations) TYPE_CHECKINGN)_TensorIterator_TensorIteratorSpec)SequenceTensorIteratorc$]tRt^:tRtRRRRRRRRRRR R R R R R R R RR RRRRRR RR RRRRRRRRraA built TensorIterator. Read-only view of the build-pipeline result. Constructor kwargs mirror ``at::TensorIteratorConfig``; defaults match the C++ defaults. See module docstring for canonical-recipe caveats. Examples -------- Build a TI for a binary op with type promotion and inspect the result:: >>> import torch >>> from torch._tensor_iterator import TensorIterator >>> a = torch.zeros(3, 4, dtype=torch.float32) >>> b = torch.zeros(3, 4, dtype=torch.float64) >>> it = TensorIterator( ... outputs=[None], ... const_inputs=[a, b], ... promote_inputs_to_common_dtype=True, ... cast_common_dtype_to_outputs=True, ... ) >>> it.common_dtype torch.float64 >>> it.numel 12 >>> it.ndim # contiguous (3, 4) collapses to a single dim 1 Declare a static shape (the iterator skips broadcast/coalesce):: >>> a = torch.zeros(2, 6) >>> out = torch.empty(2, 6) >>> it = TensorIterator( ... outputs=[out], ... const_inputs=[a], ... resize_outputs=False, ... static_shape=(2, 6), ... ) Build a reduction TI (output must be pre-allocated to the reduced shape):: >>> a = torch.zeros(3, 4) >>> out = torch.empty(3, 1) >>> it = TensorIterator( ... outputs=[out], ... const_inputs=[a], ... resize_outputs=False, ... is_reduction=True, ... ) Inspect post-coalesce strides (in bytes; use ``element_strides`` for element units):: >>> a = torch.zeros(3, 4) >>> b = torch.zeros(3, 4) >>> it = TensorIterator(outputs=[None], const_inputs=[a, b]) >>> tuple(it.strides(0)) # output byte strides (4,) >>> it.element_strides(0) # ... in elements (1,) outputsNinputs const_inputscheck_all_same_dtypeTcheck_all_same_devicepromote_inputs_to_common_dtypeFpromote_integer_inputs_to_floatcast_common_dtype_to_outputsenforce_safe_casting_to_outputenforce_linear_iterationresize_outputscheck_mem_overlapallow_cpu_scalars is_reduction static_dtype static_device static_shape squash_dimsc&dV^8dQhRRRRRRRRRRR RR RR RR RR RRRRRRRRRRRRRRRRRRR/#)r z list[torch.Tensor | None] | Noner zlist[torch.Tensor] | Noner r boolr rrrrrrrrrrtorch.dtype | Nonerztorch.device | NonerzSequence[int] | Nonerz Sequence[int]returnNone)formats"W/home/luca/screen-checking/.venv/lib/python3.14/site-packages/torch/_tensor_iterator.py __annotate__TensorIterator.__annotate__ws/4/42/4* /4 0 /4 # /4 $/4)-/4*./4'+/4)-/4#'/4/4 /4 /4 !/4")#/4$+%/4&+'/4(#)/4* +/4c \4pVe \V4M.VnVe \V4M.VnVe \V4M.VnVVnVVnVVnVVnVVn V Vn V Vn V Vn V Vn V VnVVnVeVVnVeVVnVe!\V4Vn\V4VnVP)4VnR#N)_CTensorIteratorSpeclistr r r r r rrrrrrrrrrrrrbuild_impl)selfr r r r r rrrrrrrrrrrrrspecs&$$$$$$$$$$$$$$$$$$ r#__init__TensorIterator.__init__ws,$%(/(;tG} &,&8d6lb 2>2JD.PR$8!%:".L+/N,,H).L+(@%,!2!2(  # ,D   $!.D   # $\ 2D #K0D '+zz| r&cV^8dQhRR/#rrintr!)r"s"r#r$r%scr&c .VPP#r()r,ndimr-s&r#r5TensorIterator.ndimszzr&cV^8dQhRR/#)rr memoryviewr!)r"s"r#r$r%s  z r&c .VPP#)aiIterator shape (post coalesce/reorder), as a zero-copy ``memoryview`` of ``int64`` elements. The view holds a reference to this iterator and keeps it alive for as long as the view is reachable; copy via ``tuple(it.shape)`` if you need a snapshot you can outlive the iterator with. Hot-path readers (dispatch conditionals) get index access without an allocation.)r,shaper6s&r#r;TensorIterator.shapeszzr&cV^8dQhRR/#r2r!)r"s"r#r$r%s  s r&c .VPP#r()r,numelr6s&r#r?TensorIterator.numelszzr&cV^8dQhRR/#r2r!)r"s"r#r$r%####r&c .VPP#r()r,ntensorsr6s&r#rDTensorIterator.ntensorszz"""r&cV^8dQhRR/#r2r!)r"s"r#r$r%s"""r&c .VPP#r()r,ninputsr6s&r#rITensorIterator.ninputsszz!!!r&cV^8dQhRR/#r2r!)r"s"r#r$r%rBr&c .VPP#r()r,noutputsr6s&r#rMTensorIterator.noutputsrFr&cV^8dQhRR/#rrrr!)r"s"r#r$r%((t(r&c .VPP#r()r, is_contiguousr6s&r#rSTensorIterator.is_contiguouszz'''r&cV^8dQhRR/#rPr!)r"s"r#r$r%rQr&c .VPP#r()r, is_trivial_1dr6s&r#rXTensorIterator.is_trivial_1drUr&cV^8dQhRR/#)rrrr!)r"s"r#r$r%s''0'r&c .VPP#)a,The inferred computation dtype, or ``None`` if no single dtype was inferred. Populated whenever TensorIterator can resolve a common dtype -- under promotion flags, or when every input already shares a dtype. ``None`` does not mean "promotion was not requested"; it means inference produced no answer.)r, common_dtyper6s&r#r\TensorIterator.common_dtypeszz&&&r&c V^8dQhRRRR/#rindexr3r torch.Tensorr!)r"s"r#r$r%s((C(L(r&c 8VPPV4#)aLReturn the iterator's current operand at ``index``. Note: under ``promote_inputs_to_common_dtype`` / ``cast_common_dtype_to_outputs`` (CPU paths), this may be a promoted/cast kernel temporary rather than the tensor that was registered with the config -- it's the iterator's view of the operand a kernel would actually iterate over.)r,tensorr-r`s&&r#rcTensorIterator.tensorszz  ''r&c V^8dQhRRRR/#r_r!)r"s"r#r$r%s''3'|'r&c 8VPPV4#)zZReturn the iterator's current input. See :meth:`tensor` for the promoted-temporary caveat.)r,inputrds&&r#rhTensorIterator.inputszz&&r&c V^8dQhRRRR/#r_r!)r"s"r#r$r%s((C( (r&c 8VPPV4#)zWReturn the iterator's current output. See :meth:`tensor` for the cast-temporary caveat.)r,outputrds&&r#rlTensorIterator.outputszz  ''r&c V^8dQhRRRR/#)rr`r3rz torch.dtyper!)r"s"r#r$r%s''3'{'r&c 8VPPV4#r()r,dtyperds&&r#rpTensorIterator.dtypeszz&&r&c V^8dQhRRRR/#)rr`r3rz torch.devicer!)r"s"r#r$r%s((C( (r&c 8VPPV4#r()r,devicerds&&r#rtTensorIterator.deviceszz  ''r&c V^8dQhRRRR/#)rr`r3rr9r!)r"s"r#r$r%s))S)Z)r&c 8VPPV4#)a+Per-operand strides in bytes (post reorder/coalesce), as a zero-copy ``memoryview`` of ``int64`` elements. The view holds a reference to this iterator and keeps it alive for as long as the view is reachable; copy via ``tuple(it.strides(i))`` if you need a snapshot you can outlive the iterator with.)r,stridesrds&&r#rxTensorIterator.stridess zz!!%((r&c V^8dQhRRRR/#)rr`r3rztuple[int, ...]r!)r"s"r#r$r%s11S1_1r&c 8VPPV4#)zPer-operand strides in elements (byte stride / element size). Allocates a fresh tuple on every call. Don't use on a hot path: cache the result, or read :meth:`strides` once and divide by :meth:`element_size` of the operand inline.)r,element_stridesrds&&r#r|TensorIterator.element_stridess zz))%00r&cV^8dQhRR/#)rrstrr!)r"s"r#r$r%s  # r&c ,\VP4#r()reprr,r6s&r#__repr__TensorIterator.__repr__sDJJr&)r,r!))__name__ __module__ __qualname____firstlineno____doc__r/propertyr5r;r?rDrIrMrSrXr\rcrhrlrprtrxr|r__static_attributes__r!r&r#rr:s:x/459/4-1 /4 37 /4 &* /4'+/405/416/4.3/405/4*//4 $/4#'/4#(/4 #!/4",0#/4$.2%/4&.2'/4(&()/4b    ##""##((((''(' ( '()1  r&c(V^8dQhRRRRRRRR/#routtorch.Tensor | Nonearabrrr!)r"s"r#r$r$ s,    !- 2>  r&c (\V.W.RRRRR7#)z0Equivalent of ``at::TensorIterator::binary_op``.T)r r rrrrrrrrs&&&r# binary_opr s' V'+%)'+  r&c(V^8dQhRRRRRRRR/#rr!)r"s"r#r$r$s,    !- 2>  r&c *\V.W.RRRRRR7#)z6Equivalent of ``at::TensorIterator::binary_float_op``.T)r r rrrrrrrs&&&r#binary_float_oprs* V'+%)'+(, r&c(V^8dQhRRRRRRRR/#rr!)r"s"r#r$r$'s, !-2>r&c Vf\PMRpVRJ;'dVP\P8gp\V.W.RRVVR7#)a4Equivalent of ``at::TensorIterator::comparison_op``. When ``out`` is ``None``, the output dtype is forced to bool. When ``out`` is a defined non-bool tensor, the common dtype is cast back to its dtype via ``cast_common_dtype_to_outputs``. The bool-output case skips that cast as a performance optimization. NT)r r rrrr)torchrrpr)rrrrcast_to_outputss&&& r# comparison_opr'sT"%5::$LoAA#))uzz*AO V'+%4!  r&c$V^8dQhRRRRRR/#rrrrrarrr!)r"s"r#r$r$=s";;%;,;>;r&c \V.V.R7#)z/Equivalent of ``at::TensorIterator::unary_op``.)r r rrrs&&r#unary_opr=s 3%qc ::r&c$V^8dQhRRRRRR/#rr!)r"s"r#r$r$Bs"  +   r&c (\V.V.RRRRR7#)z5Equivalent of ``at::TensorIterator::unary_float_op``.T)r r rrrrrrs&&r#unary_float_oprBs% S'+%)'+(,  r&c V^8dQhRRRR/#)rrrarrr!)r"s"r#r$r$NsL^r&c>Vf \R4h\V.RRR7#)zEquivalent of ``at::TensorIterator::nullary_op``. Unlike the binary/unary factories, ``out`` must be a defined tensor; the C++ named constructor takes a non-undefined output. zAnullary_op requires a defined output tensor; None is not allowed.F)r r r) TypeErrorr)rs&r# nullary_oprNs3  { O   " r&out2c(V^8dQhRRRRRRRR/#)rrrarrrrrr!)r"s"r#r$r$_s022 22  2  2r&c LVEeVPVPu;8XdVP8Xg5M\RVP RVP RVP 24hVP4VP48wd.\RVP4 RVP4 24hVPVP8wg$VP 4VP 48wd \R4h\ W.V.RRRRR 7#\ V.V.RRRRR 7#) aEquivalent of ``at::TensorIterator::reduce_op``. Pass ``out2`` for the two-output reduction overload (e.g. ``min`` returning values + indices). The output tensor(s) must be pre-allocated and shaped correctly: this factory does not allocate or resize. With ``out2``, both outputs must live on ``a``'s device and share its sizes/strides -- the C++ named constructor asserts this and the same checks are mirrored here. zAreduce_op: out, out2, and the input must share a device, got out=z, out2=z, a=z4reduce_op: out and out2 must have the same dim, got z and z=reduce_op: out and out2 must have identical sizes and stridesFT)r r r rrr)r r rrrr)rt RuntimeErrordimr;strider)rrrs&&$r# reduce_opr_s( zzQXX44::,gdkk]$qxxjJ  779 "F779+U488:,0  99 "cjjldkkm&CO K!& #    S'+  r&)rrrrrrrr)r __future__rtypingrrtorch._Cr_CTensorIteratorrr)collections.abcr__all__rrrrrrrrr!r&r#rsh<#  ( H H `  ,; "2!% 22r&