ak.typetracer.TypeTracerArray
=============================

Defined in `awkward._nplikes.typetracer <https://github.com/scikit-hep/awkward/blob/80c3e39415a29a29ae2ffcc089f09e6de9e17fa2/src/awkward/_nplikes/typetracer.py>`__ on `line 248 <https://github.com/scikit-hep/awkward/blob/80c3e39415a29a29ae2ffcc089f09e6de9e17fa2/src/awkward/_nplikes/typetracer.py#L248>`__.

.. py:class:: ak.typetracer.TypeTracerArray



   Mixin defining all operator special methods using __array_ufunc__.

   This class implements the special methods for almost all of Python's
   builtin operators defined in the ``operator`` module, including comparisons
   (````==````, ````>````, etc.) and arithmetic (````+````, ````*````, ````-````, etc.), by
   deferring to the ````__array_ufunc__```` method, which subclasses must
   implement.

   It is useful for writing classes that do not inherit from ``numpy.ndarray``,
   but that should support arithmetic and numpy universal functions like
   arrays as described in ``A Mechanism for Overriding Ufuncs
   <https://numpy.org/neps/nep-0013-ufunc-overrides.html>``_.

   As an trivial example, consider this implementation of an ````ArrayLike````
   class that simply wraps a NumPy array and ensures that the result of any
   arithmetic operation is also an ````ArrayLike```` object::

       class ArrayLike(np.lib.mixins.NDArrayOperatorsMixin):
           def __init__(self, value):
               self.value = np.asarray(value)

           # One might also consider adding the built-in list type to this
           # list, to support operations like np.add(array_like, list)
           _HANDLED_TYPES = (np.ndarray, numbers.Number)

           def __array_ufunc__(self, ufunc, method, *inputs, **kwargs):
               out = kwargs.get('out', ())
               for x in inputs + out:
                   # Only support operations with instances of _HANDLED_TYPES.
                   # Use ArrayLike instead of type(self) for isinstance to
                   # allow subclasses that don't override __array_ufunc__ to
                   # handle ArrayLike objects.
                   if not isinstance(x, self._HANDLED_TYPES + (ArrayLike,)):
                       return NotImplemented

               # Defer to the implementation of the ufunc on unwrapped values.
               inputs = tuple(x.value if isinstance(x, ArrayLike) else x
                              for x in inputs)
               if out:
                   kwargs['out'] = tuple(
                       x.value if isinstance(x, ArrayLike) else x
                       for x in out)
               result = getattr(ufunc, method)(*inputs, **kwargs)

               if type(result) is tuple:
                   # multiple return values
                   return tuple(type(self)(x) for x in result)
               elif method == 'at':
                   # no return value
                   return None
               else:
                   # one return value
                   return type(self)(result)

           def __repr__(self):
               return '%s(%r)' % (type(self).__name__, self.value)

   In interactions between ````ArrayLike```` objects and numbers or numpy arrays,
   the result is always another ````ArrayLike````:

       >>> x = ArrayLike([1, 2, 3])
       >>> x - 1
       ArrayLike(array([0, 1, 2]))
       >>> 1 - x
       ArrayLike(array([ 0, -1, -2]))
       >>> np.arange(3) - x
       ArrayLike(array([-1, -1, -1]))
       >>> x - np.arange(3)
       ArrayLike(array([1, 1, 1]))

   Note that unlike ````numpy.ndarray````, ````ArrayLike```` does not allow operations
   with arbitrary, unrecognized types. This ensures that interactions with
   ArrayLike preserve a well-defined casting hierarchy.

   .. versionadded:: 1.13


   .. py:attribute:: _dtype
      :type:  numpy.dtype


   .. py:attribute:: _shape
      :type:  tuple[awkward._nplikes.shape.ShapeItem, Ellipsis]


   .. py:attribute:: runtime_typechecks
      :value: True



   .. py:method:: _new(dtype: awkward._typing.DType, shape: tuple[awkward._nplikes.shape.ShapeItem, Ellipsis], form_key: str | None = None, report: TypeTracerReport | None = None)
      :classmethod:



   .. py:property:: T
      :type: awkward._typing.Self



   .. py:property:: dtype
      :type: awkward._typing.DType



   .. py:property:: size
      :type: awkward._nplikes.shape.ShapeItem



   .. py:property:: shape
      :type: tuple[awkward._nplikes.shape.ShapeItem, Ellipsis]



   .. py:property:: strides


   .. py:property:: inner_shape
      :type: tuple[awkward._nplikes.shape.ShapeItem, Ellipsis]



   .. py:property:: form_key
      :type: str | None



   .. py:property:: report
      :type: TypeTracerReport | None



   .. py:method:: touch_shape()


   .. py:method:: touch_data()


   .. py:property:: nplike
      :type: TypeTracer



   .. py:property:: ndim
      :type: int



   .. py:property:: nbytes
      :type: awkward._nplikes.shape.ShapeItem



   .. py:method:: view(dtype: numpy.typing.DTypeLike) -> awkward._typing.Self


   .. py:method:: forget_length() -> awkward._typing.Self


   .. py:property:: ctypes


   .. py:method:: copy()


   .. py:method:: tolist() -> list

Classes
-------

.. autoapisummary::

   awkward.typetracer.TypeTracerArray._CTypes