class_docstr: An array of fixed-shape, homogeneous-typed tensors.
  
  This is the Arrow side of TensorArray.
  
  See Arrow docs for customizing extension arrays:
  https://arrow.apache.org/docs/python/extending_types.html#custom-extension-array-class
class_docstr_tok: ["An","array","of","fixed-shape",",","homogeneous-typed","tensors",".","This","is","the","Arrow","side","of","TensorArray",".","See","Arrow","docs","for","customizing","extension","arrays",":","https",":","\/\/arrow.apache.org\/docs\/python\/extending_types.html","#","custom-extension-array-class"]
docstr: Helper for getting either an element of the array of tensors as an
  ndarray, or the entire array of tensors as a single ndarray.
  
  Args:
      index: The index of the tensor element that we wish to return as
          an ndarray. If not given, the entire array of tensors is
          returned as an ndarray.
      zero_copy_only: If True, an exception will be raised if the
          conversion to a NumPy array would require copying the
          underlying data (e.g. in presence of nulls, or for
          non-primitive types). This argument is currently ignored, so
          zero-copy isn't enforced even if this argument is true.
  
  Returns:
      The corresponding tensor element as an ndarray if an index was
      given, or the entire array of tensors as an ndarray otherwise.
docstr_tok: ["Helper","for","getting","either","an","element","of","the","array","of","tensors","as","an","ndarray",",","or","the","entire","array","of","tensors","as","a","single","ndarray",".","Args",":","index",":","The","index","of","the","tensor","element","that","we","wish","to","return","as","an","ndarray",".","If","not","given",",","the","entire","array","of","tensors","is","returned","as","an","ndarray",".","zero_copy_only",":","If","True",",","an","exception","will","be","raised","if","the","conversion","to","a","NumPy","array","would","require","copying","the","underlying","data","(","e.g",".","in","presence","of","nulls",",","or","for","non-primitive","types",")",".","This","argument","is","currently","ignored",",","so","zero-copy","is","n't","enforced","even","if","this","argument","is","true",".","Returns",":","The","corresponding","tensor","element","as","an","ndarray","if","an","index","was","given",",","or","the","entire","array","of","tensors","as","an","ndarray","otherwise","."]
code: def _to_numpy(
      self, index: Optional[int] = None, zero_copy_only: bool = False
  ):
      """
      Helper for getting either an element of the array of tensors as an
      ndarray, or the entire array of tensors as a single ndarray.
  
      Args:
          index: The index of the tensor element that we wish to return as
              an ndarray. If not given, the entire array of tensors is
              returned as an ndarray.
          zero_copy_only: If True, an exception will be raised if the
              conversion to a NumPy array would require copying the
              underlying data (e.g. in presence of nulls, or for
              non-primitive types). This argument is currently ignored, so
              zero-copy isn't enforced even if this argument is true.
  
      Returns:
          The corresponding tensor element as an ndarray if an index was
          given, or the entire array of tensors as an ndarray otherwise.
      """
      # TODO(Clark): Enforce zero_copy_only.
      # TODO(Clark): Support strides?
      # Buffers schema:
      # [None, offset_buffer, None, data_buffer]
      buffers = self.buffers()
      data_buffer = buffers[3]
      storage_list_type = self.storage.type
      value_type = storage_list_type.value_type
      ext_dtype = value_type.to_pandas_dtype()
      shape = self.type.shape
      if pa.types.is_boolean(value_type):
          # Arrow boolean array buffers are bit-packed, with 8 entries per byte,
          # and are accessed via bit offsets.
          buffer_item_width = value_type.bit_width
      else:
          # We assume all other array types are accessed via byte array
          # offsets.
          buffer_item_width = value_type.bit_width // 8
      # Number of items per inner ndarray.
      num_items_per_element = np.prod(shape) if shape else 1
      # Base offset into data buffer, e.g. due to zero-copy slice.
      buffer_offset = self.offset * num_items_per_element
      # Offset of array data in buffer.
      offset = buffer_item_width * buffer_offset
      if index is not None:
          # Getting a single tensor element of the array.
          offset_buffer = buffers[1]
          offset_array = np.ndarray(
              (len(self),),
              buffer=offset_buffer,
              dtype=self.OFFSET_DTYPE,
          )
          # Offset into array to reach logical index.
          index_offset = offset_array[index]
          # Add the index offset to the base offset.
          offset += buffer_item_width * index_offset
      else:
          # Getting the entire array of tensors.
          shape = (len(self),) + shape
      if pa.types.is_boolean(value_type):
          # Special handling for boolean arrays, since Arrow bit-packs boolean arrays
          # while NumPy does not.
          # Cast as uint8 array and let NumPy unpack into a boolean view.
          # Offset into uint8 array, where each element is a bucket for 8 booleans.
          byte_bucket_offset = offset // 8
          # Offset for a specific boolean, within a uint8 array element.
          bool_offset = offset % 8
          # The number of uint8 array elements (buckets) that our slice spans.
          # Note that, due to the offset for a specific boolean, the slice can span
          # byte boundaries even if it contains less than 8 booleans.
          num_boolean_byte_buckets = 1 + (
              (bool_offset + np.prod(shape) - 1) // 8
          )
          # Construct the uint8 array view on the buffer.
          arr = np.ndarray(
              (num_boolean_byte_buckets,),
              dtype=np.uint8,
              buffer=data_buffer,
              offset=byte_bucket_offset,
          )
          # Unpack into a byte per boolean, using LSB bit-packed ordering.
          arr = np.unpackbits(arr, bitorder="little")
          # Interpret buffer as boolean array.
          return np.ndarray(
              shape, dtype=np.bool_, buffer=arr, offset=bool_offset
          )
      # Special handling of binary/string types. Assumes unicode string tensor columns
      if pa.types.is_fixed_size_binary(value_type):
          ext_dtype = np.dtype(
              f"<U{value_type.byte_width // NUM_BYTES_PER_UNICODE_CHAR}"
          )
      return np.ndarray(
          shape, dtype=ext_dtype, buffer=data_buffer, offset=offset
      )
  
imports: import itertools
  import json
  import sys
  from typing import Iterable, Optional, Tuple, List, Sequence, Union
  from packaging.version import parse
  import numpy
  import pyarrow
  from ray.air.util.tensor_extensions.utils import _is_ndarray_variable_shaped_tensor, create_ragged_ndarray
  from ray._private.utils import _get_pyarrow_version
  from ray.util.annotations import PublicAPI
label_desc: Use image node_id 2 for calling the ArrowTensorArray obj's underlying member method code with example usage: obj._to_numpy(index, zero_copy_only) and returns: np, np