Add files using upload-large-folder tool

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/config.py

@@ -0,0 +1,47 @@
+import dataclasses
+from typing import Iterable
+
+
+def ensure_only_allowed_dataclass_keys_updated(
+    dataclass: dataclasses.dataclass,
+    allowed_keys: Iterable[str],
+):
+    """
+    Validate dataclass by raising an exception if any key not included in
+    ``allowed_keys`` differs from the default value.
+
+    A ``ValueError`` will also be raised if any of the ``allowed_keys``
+    is not present in ``dataclass.__dict__``.
+
+    Args:
+        dataclass: Dict or dataclass to check.
+        allowed_keys: dataclass attribute keys that can have a value different than
+        the default one.
+    """
+    default_data = dataclass.__class__()
+
+    allowed_keys = set(allowed_keys)
+
+    # TODO: split keys_not_in_dict validation to a separate function.
+    keys_not_in_dict = [key for key in allowed_keys if key not in default_data.__dict__]
+    if keys_not_in_dict:
+        raise ValueError(
+            f"Key(s) {keys_not_in_dict} are not present in "
+            f"{dataclass.__class__.__name__}. "
+            "Remove them from `allowed_keys`. "
+            f"Valid keys: {list(default_data.__dict__.keys())}"
+        )
+
+    # These keys should not have been updated in the `dataclass` object
+    prohibited_keys = set(default_data.__dict__) - allowed_keys
+
+    bad_keys = [
+        key
+        for key in prohibited_keys
+        if dataclass.__dict__[key] != default_data.__dict__[key]
+    ]
+    if bad_keys:
+        raise ValueError(
+            f"Key(s) {bad_keys} are not allowed to be updated in the current context. "
+            "Remove them from the dataclass."
+        )

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/device_manager/__init__.py

@@ -0,0 +1,92 @@
+import logging
+import threading
+from typing import Optional
+
+import ray
+import ray._private.ray_constants as ray_constants
+from ray.air._internal.device_manager.cpu import CPUTorchDeviceManager
+from ray.air._internal.device_manager.hpu import HPUTorchDeviceManager
+from ray.air._internal.device_manager.npu import NPUTorchDeviceManager
+from ray.air._internal.device_manager.nvidia_gpu import CUDATorchDeviceManager
+from ray.air._internal.device_manager.torch_device_manager import TorchDeviceManager
+
+logger = logging.getLogger(__name__)
+
+
+DEFAULT_TORCH_DEVICE_MANAGER_CLS = CPUTorchDeviceManager
+
+
+SUPPORTED_ACCELERATOR_TORCH_DEVICE_MANAGER = {
+    ray_constants.GPU: CUDATorchDeviceManager,
+    ray_constants.HPU: HPUTorchDeviceManager,
+    ray_constants.NPU: NPUTorchDeviceManager,
+}
+
+
+def register_custom_torch_dist_backend(backend: Optional[str] = None) -> None:
+    if backend == "hccl":
+        # The name for the communication backend of Habana and torch-npu is the same.
+        HPUTorchDeviceManager.register_custom_torch_dist_backend()
+
+        NPUTorchDeviceManager.register_custom_torch_dist_backend()
+
+
+_torch_device_manager = None
+_torch_device_manager_lock = threading.Lock()
+
+
+def get_torch_device_manager_by_context() -> TorchDeviceManager:
+    global _torch_device_manager
+
+    with _torch_device_manager_lock:
+        if not _torch_device_manager:
+            existing_device_manager_cls = None
+            resources = ray.get_runtime_context().get_accelerator_ids()
+
+            # select correct accelerator type from resources
+            for resource_type, resource_value in resources.items():
+                device_manager_cls = SUPPORTED_ACCELERATOR_TORCH_DEVICE_MANAGER.get(
+                    resource_type, None
+                )
+                if resource_value and device_manager_cls:
+                    # An error will raise when multiple accelerators are specified.
+                    if existing_device_manager_cls:
+                        raise RuntimeError(
+                            "Unable to determine the appropriate DeviceManager "
+                            f"for the specified resources {resources}."
+                        )
+                    else:
+                        existing_device_manager_cls = device_manager_cls
+
+            device_manager_cls = (
+                existing_device_manager_cls or DEFAULT_TORCH_DEVICE_MANAGER_CLS
+            )
+
+            _torch_device_manager = device_manager_cls()
+
+    return _torch_device_manager
+
+
+def get_torch_device_manager_by_device_type(device_type: str):
+    if device_type.lower() == ray_constants.GPU.lower() or device_type == "cuda":
+        return CUDATorchDeviceManager()
+    elif device_type.lower() == ray_constants.NPU.lower():
+        return NPUTorchDeviceManager()
+    elif device_type.lower() == ray_constants.HPU.lower():
+        return HPUTorchDeviceManager()
+    elif device_type.lower() == "cpu":
+        return CPUTorchDeviceManager()
+
+    raise RuntimeError(f"Device type {device_type} cannot be recognized.")
+
+
+__all__ = [
+    TorchDeviceManager,
+    CPUTorchDeviceManager,
+    CUDATorchDeviceManager,
+    HPUTorchDeviceManager,
+    NPUTorchDeviceManager,
+    register_custom_torch_dist_backend,
+    get_torch_device_manager_by_context,
+    get_torch_device_manager_by_device_type,
+]

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/device_manager/cpu.py

@@ -0,0 +1,30 @@
+from contextlib import contextmanager
+from typing import List
+
+import torch
+
+from ray.air._internal.device_manager.torch_device_manager import TorchDeviceManager
+
+
+class CPUTorchDeviceManager(TorchDeviceManager):
+    """CPU device manager"""
+
+    def is_available(self) -> bool():
+        return True
+
+    def get_devices(self) -> List[torch.device]:
+        """Gets the correct torch device list configured for this process."""
+        return [torch.device("cpu")]
+
+    def supports_stream(self) -> bool:
+        """Validate if the device type support create a stream"""
+        return False
+
+    def get_stream_context(self, stream):
+        """Return empty context mananger for CPU."""
+
+        @contextmanager
+        def default_context_manager():
+            yield
+
+        return default_context_manager()

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/device_manager/hpu.py

@@ -0,0 +1,50 @@
+from contextlib import contextmanager
+from typing import List, Union
+
+import torch
+
+from ray._private.accelerators.hpu import HPU_PACKAGE_AVAILABLE
+from ray.air._internal.device_manager.torch_device_manager import TorchDeviceManager
+
+if HPU_PACKAGE_AVAILABLE:
+    import habana_frameworks.torch.hpu as torch_hpu
+
+
+class HPUTorchDeviceManager(TorchDeviceManager):
+    """HPU device manager"""
+
+    @staticmethod
+    def register_custom_torch_dist_backend():
+        if HPU_PACKAGE_AVAILABLE:
+            import habana_frameworks.torch.core  # noqa: F401
+            import habana_frameworks.torch.distributed.hccl  # noqa: F401
+
+    def is_available(self) -> bool():
+        if not HPU_PACKAGE_AVAILABLE:
+            return False
+
+        return torch_hpu.is_available()
+
+    def get_devices(self) -> List[torch.device]:
+        if not self.is_available():
+            raise RuntimeError(
+                "Using HPUTorchDeviceManager but torch hpu is not available."
+            )
+
+        return [torch.device("hpu")]
+
+    def set_device(self, device: Union[torch.device, int, str, None]):
+        torch_hpu.set_device(device)
+
+    def supports_stream(self) -> bool:
+        """Validate if the device type support create a stream"""
+        return False
+
+    def get_stream_context(self, stream):
+        """Get HPU stream context manager, empty so far."""
+
+        @contextmanager
+        def default_context_manager():
+            yield
+
+        return default_context_manager()

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/device_manager/npu.py

@@ -0,0 +1,105 @@
+import os
+from importlib.util import find_spec
+from typing import List, Union
+
+import torch
+
+import ray
+import ray._private.ray_constants as ray_constants
+from ray.air._internal.device_manager.torch_device_manager import TorchDeviceManager
+
+
+def is_package_present(package_name: str) -> bool:
+    try:
+        return find_spec(package_name) is not None
+    except ModuleNotFoundError:
+        return False
+
+
+NPU_TORCH_PACKAGE_AVAILABLE = is_package_present("torch_npu")
+
+
+if NPU_TORCH_PACKAGE_AVAILABLE:
+    import torch_npu  # noqa: F401
+
+
+class NPUTorchDeviceManager(TorchDeviceManager):
+    """Ascend NPU device manager"""
+
+    @staticmethod
+    def register_custom_torch_dist_backend():
+        if NPU_TORCH_PACKAGE_AVAILABLE:
+            import torch_npu  # noqa: F401, F811
+
+    def is_available(self) -> bool:
+        if not NPU_TORCH_PACKAGE_AVAILABLE:
+            return False
+
+        return torch.npu.is_available()
+
+    def get_devices(self) -> List[torch.device]:
+        """Gets the correct torch device list configured for this process.
+
+        Returns a list of torch NPU devices allocated for the current worker.
+        If no NPUs are assigned, then it returns a list with a single CPU device.
+        """
+        if NPU_TORCH_PACKAGE_AVAILABLE and torch.npu.is_available():
+            npu_ids = [
+                str(id)
+                for id in ray.get_runtime_context().get_accelerator_ids()[
+                    ray_constants.NPU
+                ]
+            ]
+
+            device_ids = []
+
+            if len(npu_ids) > 0:
+                npu_visible_str = os.environ.get(
+                    ray_constants.NPU_RT_VISIBLE_DEVICES_ENV_VAR, ""
+                )
+                if npu_visible_str and npu_visible_str != "NoDevFiles":
+                    npu_visible_list = npu_visible_str.split(",")
+                else:
+                    npu_visible_list = []
+
+                for npu_id in npu_ids:
+                    try:
+                        device_ids.append(npu_visible_list.index(npu_id))
+                    except IndexError:
+                        raise RuntimeError(
+                            "ASCEND_RT_VISIBLE_DEVICES set incorrectly. "
+                            f"Got {npu_visible_str}, expected to include {npu_id}. "
+                            "Did you override the `ASCEND_RT_VISIBLE_DEVICES` "
+                            "environment variable?"
+                        )
+            else:
+                # If called on the driver or outside of Ray Train, return the
+                # 0th device.
+                device_ids.append(0)
+
+            devices = [torch.device(f"npu:{device_id}") for device_id in device_ids]
+        else:
+            raise RuntimeError(
+                "Using NPUTorchDeviceManager but torch npu is not available."
+            )
+
+        return devices
+
+    def set_device(self, device: Union[torch.device, int]):
+        torch.npu.set_device(device)
+
+    def supports_stream(self) -> bool:
+        """Validate if the device type support to create a stream"""
+        return True
+
+    def create_stream(self, device):
+        """Create a stream on NPU device"""
+        return torch.npu.Stream(device)
+
+    def get_stream_context(self, stream):
+        """Get a torch.stream context on NPU device"""
+        return torch.npu.stream(stream)
+
+    def get_current_stream(self):
+        """Get current stream for NPU device"""
+        return torch.npu.current_stream()

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/device_manager/nvidia_gpu.py

@@ -0,0 +1,79 @@
+import os
+from typing import List, Union
+
+import torch
+
+import ray
+from ray.air._internal.device_manager.torch_device_manager import TorchDeviceManager
+
+
+class CUDATorchDeviceManager(TorchDeviceManager):
+    """CUDA device manager"""
+
+    def is_available(self) -> bool():
+        return torch.cuda.is_available()
+
+    def get_devices(self) -> List[torch.device]:
+        """Gets the correct torch device list configured for this process.
+
+        Returns a list of torch CUDA devices allocated for the current worker.
+        If no GPUs are assigned, then it returns a list with a single CPU device.
+
+        Assumes that `CUDA_VISIBLE_DEVICES` is set and is a
+        superset of the `ray.get_gpu_ids()`.
+        """
+
+        # GPU IDs are assigned by Ray after you specify "use_gpu"
+        # GPU `ray.get_gpu_ids()` may return ints or may return strings.
+        # We should always convert to strings.
+        gpu_ids = [str(id) for id in ray.get_gpu_ids()]
+
+        device_ids = []
+
+        if len(gpu_ids) > 0:
+            cuda_visible_str = os.environ.get("CUDA_VISIBLE_DEVICES", "")
+            if cuda_visible_str and cuda_visible_str != "NoDevFiles":
+                cuda_visible_list = cuda_visible_str.split(",")
+            else:
+                cuda_visible_list = []
+
+            # By default, there should only be one GPU ID if `use_gpu=True`.
+            # If there are multiple GPUs, return a list of devices.
+            # If using fractional GPUs, these IDs are not guaranteed
+            # to be unique across different processes.
+            for gpu_id in gpu_ids:
+                try:
+                    device_ids.append(cuda_visible_list.index(gpu_id))
+                except IndexError:
+                    raise RuntimeError(
+                        "CUDA_VISIBLE_DEVICES set incorrectly. "
+                        f"Got {cuda_visible_str}, expected to include {gpu_id}. "
+                        "Did you override the `CUDA_VISIBLE_DEVICES` environment"
+                        " variable? If not, please help file an issue on Github."
+                    )
+
+        else:
+            # If called on the driver or outside of Ray Train, return the
+            # 0th device.
+            device_ids.append(0)
+
+        return [torch.device(f"cuda:{device_id}") for device_id in device_ids]
+
+    def set_device(self, device: Union[torch.device, int, str, None]):
+        torch.cuda.set_device(device)
+
+    def supports_stream(self) -> bool:
+        """Validate if the device type support create a stream"""
+        return True
+
+    def create_stream(self, device: torch.device) -> torch.cuda.Stream:
+        """Create a stream on cuda device"""
+        return torch.cuda.Stream(device)
+
+    def get_stream_context(self, stream):
+        """Get a stream context for cuda device"""
+        return torch.cuda.stream(stream)
+
+    def get_current_stream(self) -> torch.cuda.Stream:
+        """Get current stream for cuda device"""
+        return torch.cuda.current_stream()

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/device_manager/torch_device_manager.py

@@ -0,0 +1,40 @@
+from abc import ABC
+from typing import List, Union
+
+import torch
+
+
+class TorchDeviceManager(ABC):
+    """This class contains the function needed for supporting
+    an acclerator family in Ray AI Library.
+    """
+
+    def is_available(self) -> bool:
+        """Validate if device is available."""
+        ...
+
+    def get_devices(self) -> List[torch.device]:
+        """Gets the correct torch device configured for this process"""
+        ...
+
+    def set_device(self, device: Union[torch.device, int, str, None]):
+        """Set the correct device for this process"""
+        ...
+
+    def supports_stream(self) -> bool:
+        """Validate if the device type support create a stream"""
+        ...
+
+    def create_stream(self, device: torch.device):
+        """Create a device stream"""
+        ...
+
+    def get_stream_context(self, stream):
+        """Get a stream context of device. If device didn't support stream,
+        this should return a empty context manager instead of  None.
+        """
+        ...
+
+    def get_current_stream(self):
+        """Get current stream on accelerators like torch.cuda.current_stream"""
+        ...

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/json.py

@@ -0,0 +1,31 @@
+import json
+import numbers
+
+import numpy as np
+
+
+class SafeFallbackEncoder(json.JSONEncoder):
+    def __init__(self, nan_str="null", **kwargs):
+        super(SafeFallbackEncoder, self).__init__(**kwargs)
+        self.nan_str = nan_str
+
+    def default(self, value):
+        try:
+            if type(value).__module__ == np.__name__ and isinstance(value, np.ndarray):
+                return value.tolist()
+
+            if isinstance(value, np.bool_):
+                return bool(value)
+
+            if np.isnan(value):
+                return self.nan_str
+
+            if issubclass(type(value), numbers.Integral):
+                return int(value)
+            if issubclass(type(value), numbers.Number):
+                return float(value)
+
+            return super(SafeFallbackEncoder, self).default(value)
+
+        except Exception:
+            return str(value)  # give up, just stringify it (ok for logs)

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/session.py

@@ -0,0 +1,10 @@
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+# TODO(justinvyu): Move this to train
+def _get_session(warn: bool = False):
+    from ray.train._internal.session import _session as train_session
+
+    return train_session

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/tensorflow_utils.py

@@ -0,0 +1,131 @@
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pyarrow
+import tensorflow as tf
+
+from ray.air.util.data_batch_conversion import _unwrap_ndarray_object_type_if_needed
+from ray.air.util.tensor_extensions.arrow import get_arrow_extension_tensor_types
+
+if TYPE_CHECKING:
+    from ray.data._internal.pandas_block import PandasBlockSchema
+
+
+def convert_ndarray_to_tf_tensor(
+    ndarray: np.ndarray,
+    dtype: Optional[tf.dtypes.DType] = None,
+    type_spec: Optional[tf.TypeSpec] = None,
+) -> tf.Tensor:
+    """Convert a NumPy ndarray to a TensorFlow Tensor.
+
+    Args:
+        ndarray: A NumPy ndarray that we wish to convert to a TensorFlow Tensor.
+        dtype: A TensorFlow dtype for the created tensor; if None, the dtype will be
+            inferred from the NumPy ndarray data.
+        type_spec: A type spec that specifies the shape and dtype of the returned
+            tensor. If you specify ``dtype``, the dtype stored in the type spec is
+            ignored.
+
+    Returns: A TensorFlow Tensor.
+    """
+    if dtype is None and type_spec is not None:
+        dtype = type_spec.dtype
+
+    is_ragged = isinstance(type_spec, tf.RaggedTensorSpec)
+    ndarray = _unwrap_ndarray_object_type_if_needed(ndarray)
+    if is_ragged:
+        return tf.ragged.constant(ndarray, dtype=dtype)
+    else:
+        return tf.convert_to_tensor(ndarray, dtype=dtype)
+
+
+def convert_ndarray_batch_to_tf_tensor_batch(
+    ndarrays: Union[np.ndarray, Dict[str, np.ndarray]],
+    dtypes: Optional[Union[tf.dtypes.DType, Dict[str, tf.dtypes.DType]]] = None,
+) -> Union[tf.Tensor, Dict[str, tf.Tensor]]:
+    """Convert a NumPy ndarray batch to a TensorFlow Tensor batch.
+
+    Args:
+        ndarray: A (dict of) NumPy ndarray(s) that we wish to convert to a TensorFlow
+            Tensor.
+        dtype: A (dict of) TensorFlow dtype(s) for the created tensor; if None, the
+            dtype will be inferred from the NumPy ndarray data.
+
+    Returns: A (dict of) TensorFlow Tensor(s).
+    """
+    if isinstance(ndarrays, np.ndarray):
+        # Single-tensor case.
+        if isinstance(dtypes, dict):
+            if len(dtypes) != 1:
+                raise ValueError(
+                    "When constructing a single-tensor batch, only a single dtype "
+                    f"should be given, instead got: {dtypes}"
+                )
+            dtypes = next(iter(dtypes.values()))
+        batch = convert_ndarray_to_tf_tensor(ndarrays, dtypes)
+    else:
+        # Multi-tensor case.
+        batch = {
+            col_name: convert_ndarray_to_tf_tensor(
+                col_ndarray,
+                dtype=dtypes[col_name] if isinstance(dtypes, dict) else dtypes,
+            )
+            for col_name, col_ndarray in ndarrays.items()
+        }
+
+    return batch
+
+
+def get_type_spec(
+    schema: Union["pyarrow.lib.Schema", "PandasBlockSchema"],
+    columns: Union[str, List[str]],
+) -> Union[tf.TypeSpec, Dict[str, tf.TypeSpec]]:
+    import pyarrow as pa
+
+    from ray.data.extensions import TensorDtype
+
+    tensor_extension_types = get_arrow_extension_tensor_types()
+
+    assert not isinstance(schema, type)
+
+    dtypes: Dict[str, Union[np.dtype, pa.DataType]] = dict(
+        zip(schema.names, schema.types)
+    )
+
+    def get_dtype(dtype: Union[np.dtype, pa.DataType]) -> tf.dtypes.DType:
+        if isinstance(dtype, pa.DataType):
+            dtype = dtype.to_pandas_dtype()
+        if isinstance(dtype, TensorDtype):
+            dtype = dtype.element_dtype
+        return tf.dtypes.as_dtype(dtype)
+
+    def get_shape(dtype: Union[np.dtype, pa.DataType]) -> Tuple[int, ...]:
+        shape = (None,)
+        if isinstance(dtype, tensor_extension_types):
+            dtype = dtype.to_pandas_dtype()
+        if isinstance(dtype, TensorDtype):
+            shape += dtype.element_shape
+        return shape
+
+    def get_tensor_spec(
+        dtype: Union[np.dtype, pa.DataType], *, name: str
+    ) -> tf.TypeSpec:
+        shape, dtype = get_shape(dtype), get_dtype(dtype)
+        # Batch dimension is always `None`. So, if there's more than one `None`-valued
+        # dimension, then the tensor is ragged.
+        is_ragged = sum(dim is None for dim in shape) > 1
+        if is_ragged:
+            type_spec = tf.RaggedTensorSpec(shape, dtype=dtype)
+        else:
+            type_spec = tf.TensorSpec(shape, dtype=dtype, name=name)
+        return type_spec
+
+    if isinstance(columns, str):
+        name, dtype = columns, dtypes[columns]
+        return get_tensor_spec(dtype, name=name)
+
+    return {
+        name: get_tensor_spec(dtype, name=name)
+        for name, dtype in dtypes.items()
+        if name in columns
+    }

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/torch_utils.py

@@ -0,0 +1,294 @@
+import warnings
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+import pandas as pd
+import torch
+
+from ray.air._internal.device_manager import get_torch_device_manager_by_context
+from ray.air.util.data_batch_conversion import _unwrap_ndarray_object_type_if_needed
+
+
+def get_devices() -> List[torch.device]:
+    """Gets the correct torch device list configured for this process.
+
+    Returns a list of torch accelerator (GPU, HPU, NPU...) devices allocated for
+    the current worker.
+    If no accelerators are assigned, then it returns a list with a single CPU device.
+    """
+    return get_torch_device_manager_by_context().get_devices()
+
+
+def convert_pandas_to_torch_tensor(
+    data_batch: pd.DataFrame,
+    columns: Optional[Union[List[str], List[List[str]]]] = None,
+    column_dtypes: Optional[Union[torch.dtype, List[torch.dtype]]] = None,
+    unsqueeze: bool = True,
+) -> Union[torch.Tensor, List[torch.Tensor]]:
+    """Converts a Pandas dataframe to a torch Tensor or list of torch Tensors.
+
+    The format of the return type will match the format of ``columns``. If a
+    list of columns is provided, the return type will be a single tensor. If
+    ``columns`` is a list of lists, then the return type will be a list of
+    tensors.
+
+    Args:
+        data_batch: The pandas dataframe to convert to a
+            torch tensor.
+        columns:
+            The names of the columns in the dataframe to include in the
+            torch tensor. If this arg is a List[List[str]], then the return
+            type will be a List of tensors. This is useful for multi-input
+            models. If None, then use all columns in the ``data_batch``.
+        column_dtype: The
+            torch dtype to use for the tensor. If set to None,
+            then automatically infer the dtype.
+        unsqueeze: If set to True, the tensors
+            will be unsqueezed (reshaped to (N, 1)) before being concatenated into
+            the final tensor. Otherwise, they will be left as is, that is
+            (N, ). Defaults to True.
+
+    Returns:
+        Either a torch tensor of size (N, len(columns)) where N is the
+        number of rows in the ``data_batch`` Dataframe, or a list of
+        tensors, where the size of item i is (N, len(columns[i])).
+
+    """
+
+    multi_input = columns and (isinstance(columns[0], (list, tuple)))
+
+    if not multi_input and column_dtypes and not isinstance(column_dtypes, torch.dtype):
+        raise TypeError(
+            "If `columns` is a list of strings, "
+            "`column_dtypes` must be None or a single `torch.dtype`."
+            f"Got {type(column_dtypes)} instead."
+        )
+
+    columns = columns if columns else []
+
+    def tensorize(vals, dtype):
+        """This recursive function allows to convert pyarrow List dtypes
+        to multi-dimensional tensors."""
+        if isinstance(vals, pd.api.extensions.ExtensionArray):
+            # torch.as_tensor() does not yet support the __array__ protocol, so we need
+            # to convert extension arrays to ndarrays manually before converting to a
+            # Torch tensor.
+            # See https://github.com/pytorch/pytorch/issues/51156.
+            vals = vals.to_numpy()
+
+        if vals.dtype.type is np.object_:
+            # Column has an object dtype which Torch can't handle, so we try to
+            # tensorize each column element and then stack the resulting tensors.
+            tensors = [tensorize(x, dtype) for x in vals]
+            try:
+                return torch.stack(tensors)
+            except RuntimeError:
+                # NOTE: RuntimeError is raised when trying to stack ragged tensors.
+                # Try to coerce the tensor to a nested tensor, if possible.
+                # If this fails, the exception will be propagated up to the caller.
+                return torch.nested_tensor(tensors)
+        else:
+            return torch.as_tensor(vals, dtype=dtype)
+
+    def get_tensor_for_columns(columns, dtype):
+        feature_tensors = []
+
+        if columns:
+            batch = data_batch[columns]
+        else:
+            batch = data_batch
+
+        for col in batch.columns:
+            col_vals = batch[col].values
+            try:
+                t = tensorize(col_vals, dtype=dtype)
+            except Exception as e:
+                raise ValueError(
+                    f"Failed to convert column {col} to a Torch Tensor of dtype "
+                    f"{dtype}. See above exception chain for the exact failure."
+                ) from e
+            if unsqueeze:
+                t = t.unsqueeze(1)
+            feature_tensors.append(t)
+
+        if len(feature_tensors) > 1:
+            feature_tensor = torch.cat(feature_tensors, dim=1)
+        else:
+            feature_tensor = feature_tensors[0]
+        return feature_tensor
+
+    if multi_input:
+        if type(column_dtypes) not in [list, tuple]:
+            column_dtypes = [column_dtypes] * len(columns)
+        return [
+            get_tensor_for_columns(columns=subcolumns, dtype=dtype)
+            for subcolumns, dtype in zip(columns, column_dtypes)
+        ]
+    else:
+        return get_tensor_for_columns(columns=columns, dtype=column_dtypes)
+
+
+def convert_ndarray_to_torch_tensor(
+    ndarray: np.ndarray,
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[str] = None,
+) -> torch.Tensor:
+    """Convert a NumPy ndarray to a Torch Tensor.
+
+    Args:
+        ndarray: A NumPy ndarray that we wish to convert to a Torch Tensor.
+        dtype: A Torch dtype for the created tensor; if None, the dtype will be
+            inferred from the NumPy ndarray data.
+        device: The device on which the tensor(s) should be placed; if None, the Torch
+            tensor(s) will be constructed on the CPU.
+
+    Returns: A Torch Tensor.
+    """
+    ndarray = _unwrap_ndarray_object_type_if_needed(ndarray)
+
+    # Object dtype cannot be converted into PyTorch Tensor.
+    if ndarray.dtype.type is np.object_:
+        raise RuntimeError(
+            "Numpy array of object dtype cannot be converted to a Torch Tensor. This "
+            "may because the numpy array is a ragged tensor--it contains items of "
+            "different sizes. If using `iter_torch_batches()` API, you can pass in a "
+            "`collate_fn` argument to specify custom logic to convert the Numpy array "
+            "batch to a Torch tensor batch."
+        )
+
+    # The numpy array is not always writeable as it can come from the Ray object store.
+    # Numpy will throw a verbose warning here, which we suppress, as we don't write
+    # to the tensors. We also don't want to copy the array to avoid memory overhead.
+    # Original warning: https://github.com/pytorch/pytorch/blob/v1.13.0/
+    # torch/csrc/utils/tensor_numpy.cpp#L198-L206
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore")
+        return torch.as_tensor(ndarray, dtype=dtype, device=device)
+
+
+def convert_ndarray_batch_to_torch_tensor_batch(
+    ndarrays: Union[np.ndarray, Dict[str, np.ndarray]],
+    dtypes: Optional[Union[torch.dtype, Dict[str, torch.dtype]]] = None,
+    device: Optional[str] = None,
+) -> Union[torch.Tensor, Dict[str, torch.Tensor]]:
+    """Convert a NumPy ndarray batch to a Torch Tensor batch.
+
+    Args:
+        ndarray: A (dict of) NumPy ndarray(s) that we wish to convert to a Torch Tensor.
+        dtype: A (dict of) Torch dtype(s) for the created tensor; if None, the dtype
+            will be inferred from the NumPy ndarray data.
+        device: The device on which the tensor(s) should be placed; if None, the Torch
+            tensor(s) will be constructed on the CPU.
+
+    Returns: A (dict of) Torch Tensor(s).
+    """
+    if isinstance(ndarrays, np.ndarray):
+        # Single-tensor case.
+        if isinstance(dtypes, dict):
+            if len(dtypes) != 1:
+                raise ValueError(
+                    "When constructing a single-tensor batch, only a single dtype "
+                    f"should be given, instead got: {dtypes}"
+                )
+            dtypes = next(iter(dtypes.values()))
+        batch = convert_ndarray_to_torch_tensor(ndarrays, dtype=dtypes, device=device)
+    else:
+        # Multi-tensor case.
+        batch = {
+            col_name: convert_ndarray_to_torch_tensor(
+                col_ndarray,
+                dtype=dtypes[col_name] if isinstance(dtypes, dict) else dtypes,
+                device=device,
+            )
+            for col_name, col_ndarray in ndarrays.items()
+        }
+
+    return batch
+
+
+def load_torch_model(
+    saved_model: Union[torch.nn.Module, Dict],
+    model_definition: Optional[torch.nn.Module] = None,
+) -> torch.nn.Module:
+    """Loads a PyTorch model from the provided ``saved_model``.
+
+    ``model_definition`` is only used when ``saved_model`` is
+    a torch state dict, which will be loaded into ``model_definition``.
+    Otherwise, ``model_definition`` is discarded.
+    """
+    if isinstance(saved_model, torch.nn.Module):
+        return saved_model
+    elif isinstance(saved_model, dict):
+        if not model_definition:
+            raise ValueError(
+                "Attempting to load torch model from a "
+                "state_dict, but no `model_definition` was "
+                "provided."
+            )
+        model_definition.load_state_dict(saved_model)
+        return model_definition
+    else:
+        raise ValueError(
+            f"Saved model is of type {type(saved_model)}. "
+            f"The model saved in the checkpoint is expected "
+            f"to be of type `torch.nn.Module`, or a model "
+            f"state dict of type dict."
+        )
+
+
+def contains_tensor(obj):
+    if isinstance(obj, torch.Tensor):
+        return True
+    elif isinstance(obj, dict):
+        for k, v in obj.items():
+            if contains_tensor(k):
+                return True
+            if contains_tensor(v):
+                return True
+    elif isinstance(obj, (list, tuple)):
+        for v in obj:
+            if contains_tensor(v):
+                return True
+    return False
+
+
+# Not present in torch<=1.7.0
+# Adapted from https://github.com/pytorch/pytorch/blob/\
+# c18da597e0bb1c1aecc97c77a73fed1849057fa4/torch/nn/modules/utils.py
+def consume_prefix_in_state_dict_if_present_not_in_place(
+    state_dict: Dict[str, Any], prefix: str
+) -> Dict[str, Any]:
+    """Strip the prefix in state_dict, if any and return a new dict.
+
+    Adapted from https://github.com/pytorch/pytorch/blob/\
+c18da597e0bb1c1aecc97c77a73fed1849057fa4/torch/nn/modules/utils.py
+    The original method modified the dict in-place.
+
+    Args:
+        state_dict: a state-dict to be loaded to the model.
+        prefix: prefix.
+
+    """
+    copied = False
+
+    for key in state_dict:
+        if key.startswith(prefix):
+            newkey = key[len(prefix) :]
+            if not copied:
+                # We are doing shallow copies here, so the performance
+                # impact should be negligible anyway, but this is
+                # a simple optimization.
+                state_dict = state_dict.copy()
+                copied = True
+            state_dict[newkey] = state_dict.pop(key)
+
+    if "_metadata" in state_dict:
+        state_dict["_metadata"] = state_dict["_metadata"].copy()
+        metadata = state_dict["_metadata"]
+        for key in metadata:
+            if len(key) == 0:
+                continue
+            newkey = key[len(prefix) :]
+            metadata[newkey] = metadata.pop(key)
+
+    return state_dict

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/uri_utils.py

@@ -0,0 +1,101 @@
+import os
+import urllib.parse
+from pathlib import Path
+from typing import Union
+
+
+class URI:
+    """Represents a URI, supporting path appending and retrieving parent URIs.
+
+    Example Usage:
+
+        >>> s3_uri = URI("s3://bucket/a?scheme=http&param=1")
+        >>> s3_uri
+        URI<s3://bucket/a?scheme=http&param=1>
+        >>> str(s3_uri / "b" / "c")
+        's3://bucket/a/b/c?scheme=http&param=1'
+        >>> str(s3_uri.parent)
+        's3://bucket?scheme=http&param=1'
+        >>> str(s3_uri)
+        's3://bucket/a?scheme=http&param=1'
+        >>> s3_uri.parent.name, s3_uri.name
+        ('bucket', 'a')
+        >>> local_path = URI("/tmp/local")
+        >>> str(local_path)
+        '/tmp/local'
+        >>> str(local_path.parent)
+        '/tmp'
+        >>> str(local_path / "b" / "c")
+        '/tmp/local/b/c'
+
+    Args:
+        uri: The URI to represent.
+            Ex: s3://bucket?scheme=http&endpoint_override=localhost%3A900
+            Ex: file:///a/b/c/d
+    """
+
+    def __init__(self, uri: str):
+        self._parsed = urllib.parse.urlparse(uri)
+        if not self._parsed.scheme:
+            # Just treat this as a regular path
+            self._path = Path(uri)
+        else:
+            self._path = Path(os.path.normpath(self._parsed.netloc + self._parsed.path))
+
+    def rstrip_subpath(self, subpath: Path) -> "URI":
+        """Returns a new URI that strips the given subpath from the end of this URI.
+
+        Example:
+            >>> uri = URI("s3://bucket/a/b/c/?param=1")
+            >>> str(uri.rstrip_subpath(Path("b/c")))
+            's3://bucket/a?param=1'
+
+            >>> uri = URI("/tmp/a/b/c/")
+            >>> str(uri.rstrip_subpath(Path("/b/c/.//")))
+            '/tmp/a'
+
+        """
+        assert str(self._path).endswith(str(subpath)), (self._path, subpath)
+        stripped_path = str(self._path).replace(str(subpath), "")
+        return URI(self._get_str_representation(self._parsed, stripped_path))
+
+    @property
+    def name(self) -> str:
+        return self._path.name
+
+    @property
+    def parent(self) -> "URI":
+        assert self._path.parent != ".", f"{str(self)} has no valid parent URI"
+        return URI(self._get_str_representation(self._parsed, self._path.parent))
+
+    @property
+    def scheme(self) -> str:
+        return self._parsed.scheme
+
+    @property
+    def path(self) -> str:
+        return str(self._path)
+
+    def __truediv__(self, path_to_append):
+        assert isinstance(path_to_append, str)
+        return URI(
+            self._get_str_representation(self._parsed, self._path / path_to_append)
+        )
+
+    @classmethod
+    def _get_str_representation(
+        cls, parsed_uri: urllib.parse.ParseResult, path: Union[str, Path]
+    ) -> str:
+        if not parsed_uri.scheme:
+            return str(path)
+        return parsed_uri._replace(netloc=str(path), path="").geturl()
+
+    def __repr__(self):
+        return f"URI<{str(self)}>"
+
+    def __str__(self):
+        return self._get_str_representation(self._parsed, self._path)
+
+
+def is_uri(path: str) -> bool:
+    return bool(urllib.parse.urlparse(path).scheme)

infer_4_37_2/lib/python3.10/site-packages/ray/air/_internal/util.py

@@ -0,0 +1,134 @@
+import copy
+import logging
+import os
+import queue
+import socket
+import threading
+from contextlib import closing
+from typing import Optional
+
+import numpy as np
+
+from ray.air.constants import _ERROR_REPORT_TIMEOUT
+
+logger = logging.getLogger(__name__)
+
+
+def find_free_port():
+    with closing(socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as s:
+        s.bind(("", 0))
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        return s.getsockname()[1]
+
+
+def is_nan(value):
+    return np.isnan(value)
+
+
+def is_nan_or_inf(value):
+    return is_nan(value) or np.isinf(value)
+
+
+class StartTraceback(Exception):
+    """These exceptions (and their tracebacks) can be skipped with `skip_exceptions`"""
+
+    pass
+
+
+class StartTracebackWithWorkerRank(StartTraceback):
+    def __init__(self, worker_rank: int) -> None:
+        super().__init__()
+        self.worker_rank = worker_rank
+
+    def __reduce__(self):
+        return (self.__class__, (self.worker_rank,))
+
+
+def skip_exceptions(exc: Optional[Exception]) -> Exception:
+    """Skip all contained `StartTracebacks` to reduce traceback output.
+
+    Returns a shallow copy of the exception with all `StartTracebacks` removed.
+
+    If the RAY_AIR_FULL_TRACEBACKS environment variable is set,
+    the original exception (not a copy) is returned.
+    """
+    should_not_shorten = bool(int(os.environ.get("RAY_AIR_FULL_TRACEBACKS", "0")))
+
+    if should_not_shorten:
+        return exc
+
+    if isinstance(exc, StartTraceback):
+        # If this is a StartTraceback, skip
+        return skip_exceptions(exc.__cause__)
+
+    # Perform a shallow copy to prevent recursive __cause__/__context__.
+    new_exc = copy.copy(exc).with_traceback(exc.__traceback__)
+
+    # Make sure nested exceptions are properly skipped.
+    cause = getattr(exc, "__cause__", None)
+    if cause:
+        new_exc.__cause__ = skip_exceptions(cause)
+
+    return new_exc
+
+
+def exception_cause(exc: Optional[Exception]) -> Optional[Exception]:
+    if not exc:
+        return None
+
+    return getattr(exc, "__cause__", None)
+
+
+class RunnerThread(threading.Thread):
+    """Supervisor thread that runs your script."""
+
+    def __init__(self, *args, error_queue, **kwargs):
+        threading.Thread.__init__(self, *args, **kwargs)
+        self._error_queue = error_queue
+        self._ret = None
+
+    def _propagate_exception(self, e: BaseException):
+        try:
+            # report the error but avoid indefinite blocking which would
+            # prevent the exception from being propagated in the unlikely
+            # case that something went terribly wrong
+            self._error_queue.put(e, block=True, timeout=_ERROR_REPORT_TIMEOUT)
+        except queue.Full:
+            logger.critical(
+                (
+                    "Runner Thread was unable to report error to main "
+                    "function runner thread. This means a previous error "
+                    "was not processed. This should never happen."
+                )
+            )
+
+    def run(self):
+        try:
+            self._ret = self._target(*self._args, **self._kwargs)
+        except StopIteration:
+            logger.debug(
+                (
+                    "Thread runner raised StopIteration. Interpreting it as a "
+                    "signal to terminate the thread without error."
+                )
+            )
+        except SystemExit as e:
+            # Do not propagate up for graceful termination.
+            if e.code == 0:
+                logger.debug(
+                    (
+                        "Thread runner raised SystemExit with error code 0. "
+                        "Interpreting it as a signal to terminate the thread "
+                        "without error."
+                    )
+                )
+            else:
+                # If non-zero exit code, then raise exception to main thread.
+                self._propagate_exception(e)
+        except BaseException as e:
+            # Propagate all other exceptions to the main thread.
+            self._propagate_exception(e)
+
+    def join(self, timeout=None):
+        super(RunnerThread, self).join(timeout)
+        return self._ret

infer_4_37_2/lib/python3.10/site-packages/ray/air/util/tensor_extensions/arrow.py

@@ -0,0 +1,1216 @@
+import abc
+import itertools
+import json
+import logging
+import sys
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import pyarrow as pa
+from packaging.version import parse as parse_version
+
+from ray._private.utils import _get_pyarrow_version
+from ray.air.constants import TENSOR_COLUMN_NAME
+from ray.air.util.tensor_extensions.utils import (
+    _is_ndarray_tensor,
+    _is_ndarray_variable_shaped_tensor,
+    create_ragged_ndarray,
+)
+from ray.data._internal.util import GiB
+from ray.util import log_once
+from ray.util.annotations import DeveloperAPI, PublicAPI
+
+PYARROW_VERSION = _get_pyarrow_version()
+if PYARROW_VERSION is not None:
+    PYARROW_VERSION = parse_version(PYARROW_VERSION)
+# Minimum version of Arrow that supports ExtensionScalars.
+# TODO(Clark): Remove conditional definition once we only support Arrow 8.0.0+.
+MIN_PYARROW_VERSION_SCALAR = parse_version("8.0.0")
+# Minimum version of Arrow that supports subclassable ExtensionScalars.
+# TODO(Clark): Remove conditional definition once we only support Arrow 9.0.0+.
+MIN_PYARROW_VERSION_SCALAR_SUBCLASS = parse_version("9.0.0")
+# Minimum version supporting `zero_copy_only` flag in `ChunkedArray.to_numpy`
+MIN_PYARROW_VERSION_CHUNKED_ARRAY_TO_NUMPY_ZERO_COPY_ONLY = parse_version("13.0.0")
+
+NUM_BYTES_PER_UNICODE_CHAR = 4
+
+# NOTE: Overflow threshold in bytes for most Arrow types using int32 as
+#       its offsets
+INT32_OVERFLOW_THRESHOLD = 2 * GiB
+
+logger = logging.getLogger(__name__)
+
+
+@DeveloperAPI
+class ArrowConversionError(Exception):
+    """Error raised when there is an issue converting data to Arrow."""
+
+    MAX_DATA_STR_LEN = 200
+
+    def __init__(self, data_str: str):
+        if len(data_str) > self.MAX_DATA_STR_LEN:
+            data_str = data_str[: self.MAX_DATA_STR_LEN] + "..."
+        message = f"Error converting data to Arrow: {data_str}"
+        super().__init__(message)
+
+
+def _arrow_supports_extension_scalars():
+    """
+    Whether Arrow ExtensionScalars are supported in the current pyarrow version.
+
+    This returns True if the pyarrow version is 8.0.0+, or if the pyarrow version is
+    unknown.
+    """
+    # TODO(Clark): Remove utility once we only support Arrow 8.0.0+.
+    return PYARROW_VERSION is None or PYARROW_VERSION >= MIN_PYARROW_VERSION_SCALAR
+
+
+def _arrow_extension_scalars_are_subclassable():
+    """
+    Whether Arrow ExtensionScalars support subclassing in the current pyarrow version.
+
+    This returns True if the pyarrow version is 9.0.0+, or if the pyarrow version is
+    unknown.
+    """
+    # TODO(Clark): Remove utility once we only support Arrow 9.0.0+.
+    return (
+        PYARROW_VERSION is None
+        or PYARROW_VERSION >= MIN_PYARROW_VERSION_SCALAR_SUBCLASS
+    )
+
+
+@DeveloperAPI
+def pyarrow_table_from_pydict(
+    pydict: Dict[str, Union[List[Any], pa.Array]],
+) -> pa.Table:
+    """
+    Convert a Python dictionary to a pyarrow Table.
+
+    Raises:
+        ArrowConversionError: if the conversion fails.
+    """
+    try:
+        return pa.Table.from_pydict(pydict)
+    except Exception as e:
+        raise ArrowConversionError(str(pydict)) from e
+
+
+@DeveloperAPI(stability="alpha")
+def convert_to_pyarrow_array(column_values: np.ndarray, column_name: str) -> pa.Array:
+    """Converts provided NumPy `ndarray` into PyArrow's `array` while utilizing
+    both Arrow's natively supported types as well as custom extension types:
+
+        - ArrowTensorArray (for tensors)
+        - ArrowPythonObjectArray (for user-defined python class objects, as well as
+        any python object that aren't represented by a corresponding Arrow's native
+        scalar type)
+    """
+
+    try:
+        # Since Arrow does NOT support tensors (aka multidimensional arrays) natively,
+        # we have to make sure that we handle this case utilizing `ArrowTensorArray`
+        # extension type
+        if column_name == TENSOR_COLUMN_NAME or _is_ndarray_tensor(column_values):
+            from ray.data.extensions.tensor_extension import ArrowTensorArray
+
+            return ArrowTensorArray.from_numpy(column_values, column_name)
+        else:
+            return _convert_to_pyarrow_native_array(column_values, column_name)
+
+    except ArrowConversionError as ace:
+        from ray.data.extensions.object_extension import (
+            ArrowPythonObjectArray,
+            _object_extension_type_allowed,
+        )
+
+        if not _object_extension_type_allowed():
+            should_serialize_as_object_ext_type = False
+            object_ext_type_detail = (
+                "skipping fallback to serialize as pickled python"
+                f" objects (due to unsupported Arrow version {PYARROW_VERSION}, "
+                f"min required version is {MIN_PYARROW_VERSION_SCALAR_SUBCLASS})"
+            )
+        else:
+            from ray.data import DataContext
+
+            if not DataContext.get_current().enable_fallback_to_arrow_object_ext_type:
+                should_serialize_as_object_ext_type = False
+                object_ext_type_detail = (
+                    "skipping fallback to serialize as pickled python objects "
+                    "(due to DataContext.enable_fallback_to_arrow_object_ext_type "
+                    "= False)"
+                )
+            else:
+                should_serialize_as_object_ext_type = True
+                object_ext_type_detail = (
+                    "falling back to serialize as pickled python objects"
+                )
+
+        # NOTE: To avoid logging following warning for every block it's
+        #       only going to be logged in following cases
+        #           - When fallback is disabled, or
+        #           - It's being logged for the first time
+        if not should_serialize_as_object_ext_type or log_once(
+            "_fallback_to_arrow_object_extension_type_warning"
+        ):
+            logger.warning(
+                f"Failed to convert column '{column_name}' into pyarrow "
+                f"array due to: {ace}; {object_ext_type_detail}",
+                exc_info=ace,
+            )
+
+        # If `ArrowPythonObjectType` is not supported raise original exception
+        if not should_serialize_as_object_ext_type:
+            raise
+
+        # Otherwise, attempt to fall back to serialize as python objects
+        return ArrowPythonObjectArray.from_objects(column_values)
+
+
+def _convert_to_pyarrow_native_array(
+    column_values: np.ndarray, column_name: str
+) -> pa.Array:
+    """Converts provided NumPy `ndarray` into PyArrow's `array` while only utilizing
+    Arrow's natively supported types (ie no custom extension types)"""
+
+    try:
+        # NOTE: We explicitly infer PyArrow `DataType` so that
+        #       we can perform upcasting to be able to accommodate
+        #       blocks that are larger than 2Gb in size (limited
+        #       by int32 offsets used by Arrow internally)
+        dtype = _infer_pyarrow_type(column_values)
+
+        logger.log(
+            logging.getLevelName("TRACE"),
+            f"Inferred dtype of '{dtype}' for column '{column_name}'",
+        )
+
+        return pa.array(column_values, type=dtype)
+    except Exception as e:
+        raise ArrowConversionError(str(column_values)) from e
+
+
+def _infer_pyarrow_type(column_values: np.ndarray) -> Optional[pa.DataType]:
+    """Infers target Pyarrow `DataType` based on the provided
+    columnar values.
+
+    NOTE: This is a wrapper on top of `pa.infer_type(...)` utility
+          performing up-casting of `binary` and `string` types to
+          corresponding `large_binary` and `large_string` types in case
+          any of the array elements exceeds 2Gb in size therefore
+          making it impossible for original types to accommodate such
+          values.
+
+          Unfortunately, for unknown reasons PA doesn't perform
+          that upcasting itself henceforth we have to do perform
+          it manually
+
+    Args:
+        column_values: List of columnar values
+
+    Returns:
+        Instance of PyArrow's `DataType` based on the provided
+        column values
+    """
+
+    if len(column_values) == 0:
+        return None
+
+    inferred_pa_dtype = pa.infer_type(column_values)
+
+    def _len_gt_overflow_threshold(obj: Any) -> bool:
+        # NOTE: This utility could be seeing objects other than strings or bytes in
+        #       cases when column contains non-scalar non-homogeneous object types as
+        #       column values, therefore making Arrow unable to infer corresponding
+        #       column type appropriately, therefore falling back to assume the type
+        #       of the first element in the list.
+        #
+        #       Check out test cases for this method for an additional context.
+        if isinstance(obj, (str, bytes)):
+            return len(obj) > INT32_OVERFLOW_THRESHOLD
+
+        return False
+
+    if pa.types.is_binary(inferred_pa_dtype) and any(
+        [_len_gt_overflow_threshold(v) for v in column_values]
+    ):
+        return pa.large_binary()
+    elif pa.types.is_string(inferred_pa_dtype) and any(
+        [_len_gt_overflow_threshold(v) for v in column_values]
+    ):
+        return pa.large_string()
+
+    return inferred_pa_dtype
+
+
+@DeveloperAPI
+def get_arrow_extension_tensor_types():
+    """Returns list of extension types of Arrow Array holding
+    multidimensional tensors
+    """
+    return (
+        *get_arrow_extension_fixed_shape_tensor_types(),
+        *get_arrow_extension_variable_shape_tensor_types(),
+    )
+
+
+@DeveloperAPI
+def get_arrow_extension_fixed_shape_tensor_types():
+    """Returns list of Arrow extension types holding multidimensional
+    tensors of *fixed* shape
+    """
+    return ArrowTensorType, ArrowTensorTypeV2
+
+
+@DeveloperAPI
+def get_arrow_extension_variable_shape_tensor_types():
+    """Returns list of Arrow extension types holding multidimensional
+    tensors of *fixed* shape
+    """
+    return (ArrowVariableShapedTensorType,)
+
+
+class _BaseFixedShapeArrowTensorType(pa.ExtensionType, abc.ABC):
+    """
+    Arrow ExtensionType for an array of fixed-shaped, homogeneous-typed
+    tensors.
+
+    This is the Arrow side of TensorDtype.
+
+    See Arrow extension type docs:
+    https://arrow.apache.org/docs/python/extending_types.html#defining-extension-types-user-defined-types
+    """
+
+    def __init__(
+        self, shape: Tuple[int, ...], tensor_dtype: pa.DataType, ext_type_id: str
+    ):
+        self._shape = shape
+
+        super().__init__(tensor_dtype, ext_type_id)
+
+    @property
+    def shape(self):
+        """
+        Shape of contained tensors.
+        """
+        return self._shape
+
+    @property
+    def scalar_type(self):
+        """Returns the type of the underlying tensor elements."""
+        return self.storage_type.value_type
+
+    def to_pandas_dtype(self):
+        """
+        Convert Arrow extension type to corresponding Pandas dtype.
+
+        Returns:
+            An instance of pd.api.extensions.ExtensionDtype.
+        """
+        from ray.air.util.tensor_extensions.pandas import TensorDtype
+
+        return TensorDtype(self._shape, self.scalar_type.to_pandas_dtype())
+
+    def __reduce__(self):
+        return self.__arrow_ext_deserialize__, (
+            self.storage_type,
+            self.__arrow_ext_serialize__(),
+        )
+
+    def __arrow_ext_serialize__(self):
+        return json.dumps(self._shape).encode()
+
+    def __arrow_ext_class__(self):
+        """
+        ExtensionArray subclass with custom logic for this array of tensors
+        type.
+
+        Returns:
+            A subclass of pd.api.extensions.ExtensionArray.
+        """
+        return ArrowTensorArray
+
+    if _arrow_extension_scalars_are_subclassable():
+        # TODO(Clark): Remove this version guard once we only support Arrow 9.0.0+.
+        def __arrow_ext_scalar_class__(self):
+            """
+            ExtensionScalar subclass with custom logic for this array of tensors type.
+            """
+            return ArrowTensorScalar
+
+    if _arrow_supports_extension_scalars():
+        # TODO(Clark): Remove this version guard once we only support Arrow 8.0.0+.
+        def _extension_scalar_to_ndarray(
+            self, scalar: pa.ExtensionScalar
+        ) -> np.ndarray:
+            """
+            Convert an ExtensionScalar to a tensor element.
+            """
+            raw_values = scalar.value.values
+            shape = scalar.type.shape
+            value_type = raw_values.type
+            offset = raw_values.offset
+            data_buffer = raw_values.buffers()[1]
+            return _to_ndarray_helper(shape, value_type, offset, data_buffer)
+
+    def __str__(self) -> str:
+        return (
+            f"numpy.ndarray(shape={self.shape}, dtype={self.storage_type.value_type})"
+        )
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    @classmethod
+    def _need_variable_shaped_tensor_array(
+        cls,
+        array_types: Sequence[
+            Union[
+                "ArrowTensorType", "ArrowTensorTypeV2", "ArrowVariableShapedTensorType"
+            ]
+        ],
+    ) -> bool:
+        """
+        Whether the provided list of tensor types needs a variable-shaped
+        representation (i.e. `ArrowVariableShapedTensorType`) when concatenating
+        or chunking. If one or more of the tensor types in `array_types` are
+        variable-shaped and/or any of the tensor arrays have a different shape
+        than the others, a variable-shaped tensor array representation will be
+        required and this method will return True.
+
+        Args:
+            array_types: List of tensor types to check if a variable-shaped
+            representation is required for concatenation
+
+        Returns:
+            True if concatenating arrays with types `array_types` requires
+            a variable-shaped representation
+        """
+        shape = None
+        for arr_type in array_types:
+            # If at least one of the arrays is variable-shaped, we can immediately
+            # short-circuit since we require a variable-shaped representation.
+            if isinstance(arr_type, ArrowVariableShapedTensorType):
+                return True
+            if not isinstance(arr_type, get_arrow_extension_fixed_shape_tensor_types()):
+                raise ValueError(
+                    "All provided array types must be an instance of either "
+                    "ArrowTensorType or ArrowVariableShapedTensorType, but "
+                    f"got {arr_type}"
+                )
+            # We need variable-shaped representation if any of the tensor arrays have
+            # different shapes.
+            if shape is not None and arr_type.shape != shape:
+                return True
+            shape = arr_type.shape
+        return False
+
+
+@PublicAPI(stability="beta")
+class ArrowTensorType(_BaseFixedShapeArrowTensorType):
+    """Arrow ExtensionType (v1) for tensors.
+
+    NOTE: This type does *NOT* support tensors larger than 4Gb (due to
+          overflow of int32 offsets utilized inside Pyarrow `ListType`)
+    """
+
+    OFFSET_DTYPE = np.int32
+
+    def __init__(self, shape: Tuple[int, ...], dtype: pa.DataType):
+        """
+        Construct the Arrow extension type for array of fixed-shaped tensors.
+
+        Args:
+            shape: Shape of contained tensors.
+            dtype: pyarrow dtype of tensor elements.
+        """
+
+        super().__init__(shape, pa.list_(dtype), "ray.data.arrow_tensor")
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        shape = tuple(json.loads(serialized))
+        return cls(shape, storage_type.value_type)
+
+
+@PublicAPI(stability="alpha")
+class ArrowTensorTypeV2(_BaseFixedShapeArrowTensorType):
+    """Arrow ExtensionType (v2) for tensors (supporting tensors > 4Gb)."""
+
+    OFFSET_DTYPE = np.int64
+
+    def __init__(self, shape: Tuple[int, ...], dtype: pa.DataType):
+        """
+        Construct the Arrow extension type for array of fixed-shaped tensors.
+
+        Args:
+            shape: Shape of contained tensors.
+            dtype: pyarrow dtype of tensor elements.
+        """
+
+        super().__init__(shape, pa.large_list(dtype), "ray.data.arrow_tensor_v2")
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        shape = tuple(json.loads(serialized))
+        return cls(shape, storage_type.value_type)
+
+
+if _arrow_extension_scalars_are_subclassable():
+    # TODO(Clark): Remove this version guard once we only support Arrow 9.0.0+.
+    @PublicAPI(stability="beta")
+    class ArrowTensorScalar(pa.ExtensionScalar):
+        def as_py(self) -> np.ndarray:
+            return self.type._extension_scalar_to_ndarray(self)
+
+        def __array__(self) -> np.ndarray:
+            return self.as_py()
+
+
+# TODO(Clark): Remove this mixin once we only support Arrow 9.0.0+.
+class _ArrowTensorScalarIndexingMixin:
+    """
+    A mixin providing support for scalar indexing in tensor extension arrays for
+    Arrow < 9.0.0, before full ExtensionScalar support was added. This mixin overrides
+    __getitem__, __iter__, and to_pylist.
+    """
+
+    # This mixin will be a no-op (no methods added) for Arrow 9.0.0+.
+    if not _arrow_extension_scalars_are_subclassable():
+        # NOTE: These __iter__ and to_pylist definitions are shared for both
+        # Arrow < 8.0.0 and Arrow 8.*.
+        def __iter__(self):
+            # Override pa.Array.__iter__() in order to return an iterator of
+            # properly shaped tensors instead of an iterator of flattened tensors.
+            # See comment in above __getitem__ method.
+            for i in range(len(self)):
+                # Use overridden __getitem__ method.
+                yield self.__getitem__(i)
+
+        def to_pylist(self):
+            # Override pa.Array.to_pylist() due to a lack of ExtensionScalar
+            # support (see comment in __getitem__).
+            return list(self)
+
+        if _arrow_supports_extension_scalars():
+            # NOTE(Clark): This __getitem__ override is only needed for Arrow 8.*,
+            # before ExtensionScalar subclassing support was added.
+            # TODO(Clark): Remove these methods once we only support Arrow 9.0.0+.
+            def __getitem__(self, key):
+                # This __getitem__ hook allows us to support proper indexing when
+                # accessing a single tensor (a "scalar" item of the array). Without this
+                # hook for integer keys, the indexing will fail on pyarrow < 9.0.0 due
+                # to a lack of ExtensionScalar subclassing support.
+
+                # NOTE(Clark): We'd like to override the pa.Array.getitem() helper
+                # instead, which would obviate the need for overriding __iter__(), but
+                # unfortunately overriding Cython cdef methods with normal Python
+                # methods isn't allowed.
+                item = super().__getitem__(key)
+                if not isinstance(key, slice):
+                    item = item.type._extension_scalar_to_ndarray(item)
+                return item
+
+        else:
+            # NOTE(Clark): This __getitem__ override is only needed for Arrow < 8.0.0,
+            # before any ExtensionScalar support was added.
+            # TODO(Clark): Remove these methods once we only support Arrow 8.0.0+.
+            def __getitem__(self, key):
+                # This __getitem__ hook allows us to support proper indexing when
+                # accessing a single tensor (a "scalar" item of the array). Without this
+                # hook for integer keys, the indexing will fail on pyarrow < 8.0.0 due
+                # to a lack of ExtensionScalar support.
+
+                # NOTE(Clark): We'd like to override the pa.Array.getitem() helper
+                # instead, which would obviate the need for overriding __iter__(), but
+                # unfortunately overriding Cython cdef methods with normal Python
+                # methods isn't allowed.
+                if isinstance(key, slice):
+                    return super().__getitem__(key)
+                return self._to_numpy(key)
+
+
+# NOTE: We need to inherit from the mixin before pa.ExtensionArray to ensure that the
+# mixin's overriding methods appear first in the MRO.
+# TODO(Clark): Remove this mixin once we only support Arrow 9.0.0+.
+@PublicAPI(stability="beta")
+class ArrowTensorArray(_ArrowTensorScalarIndexingMixin, pa.ExtensionArray):
+    """
+    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
+    """
+
+    @classmethod
+    def from_numpy(
+        cls,
+        arr: Union[np.ndarray, Iterable[np.ndarray]],
+        column_name: Optional[str] = None,
+    ) -> Union["ArrowTensorArray", "ArrowVariableShapedTensorArray"]:
+        """
+        Convert an ndarray or an iterable of ndarrays to an array of homogeneous-typed
+        tensors. If given fixed-shape tensor elements, this will return an
+        ``ArrowTensorArray``; if given variable-shape tensor elements, this will return
+        an ``ArrowVariableShapedTensorArray``.
+
+        Args:
+            arr: An ndarray or an iterable of ndarrays.
+            column_name: Optional. Used only in logging outputs to provide
+                additional details.
+
+        Returns:
+            - If fixed-shape tensor elements, an ``ArrowTensorArray`` containing
+              ``len(arr)`` tensors of fixed shape.
+            - If variable-shaped tensor elements, an ``ArrowVariableShapedTensorArray``
+              containing ``len(arr)`` tensors of variable shape.
+            - If scalar elements, a ``pyarrow.Array``.
+        """
+        if not isinstance(arr, np.ndarray) and isinstance(arr, Iterable):
+            arr = list(arr)
+
+        if isinstance(arr, (list, tuple)) and arr and isinstance(arr[0], np.ndarray):
+            # Stack ndarrays and pass through to ndarray handling logic below.
+            try:
+                arr = np.stack(arr, axis=0)
+            except ValueError as ve:
+                logger.warning(
+                    f"Failed to stack lists due to: {ve}; "
+                    f"falling back to using np.array(..., dtype=object)",
+                    exc_info=ve,
+                )
+
+                # ndarray stacking may fail if the arrays are heterogeneously-shaped.
+                arr = np.array(arr, dtype=object)
+        if not isinstance(arr, np.ndarray):
+            raise ValueError(
+                f"Must give ndarray or iterable of ndarrays, got {type(arr)} {arr}"
+            )
+
+        try:
+            return cls._from_numpy(arr)
+        except Exception as e:
+            data_str = ""
+            if column_name:
+                data_str += f"column: '{column_name}', "
+            data_str += f"shape: {arr.shape}, dtype: {arr.dtype}, data: {arr}"
+            raise ArrowConversionError(data_str) from e
+
+    @classmethod
+    def _from_numpy(
+        cls,
+        arr: np.ndarray,
+    ) -> Union["ArrowTensorArray", "ArrowVariableShapedTensorArray"]:
+        if len(arr) > 0 and np.isscalar(arr[0]):
+            # Elements are scalar so a plain Arrow Array will suffice.
+            return pa.array(arr)
+        if _is_ndarray_variable_shaped_tensor(arr):
+            # Tensor elements have variable shape, so we delegate to
+            # ArrowVariableShapedTensorArray.
+            return ArrowVariableShapedTensorArray.from_numpy(arr)
+        if not arr.flags.c_contiguous:
+            # We only natively support C-contiguous ndarrays.
+            arr = np.ascontiguousarray(arr)
+        scalar_dtype = pa.from_numpy_dtype(arr.dtype)
+        if pa.types.is_string(scalar_dtype):
+            if arr.dtype.byteorder == ">" or (
+                arr.dtype.byteorder == "=" and sys.byteorder == "big"
+            ):
+                raise ValueError(
+                    "Only little-endian string tensors are supported, "
+                    f"but got: {arr.dtype}",
+                )
+            scalar_dtype = pa.binary(arr.dtype.itemsize)
+        outer_len = arr.shape[0]
+        element_shape = arr.shape[1:]
+        total_num_items = arr.size
+        num_items_per_element = np.prod(element_shape) if element_shape else 1
+
+        # Data buffer.
+        if pa.types.is_boolean(scalar_dtype):
+            # NumPy doesn't represent boolean arrays as bit-packed, so we manually
+            # bit-pack the booleans before handing the buffer off to Arrow.
+            # NOTE: Arrow expects LSB bit-packed ordering.
+            # NOTE: This creates a copy.
+            arr = np.packbits(arr, bitorder="little")
+        data_buffer = pa.py_buffer(arr)
+        data_array = pa.Array.from_buffers(
+            scalar_dtype, total_num_items, [None, data_buffer]
+        )
+
+        from ray.data import DataContext
+
+        if DataContext.get_current().use_arrow_tensor_v2:
+            pa_type_ = ArrowTensorTypeV2(element_shape, scalar_dtype)
+        else:
+            pa_type_ = ArrowTensorType(element_shape, scalar_dtype)
+
+        # Create Offset buffer
+        offset_buffer = pa.py_buffer(
+            pa_type_.OFFSET_DTYPE(
+                [i * num_items_per_element for i in range(outer_len + 1)]
+            )
+        )
+
+        storage = pa.Array.from_buffers(
+            pa_type_.storage_type,
+            outer_len,
+            [None, offset_buffer],
+            children=[data_array],
+        )
+
+        return pa.ExtensionArray.from_storage(pa_type_, storage)
+
+    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.type.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)
+
+    def to_numpy(self, zero_copy_only: bool = True):
+        """
+        Convert the entire array of tensors into a single ndarray.
+
+        Args:
+            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:
+            A single ndarray representing the entire array of tensors.
+        """
+        return self._to_numpy(zero_copy_only=zero_copy_only)
+
+    @classmethod
+    def _concat_same_type(
+        cls,
+        to_concat: Sequence[
+            Union["ArrowTensorArray", "ArrowVariableShapedTensorArray"]
+        ],
+    ) -> Union["ArrowTensorArray", "ArrowVariableShapedTensorArray"]:
+        """
+        Concatenate multiple tensor arrays.
+
+        If one or more of the tensor arrays in to_concat are variable-shaped and/or any
+        of the tensor arrays have a different shape than the others, a variable-shaped
+        tensor array will be returned.
+        """
+        to_concat_types = [arr.type for arr in to_concat]
+        if ArrowTensorType._need_variable_shaped_tensor_array(to_concat_types):
+            # Need variable-shaped tensor array.
+            # TODO(Clark): Eliminate this NumPy roundtrip by directly constructing the
+            # underlying storage array buffers (NumPy roundtrip will not be zero-copy
+            # for e.g. boolean arrays).
+            # NOTE(Clark): Iterating over a tensor extension array converts each element
+            # to an ndarray view.
+            return ArrowVariableShapedTensorArray.from_numpy(
+                [e for a in to_concat for e in a]
+            )
+        else:
+            storage = pa.concat_arrays([c.storage for c in to_concat])
+
+            return ArrowTensorArray.from_storage(to_concat[0].type, storage)
+
+    @classmethod
+    def _chunk_tensor_arrays(
+        cls, arrs: Sequence[Union["ArrowTensorArray", "ArrowVariableShapedTensorArray"]]
+    ) -> pa.ChunkedArray:
+        """
+        Create a ChunkedArray from multiple tensor arrays.
+        """
+        arrs_types = [arr.type for arr in arrs]
+        if ArrowTensorType._need_variable_shaped_tensor_array(arrs_types):
+            new_arrs = []
+            for a in arrs:
+                if isinstance(a.type, get_arrow_extension_fixed_shape_tensor_types()):
+                    a = a.to_variable_shaped_tensor_array()
+                assert isinstance(a.type, ArrowVariableShapedTensorType)
+                new_arrs.append(a)
+            arrs = new_arrs
+        return pa.chunked_array(arrs)
+
+    def to_variable_shaped_tensor_array(self) -> "ArrowVariableShapedTensorArray":
+        """
+        Convert this tensor array to a variable-shaped tensor array.
+
+        This is primarily used when concatenating multiple chunked tensor arrays where
+        at least one chunked array is already variable-shaped and/or the shapes of the
+        chunked arrays differ, in which case the resulting concatenated tensor array
+        will need to be in the variable-shaped representation.
+        """
+        # TODO(Clark): Eliminate this NumPy roundtrip by directly constructing the
+        # underlying storage array buffers (NumPy roundtrip will not be zero-copy for
+        # e.g. boolean arrays).
+        return ArrowVariableShapedTensorArray.from_numpy(self.to_numpy())
+
+
+@PublicAPI(stability="alpha")
+class ArrowVariableShapedTensorType(pa.ExtensionType):
+    """
+    Arrow ExtensionType for an array of heterogeneous-shaped, homogeneous-typed
+    tensors.
+
+    This is the Arrow side of TensorDtype for tensor elements with different shapes.
+    Note that this extension only supports non-ragged tensor elements; i.e., when
+    considering each tensor element in isolation, they must have a well-defined,
+    non-ragged shape.
+
+    See Arrow extension type docs:
+    https://arrow.apache.org/docs/python/extending_types.html#defining-extension-types-user-defined-types
+    """
+
+    def __init__(self, dtype: pa.DataType, ndim: int):
+        """
+        Construct the Arrow extension type for array of heterogeneous-shaped tensors.
+
+        Args:
+            dtype: pyarrow dtype of tensor elements.
+            ndim: The number of dimensions in the tensor elements.
+        """
+        self._ndim = ndim
+        super().__init__(
+            pa.struct(
+                [("data", pa.large_list(dtype)), ("shape", pa.list_(pa.int64()))]
+            ),
+            "ray.data.arrow_variable_shaped_tensor",
+        )
+
+    def to_pandas_dtype(self):
+        """
+        Convert Arrow extension type to corresponding Pandas dtype.
+
+        Returns:
+            An instance of pd.api.extensions.ExtensionDtype.
+        """
+        from ray.air.util.tensor_extensions.pandas import TensorDtype
+
+        return TensorDtype(
+            (None,) * self.ndim,
+            self.storage_type["data"].type.value_type.to_pandas_dtype(),
+        )
+
+    @property
+    def ndim(self) -> int:
+        """Return the number of dimensions in the tensor elements."""
+        return self._ndim
+
+    @property
+    def scalar_type(self):
+        """Returns the type of the underlying tensor elements."""
+        data_field_index = self.storage_type.get_field_index("data")
+        return self.storage_type[data_field_index].type.value_type
+
+    def __reduce__(self):
+        return self.__arrow_ext_deserialize__, (
+            self.storage_type,
+            self.__arrow_ext_serialize__(),
+        )
+
+    def __arrow_ext_serialize__(self):
+        return json.dumps(self._ndim).encode()
+
+    @classmethod
+    def __arrow_ext_deserialize__(cls, storage_type, serialized):
+        ndim = json.loads(serialized)
+        dtype = storage_type["data"].type.value_type
+        return cls(dtype, ndim)
+
+    def __arrow_ext_class__(self):
+        """
+        ExtensionArray subclass with custom logic for this array of tensors
+        type.
+
+        Returns:
+            A subclass of pd.api.extensions.ExtensionArray.
+        """
+        return ArrowVariableShapedTensorArray
+
+    if _arrow_extension_scalars_are_subclassable():
+        # TODO(Clark): Remove this version guard once we only support Arrow 9.0.0+.
+        def __arrow_ext_scalar_class__(self):
+            """
+            ExtensionScalar subclass with custom logic for this array of tensors type.
+            """
+            return ArrowTensorScalar
+
+    def __str__(self) -> str:
+        dtype = self.storage_type["data"].type.value_type
+        return f"numpy.ndarray(ndim={self.ndim}, dtype={dtype})"
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    if _arrow_supports_extension_scalars():
+        # TODO(Clark): Remove this version guard once we only support Arrow 8.0.0+.
+        def _extension_scalar_to_ndarray(
+            self, scalar: pa.ExtensionScalar
+        ) -> np.ndarray:
+            """
+            Convert an ExtensionScalar to a tensor element.
+            """
+            data = scalar.value.get("data")
+            raw_values = data.values
+
+            shape = tuple(scalar.value.get("shape").as_py())
+            value_type = raw_values.type
+            offset = raw_values.offset
+            data_buffer = raw_values.buffers()[1]
+            return _to_ndarray_helper(shape, value_type, offset, data_buffer)
+
+
+# NOTE: We need to inherit from the mixin before pa.ExtensionArray to ensure that the
+# mixin's overriding methods appear first in the MRO.
+# TODO(Clark): Remove this mixin once we only support Arrow 9.0.0+.
+@PublicAPI(stability="alpha")
+class ArrowVariableShapedTensorArray(
+    _ArrowTensorScalarIndexingMixin, pa.ExtensionArray
+):
+    """
+    An array of heterogeneous-shaped, homogeneous-typed tensors.
+
+    This is the Arrow side of TensorArray for tensor elements that have differing
+    shapes. Note that this extension only supports non-ragged tensor elements; i.e.,
+    when considering each tensor element in isolation, they must have a well-defined
+    shape. This extension also only supports tensor elements that all have the same
+    number of dimensions.
+
+    See Arrow docs for customizing extension arrays:
+    https://arrow.apache.org/docs/python/extending_types.html#custom-extension-array-class
+    """
+
+    @classmethod
+    def from_numpy(
+        cls, arr: Union[np.ndarray, List[np.ndarray], Tuple[np.ndarray]]
+    ) -> "ArrowVariableShapedTensorArray":
+        """
+        Convert an ndarray or an iterable of heterogeneous-shaped ndarrays to an array
+        of heterogeneous-shaped, homogeneous-typed tensors.
+
+        Args:
+            arr: An ndarray or an iterable of heterogeneous-shaped ndarrays.
+
+        Returns:
+            An ArrowVariableShapedTensorArray containing len(arr) tensors of
+            heterogeneous shape.
+        """
+        # Implementation note - Arrow representation of ragged tensors:
+        #
+        # We represent an array of ragged tensors using a struct array containing two
+        # fields:
+        #  - data: a variable-sized list array, where each element in the array is a
+        #    tensor element stored in a 1D (raveled) variable-sized list of the
+        #    underlying scalar data type.
+        #  - shape: a variable-sized list array containing the shapes of each tensor
+        #    element.
+        if not isinstance(arr, (list, tuple, np.ndarray)):
+            raise ValueError(
+                "ArrowVariableShapedTensorArray can only be constructed from an "
+                f"ndarray or a list/tuple of ndarrays, but got: {type(arr)}"
+            )
+        if len(arr) == 0:
+            # Empty ragged tensor arrays are not supported.
+            raise ValueError("Creating empty ragged tensor arrays is not supported.")
+
+        # Whether all subndarrays are contiguous views of the same ndarray.
+        shapes, sizes, raveled = [], [], []
+        ndim = None
+        for a in arr:
+            a = np.asarray(a)
+            if ndim is not None and a.ndim != ndim:
+                raise ValueError(
+                    "ArrowVariableShapedTensorArray only supports tensor elements that "
+                    "all have the same number of dimensions, but got tensor elements "
+                    f"with dimensions: {ndim}, {a.ndim}"
+                )
+            ndim = a.ndim
+            shapes.append(a.shape)
+            sizes.append(a.size)
+            # Convert to 1D array view; this should be zero-copy in the common case.
+            # NOTE: If array is not in C-contiguous order, this will convert it to
+            # C-contiguous order, incurring a copy.
+            a = np.ravel(a, order="C")
+            raveled.append(a)
+        # Get size offsets and total size.
+        sizes = np.array(sizes)
+        size_offsets = np.cumsum(sizes)
+        total_size = size_offsets[-1]
+        # Concatenate 1D views into a contiguous 1D array.
+        if all(_is_contiguous_view(curr, prev) for prev, curr in _pairwise(raveled)):
+            # An optimized zero-copy path if raveled tensor elements are already
+            # contiguous in memory, e.g. if this tensor array has already done a
+            # roundtrip through our Arrow representation.
+            np_data_buffer = raveled[-1].base
+        else:
+            np_data_buffer = np.concatenate(raveled)
+        dtype = np_data_buffer.dtype
+        pa_dtype = pa.from_numpy_dtype(dtype)
+        if pa.types.is_string(pa_dtype):
+            if dtype.byteorder == ">" or (
+                dtype.byteorder == "=" and sys.byteorder == "big"
+            ):
+                raise ValueError(
+                    "Only little-endian string tensors are supported, "
+                    f"but got: {dtype}"
+                )
+            pa_dtype = pa.binary(dtype.itemsize)
+        if dtype.type is np.bool_:
+            # NumPy doesn't represent boolean arrays as bit-packed, so we manually
+            # bit-pack the booleans before handing the buffer off to Arrow.
+            # NOTE: Arrow expects LSB bit-packed ordering.
+            # NOTE: This creates a copy.
+            np_data_buffer = np.packbits(np_data_buffer, bitorder="little")
+        data_buffer = pa.py_buffer(np_data_buffer)
+        # Construct underlying data array.
+        value_array = pa.Array.from_buffers(pa_dtype, total_size, [None, data_buffer])
+        # Construct array for offsets into the 1D data array, where each offset
+        # corresponds to a tensor element.
+        size_offsets = np.insert(size_offsets, 0, 0)
+        offset_array = pa.array(size_offsets)
+        data_array = pa.LargeListArray.from_arrays(offset_array, value_array)
+        # We store the tensor element shapes so we can reconstruct each tensor when
+        # converting back to NumPy ndarrays.
+        shape_array = pa.array(shapes)
+        # Build storage array containing tensor data and the tensor element shapes.
+        storage = pa.StructArray.from_arrays(
+            [data_array, shape_array],
+            ["data", "shape"],
+        )
+        type_ = ArrowVariableShapedTensorType(pa_dtype, ndim)
+        return pa.ExtensionArray.from_storage(type_, storage)
+
+    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?
+        if index is None:
+            # Get individual ndarrays for each tensor element.
+            arrs = [self._to_numpy(i, zero_copy_only) for i in range(len(self))]
+            # Return ragged NumPy ndarray in the ndarray of ndarray pointers
+            # representation.
+            return create_ragged_ndarray(arrs)
+        data = self.storage.field("data")
+        shapes = self.storage.field("shape")
+
+        shape = shapes[index].as_py()
+        value_type = data.type.value_type
+        offset = data.offsets[index].as_py()
+        data_buffer = data.buffers()[3]
+        return _to_ndarray_helper(shape, value_type, offset, data_buffer)
+
+    def to_numpy(self, zero_copy_only: bool = True):
+        """
+        Convert the entire array of tensors into a single ndarray.
+
+        Args:
+            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:
+            A single ndarray representing the entire array of tensors.
+        """
+        return self._to_numpy(zero_copy_only=zero_copy_only)
+
+
+def _is_contiguous_view(curr: np.ndarray, prev: Optional[np.ndarray]) -> bool:
+    """Check if the provided tensor element is contiguous with the previous tensor
+    element.
+
+    Args:
+        curr: The tensor element whose contiguity that we wish to check.
+        prev: The previous tensor element in the tensor array.
+
+    Returns:
+        Whether the provided tensor element is contiguous with the previous tensor
+        element.
+    """
+    if (
+        curr.base is None
+        or not curr.data.c_contiguous
+        or (prev is not None and curr.base is not prev.base)
+    ):
+        # curr is either:
+        # - not a view,
+        # - not in C-contiguous order,
+        # - a view that does not share its base with the other subndarrays.
+        return False
+    else:
+        # curr is a C-contiguous view that shares the same base with the seen
+        # subndarrays, but we need to confirm that it is contiguous with the
+        # previous subndarray.
+        if prev is not None and (
+            _get_buffer_address(curr) - _get_buffer_address(prev)
+            != prev.base.dtype.itemsize * prev.size
+        ):
+            # This view is not contiguous with the previous view.
+            return False
+        else:
+            return True
+
+
+def _get_buffer_address(arr: np.ndarray) -> int:
+    """Get the address of the buffer underlying the provided NumPy ndarray."""
+    return arr.__array_interface__["data"][0]
+
+
+def _pairwise(iterable):
+    # pairwise('ABCDEFG') --> AB BC CD DE EF FG
+    # Backport of itertools.pairwise for Python < 3.10.
+    a, b = itertools.tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+def _to_ndarray_helper(shape, value_type, offset, data_buffer):
+    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
+    data_offset = buffer_item_width * offset
+
+    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 = data_offset // 8
+        # Offset for a specific boolean, within a uint8 array element.
+        bool_offset = data_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)
+    ext_dtype = value_type.to_pandas_dtype()
+    # Special handling of ragged string tensors
+    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=data_offset)
+
+
+try:
+    # Registration needs an extension type instance, but then works for any instance of
+    # the same subclass regardless of parametrization of the type.
+    pa.register_extension_type(ArrowTensorType((0,), pa.int64()))
+    pa.register_extension_type(ArrowTensorTypeV2((0,), pa.int64()))
+    pa.register_extension_type(ArrowVariableShapedTensorType(pa.int64(), 0))
+except pa.ArrowKeyError:
+    # Extension types are already registered.
+    pass

infer_4_37_2/lib/python3.10/site-packages/ray/air/util/tensor_extensions/pandas.py

@@ -0,0 +1,1451 @@
+# Adapted from
+# https://github.com/CODAIT/text-extensions-for-pandas/blob/dc03278689fe1c5f131573658ae19815ba25f33e/text_extensions_for_pandas/array/tensor.py
+# and
+# https://github.com/CODAIT/text-extensions-for-pandas/blob/dc03278689fe1c5f131573658ae19815ba25f33e/text_extensions_for_pandas/array/arrow_conversion.py
+
+#
+#  Copyright (c) 2020 IBM Corp.
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#  http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+# Modifications:
+# - Added ArrowTensorType.to_pandas_type()
+# - Added ArrowTensorArray.__getitem__()
+# - Added ArrowTensorArray.__iter__()
+# - Added support for column casts to extension types.
+# - Fleshed out docstrings and examples.
+# - Fixed TensorArray.isna() so it returns an appropriate ExtensionArray.
+# - Added different (more vectorized) TensorArray.take() operation.
+# - Added support for more reducers (agg funcs) to TensorArray.
+# - Added support for logical operators to TensorArray(Element).
+# - Added support for heterogeneously-shaped tensors.
+# - Miscellaneous small bug fixes and optimizations.
+
+import numbers
+import os
+from typing import Any, Callable, List, Optional, Sequence, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import pyarrow as pa
+from packaging.version import Version
+from pandas._typing import Dtype
+from pandas.compat import set_function_name
+from pandas.core.dtypes.generic import ABCDataFrame, ABCSeries
+from pandas.core.indexers import check_array_indexer, validate_indices
+
+from ray.air.util.tensor_extensions.utils import (
+    _create_possibly_ragged_ndarray,
+    _is_ndarray_variable_shaped_tensor,
+)
+from ray.util.annotations import PublicAPI
+
+try:
+    from pandas.core.dtypes.generic import ABCIndex
+except ImportError:
+    # ABCIndexClass changed to ABCIndex in Pandas 1.3
+    from pandas.core.dtypes.generic import ABCIndexClass as ABCIndex
+
+
+#############################################
+# Begin patching of ExtensionArrayFormatter #
+#############################################
+
+
+def _format_strings_patched(self) -> List[str]:
+    from pandas.core.construction import extract_array
+    from pandas.io.formats.format import format_array
+
+    if not isinstance(self.values, TensorArray):
+        return self._format_strings_orig()
+
+    values = extract_array(self.values, extract_numpy=True)
+    array = np.asarray(values)
+
+    if array.ndim == 1:
+        return self._format_strings_orig()
+
+    def format_array_wrap(array_, formatter_):
+        fmt_values = format_array(
+            array_,
+            formatter_,
+            float_format=self.float_format,
+            na_rep=self.na_rep,
+            digits=self.digits,
+            space=self.space,
+            justify=self.justify,
+            decimal=self.decimal,
+            leading_space=self.leading_space,
+            quoting=self.quoting,
+        )
+        return fmt_values
+
+    flat_formatter = self.formatter
+    if flat_formatter is None:
+        flat_formatter = values._formatter(boxed=True)
+
+    # Flatten array, call function, reshape (use ravel_compat in v1.3.0)
+    flat_array = array.ravel("K")
+    fmt_flat_array = np.asarray(format_array_wrap(flat_array, flat_formatter))
+    order = "F" if array.flags.f_contiguous else "C"
+    fmt_array = fmt_flat_array.reshape(array.shape, order=order)
+
+    # Format the array of nested strings, use default formatter
+    return format_array_wrap(fmt_array, None)
+
+
+def _format_strings_patched_v1_0_0(self) -> List[str]:
+    from functools import partial
+
+    from pandas.core.construction import extract_array
+    from pandas.io.formats.format import format_array
+    from pandas.io.formats.printing import pprint_thing
+
+    if not isinstance(self.values, TensorArray):
+        return self._format_strings_orig()
+
+    values = extract_array(self.values, extract_numpy=True)
+    array = np.asarray(values)
+
+    if array.ndim == 1:
+        return self._format_strings_orig()
+
+    def format_array_wrap(array_, formatter_):
+        fmt_values = format_array(
+            array_,
+            formatter_,
+            float_format=self.float_format,
+            na_rep=self.na_rep,
+            digits=self.digits,
+            space=self.space,
+            justify=self.justify,
+            decimal=self.decimal,
+            leading_space=self.leading_space,
+        )
+        return fmt_values
+
+    flat_formatter = self.formatter
+    if flat_formatter is None:
+        flat_formatter = values._formatter(boxed=True)
+
+    # Flatten array, call function, reshape (use ravel_compat in v1.3.0)
+    flat_array = array.ravel("K")
+    fmt_flat_array = np.asarray(format_array_wrap(flat_array, flat_formatter))
+    order = "F" if array.flags.f_contiguous else "C"
+    fmt_array = fmt_flat_array.reshape(array.shape, order=order)
+
+    # Slimmed down version of GenericArrayFormatter due to:
+    # https://github.com/pandas-dev/pandas/issues/33770
+    def format_strings_slim(array_, leading_space):
+        formatter = partial(
+            pprint_thing,
+            escape_chars=("\t", "\r", "\n"),
+        )
+
+        def _format(x):
+            return str(formatter(x))
+
+        fmt_values = []
+        for v in array_:
+            tpl = "{v}" if leading_space is False else " {v}"
+            fmt_values.append(tpl.format(v=_format(v)))
+        return fmt_values
+
+    return format_strings_slim(fmt_array, self.leading_space)
+
+
+_FORMATTER_ENABLED_ENV_VAR = "TENSOR_COLUMN_EXTENSION_FORMATTER_ENABLED"
+
+if os.getenv(_FORMATTER_ENABLED_ENV_VAR, "1") == "1":
+    if Version(pd.__version__) < Version("2.2.0"):
+        from pandas.io.formats.format import ExtensionArrayFormatter
+
+        formatter_cls = ExtensionArrayFormatter
+    else:
+        from pandas.io.formats.format import _ExtensionArrayFormatter
+
+        formatter_cls = _ExtensionArrayFormatter
+    formatter_cls._format_strings_orig = formatter_cls._format_strings
+    if Version("1.1.0") <= Version(pd.__version__) < Version("1.3.0"):
+        formatter_cls._format_strings = _format_strings_patched
+    else:
+        formatter_cls._format_strings = _format_strings_patched_v1_0_0
+    formatter_cls._patched_by_ray_datasets = True
+
+###########################################
+# End patching of ExtensionArrayFormatter #
+###########################################
+
+
+@PublicAPI(stability="beta")
+@pd.api.extensions.register_extension_dtype
+class TensorDtype(pd.api.extensions.ExtensionDtype):
+    """
+    Pandas extension type for a column of homogeneous-typed tensors.
+
+    This extension supports tensors in which the elements have different shapes.
+    However, each tensor element must be non-ragged, i.e. each tensor element must have
+    a well-defined, non-ragged shape.
+
+    See:
+    https://github.com/pandas-dev/pandas/blob/master/pandas/core/dtypes/base.py
+    for up-to-date interface documentation and the subclassing contract. The
+    docstrings of the below properties and methods were copied from the base
+    ExtensionDtype.
+
+    Examples:
+        >>> # Create a DataFrame with a list of ndarrays as a column.
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> import ray
+        >>> df = pd.DataFrame({
+        ...     "one": [1, 2, 3],
+        ...     "two": list(np.arange(24).reshape((3, 2, 2, 2)))})
+        >>> # Note the opaque np.object dtype for this column.
+        >>> df.dtypes # doctest: +SKIP
+        one     int64
+        two    object
+        dtype: object
+        >>> # Cast column to our TensorDtype extension type.
+        >>> from ray.data.extensions import TensorDtype
+        >>> df["two"] = df["two"].astype(TensorDtype(np.int64, (3, 2, 2, 2)))
+        >>> # Note that the column dtype is now TensorDtype instead of
+        >>> # np.object.
+        >>> df.dtypes # doctest: +SKIP
+        one          int64
+        two    TensorDtype(shape=(3, 2, 2, 2), dtype=int64)
+        dtype: object
+        >>> # Pandas is now aware of this tensor column, and we can do the
+        >>> # typical DataFrame operations on this column.
+        >>> col = 2 * (df["two"] + 10)
+        >>> # The ndarrays underlying the tensor column will be manipulated,
+        >>> # but the column itself will continue to be a Pandas type.
+        >>> type(col) # doctest: +SKIP
+        pandas.core.series.Series
+        >>> col # doctest: +SKIP
+        0   [[[ 2  4]
+              [ 6  8]]
+             [[10 12]
+               [14 16]]]
+        1   [[[18 20]
+              [22 24]]
+             [[26 28]
+              [30 32]]]
+        2   [[[34 36]
+              [38 40]]
+             [[42 44]
+              [46 48]]]
+        Name: two, dtype: TensorDtype(shape=(3, 2, 2, 2), dtype=int64)
+        >>> # Once you do an aggregation on that column that returns a single
+        >>> # row's value, you get back our TensorArrayElement type.
+        >>> tensor = col.mean()
+        >>> type(tensor) # doctest: +SKIP
+        ray.data.extensions.tensor_extension.TensorArrayElement
+        >>> tensor # doctest: +SKIP
+        array([[[18., 20.],
+                [22., 24.]],
+               [[26., 28.],
+                [30., 32.]]])
+        >>> # This is a light wrapper around a NumPy ndarray, and can easily
+        >>> # be converted to an ndarray.
+        >>> type(tensor.to_numpy()) # doctest: +SKIP
+        numpy.ndarray
+        >>> # In addition to doing Pandas operations on the tensor column,
+        >>> # you can now put the DataFrame into a Dataset.
+        >>> ds = ray.data.from_pandas(df) # doctest: +SKIP
+        >>> # Internally, this column is represented the corresponding
+        >>> # Arrow tensor extension type.
+        >>> ds.schema() # doctest: +SKIP
+        one: int64
+        two: extension<arrow.py_extension_type<ArrowTensorType>>
+        >>> # You can write the dataset to Parquet.
+        >>> ds.write_parquet("/some/path") # doctest: +SKIP
+        >>> # And you can read it back.
+        >>> read_ds = ray.data.read_parquet("/some/path") # doctest: +SKIP
+        >>> read_ds.schema() # doctest: +SKIP
+        one: int64
+        two: extension<arrow.py_extension_type<ArrowTensorType>>
+        >>> read_df = ray.get(read_ds.to_pandas_refs())[0] # doctest: +SKIP
+        >>> read_df.dtypes # doctest: +SKIP
+        one          int64
+        two    TensorDtype(shape=(3, 2, 2, 2), dtype=int64)
+        dtype: object
+        >>> # The tensor extension type is preserved along the
+        >>> # Pandas --> Arrow --> Parquet --> Arrow --> Pandas
+        >>> # conversion chain.
+        >>> read_df.equals(df) # doctest: +SKIP
+        True
+    """
+
+    # NOTE(Clark): This is apparently required to prevent integer indexing
+    # errors, but is an undocumented ExtensionDtype attribute. See issue:
+    # https://github.com/CODAIT/text-extensions-for-pandas/issues/166
+    base = None
+
+    def __init__(self, shape: Tuple[Optional[int], ...], dtype: np.dtype):
+        self._shape = shape
+        self._dtype = dtype
+
+    @property
+    def type(self):
+        """
+        The scalar type for the array, e.g. ``int``
+        It's expected ``ExtensionArray[item]`` returns an instance
+        of ``ExtensionDtype.type`` for scalar ``item``, assuming
+        that value is valid (not NA). NA values do not need to be
+        instances of `type`.
+        """
+        return TensorArrayElement
+
+    @property
+    def element_dtype(self):
+        """
+        The dtype of the underlying tensor elements.
+        """
+        return self._dtype
+
+    @property
+    def element_shape(self):
+        """
+        The shape of the underlying tensor elements. This will be a tuple of Nones if
+        the corresponding TensorArray for this TensorDtype holds variable-shaped tensor
+        elements.
+        """
+        return self._shape
+
+    @property
+    def is_variable_shaped(self):
+        """
+        Whether the corresponding TensorArray for this TensorDtype holds variable-shaped
+        tensor elements.
+        """
+        return all(dim_size is None for dim_size in self.shape)
+
+    @property
+    def name(self) -> str:
+        """
+        A string identifying the data type.
+        Will be used for display in, e.g. ``Series.dtype``
+        """
+        return f"numpy.ndarray(shape={self._shape}, dtype={self._dtype})"
+
+    @classmethod
+    def construct_from_string(cls, string: str):
+        r"""
+        Construct this type from a string.
+
+        This is useful mainly for data types that accept parameters.
+        For example, a period dtype accepts a frequency parameter that
+        can be set as ``period[H]`` (where H means hourly frequency).
+
+        By default, in the abstract class, just the name of the type is
+        expected. But subclasses can overwrite this method to accept
+        parameters.
+
+        Parameters
+        ----------
+        string : str
+            The name of the type, for example ``category``.
+
+        Returns
+        -------
+        ExtensionDtype
+            Instance of the dtype.
+
+        Raises
+        ------
+        TypeError
+            If a class cannot be constructed from this 'string'.
+
+        Examples
+        --------
+        For extension dtypes with arguments the following may be an
+        adequate implementation.
+
+        >>> import re
+        >>> @classmethod
+        ... def construct_from_string(cls, string):
+        ...     pattern = re.compile(r"^my_type\[(?P<arg_name>.+)\]$")
+        ...     match = pattern.match(string)
+        ...     if match:
+        ...         return cls(**match.groupdict())
+        ...     else:
+        ...         raise TypeError(
+        ...             f"Cannot construct a '{cls.__name__}' from '{string}'"
+        ...         )
+        """
+        import ast
+        import re
+
+        if not isinstance(string, str):
+            raise TypeError(
+                f"'construct_from_string' expects a string, got {type(string)}"
+            )
+        # Upstream code uses exceptions as part of its normal control flow and
+        # will pass this method bogus class names.
+        regex = (
+            r"^(TensorDtype|numpy.ndarray)"
+            r"\(shape=(\((?:(?:\d+|None),?\s?)*\)), dtype=(\w+)\)$"
+        )
+        m = re.search(regex, string)
+        err_msg = (
+            f"Cannot construct a '{cls.__name__}' from '{string}'; expected a string "
+            "like 'TensorDtype(shape=(1, 2, 3), dtype=int64)'."
+        )
+        if m is None:
+            raise TypeError(err_msg)
+        groups = m.groups()
+        if len(groups) != 3:
+            raise TypeError(err_msg)
+        _, shape, dtype = groups
+        shape = ast.literal_eval(shape)
+        dtype = np.dtype(dtype)
+        return cls(shape, dtype)
+
+    @classmethod
+    def construct_array_type(cls):
+        """
+        Return the array type associated with this dtype.
+
+        Returns
+        -------
+        type
+        """
+        return TensorArray
+
+    def __from_arrow__(self, array: Union[pa.Array, pa.ChunkedArray]):
+        """
+        Convert a pyarrow (chunked) array to a TensorArray.
+
+        This and TensorArray.__arrow_array__ make up the
+        Pandas extension type + array <--> Arrow extension type + array
+        interoperability protocol. See
+        https://pandas.pydata.org/pandas-docs/stable/development/extending.html#compatibility-with-apache-arrow
+        for more information.
+        """
+        if isinstance(array, pa.ChunkedArray):
+            if array.num_chunks > 1:
+                # TODO(Clark): Remove concat and construct from list with
+                # shape.
+                values = np.concatenate(
+                    [chunk.to_numpy() for chunk in array.iterchunks()]
+                )
+            else:
+                values = array.chunk(0).to_numpy()
+        else:
+            values = array.to_numpy()
+
+        return TensorArray(values)
+
+    def __str__(self) -> str:
+        return self.name
+
+    def __repr__(self) -> str:
+        return str(self)
+
+    @property
+    def _is_boolean(self):
+        """
+        Whether this extension array should be considered boolean.
+
+        By default, ExtensionArrays are assumed to be non-numeric.
+        Setting this to True will affect the behavior of several places,
+        e.g.
+
+        * is_bool
+        * boolean indexing
+
+        Returns
+        -------
+        bool
+        """
+        # This is needed to support returning a TensorArray from .isnan().
+        from pandas.core.dtypes.common import is_bool_dtype
+
+        return is_bool_dtype(self._dtype)
+
+
+class _TensorOpsMixin(pd.api.extensions.ExtensionScalarOpsMixin):
+    """
+    Mixin for TensorArray operator support, applying operations on the
+    underlying ndarrays.
+    """
+
+    @classmethod
+    def _create_method(cls, op, coerce_to_dtype=True, result_dtype=None):
+        """
+        Add support for binary operators by unwrapping, applying, and
+        rewrapping.
+        """
+
+        # NOTE(Clark): This overrides, but coerce_to_dtype, result_dtype might
+        # not be needed
+
+        def _binop(self, other):
+            lvalues = self._tensor
+
+            if isinstance(other, (ABCDataFrame, ABCSeries, ABCIndex)):
+                # Rely on Pandas to unbox and dispatch to us.
+                return NotImplemented
+
+            # divmod returns a tuple
+            if op_name in ["__divmod__", "__rdivmod__"]:
+                # TODO(Clark): Add support for divmod and rdivmod.
+                # div, mod = result
+                raise NotImplementedError
+
+            if isinstance(other, (TensorArray, TensorArrayElement)):
+                rvalues = other._tensor
+            else:
+                rvalues = other
+
+            result = op(lvalues, rvalues)
+
+            # Force a TensorArray if rvalue is not a scalar.
+            if isinstance(self, TensorArrayElement) and (
+                not isinstance(other, TensorArrayElement) or not np.isscalar(other)
+            ):
+                result_wrapped = TensorArray(result)
+            else:
+                result_wrapped = cls(result)
+
+            return result_wrapped
+
+        op_name = f"__{op.__name__}__"
+        return set_function_name(_binop, op_name, cls)
+
+    @classmethod
+    def _create_logical_method(cls, op):
+        return cls._create_method(op)
+
+
+class _TensorScalarCastMixin:
+    """
+    Mixin for casting scalar tensors to a particular numeric type.
+    """
+
+    def _scalarfunc(self, func: Callable[[Any], Any]):
+        return func(self._tensor)
+
+    def __complex__(self):
+        return self._scalarfunc(complex)
+
+    def __float__(self):
+        return self._scalarfunc(float)
+
+    def __int__(self):
+        return self._scalarfunc(int)
+
+    def __hex__(self):
+        return self._scalarfunc(hex)
+
+    def __oct__(self):
+        return self._scalarfunc(oct)
+
+
+@PublicAPI(stability="beta")
+class TensorArrayElement(_TensorOpsMixin, _TensorScalarCastMixin):
+    """
+    Single element of a TensorArray, wrapping an underlying ndarray.
+    """
+
+    def __init__(self, values: np.ndarray):
+        """
+        Construct a TensorArrayElement from a NumPy ndarray.
+
+        Args:
+            values: ndarray that underlies this TensorArray element.
+        """
+        self._tensor = values
+
+    def __repr__(self):
+        return self._tensor.__repr__()
+
+    def __str__(self):
+        return self._tensor.__str__()
+
+    @property
+    def numpy_dtype(self):
+        """
+        Get the dtype of the tensor.
+        :return: The numpy dtype of the backing ndarray
+        """
+        return self._tensor.dtype
+
+    @property
+    def numpy_ndim(self):
+        """
+        Get the number of tensor dimensions.
+        :return: integer for the number of dimensions
+        """
+        return self._tensor.ndim
+
+    @property
+    def numpy_shape(self):
+        """
+        Get the shape of the tensor.
+        :return: A tuple of integers for the numpy shape of the backing ndarray
+        """
+        return self._tensor.shape
+
+    @property
+    def numpy_size(self):
+        """
+        Get the size of the tensor.
+        :return: integer for the number of elements in the tensor
+        """
+        return self._tensor.size
+
+    def to_numpy(self):
+        """
+        Return the values of this element as a NumPy ndarray.
+        """
+        return np.asarray(self._tensor)
+
+    def __array__(self, dtype: np.dtype = None, **kwargs) -> np.ndarray:
+        return np.asarray(self._tensor, dtype=dtype, **kwargs)
+
+
+@PublicAPI(stability="beta")
+class TensorArray(
+    pd.api.extensions.ExtensionArray,
+    _TensorOpsMixin,
+    _TensorScalarCastMixin,
+):
+    """
+    Pandas `ExtensionArray` representing a tensor column, i.e. a column
+    consisting of ndarrays as elements.
+
+    This extension supports tensors in which the elements have different shapes.
+    However, each tensor element must be non-ragged, i.e. each tensor element must have
+    a well-defined, non-ragged shape.
+
+    Examples:
+        >>> # Create a DataFrame with a list of ndarrays as a column.
+        >>> import pandas as pd
+        >>> import numpy as np
+        >>> import ray
+        >>> from ray.data.extensions import TensorArray
+        >>> df = pd.DataFrame({
+        ...     "one": [1, 2, 3],
+        ...     "two": TensorArray(np.arange(24).reshape((3, 2, 2, 2)))})
+        >>> # Note that the column dtype is TensorDtype.
+        >>> df.dtypes # doctest: +SKIP
+        one          int64
+        two    TensorDtype(shape=(3, 2, 2, 2), dtype=int64)
+        dtype: object
+        >>> # Pandas is aware of this tensor column, and we can do the
+        >>> # typical DataFrame operations on this column.
+        >>> col = 2 * (df["two"] + 10)
+        >>> # The ndarrays underlying the tensor column will be manipulated,
+        >>> # but the column itself will continue to be a Pandas type.
+        >>> type(col) # doctest: +SKIP
+        pandas.core.series.Series
+        >>> col # doctest: +SKIP
+        0   [[[ 2  4]
+              [ 6  8]]
+             [[10 12]
+               [14 16]]]
+        1   [[[18 20]
+              [22 24]]
+             [[26 28]
+              [30 32]]]
+        2   [[[34 36]
+              [38 40]]
+             [[42 44]
+              [46 48]]]
+        Name: two, dtype: TensorDtype(shape=(3, 2, 2, 2), dtype=int64)
+        >>> # Once you do an aggregation on that column that returns a single
+        >>> # row's value, you get back our TensorArrayElement type.
+        >>> tensor = col.mean() # doctest: +SKIP
+        >>> type(tensor) # doctest: +SKIP
+        ray.data.extensions.tensor_extension.TensorArrayElement
+        >>> tensor # doctest: +SKIP
+        array([[[18., 20.],
+                [22., 24.]],
+               [[26., 28.],
+                [30., 32.]]])
+        >>> # This is a light wrapper around a NumPy ndarray, and can easily
+        >>> # be converted to an ndarray.
+        >>> type(tensor.to_numpy()) # doctest: +SKIP
+        numpy.ndarray
+        >>> # In addition to doing Pandas operations on the tensor column,
+        >>> # you can now put the DataFrame into a Dataset.
+        >>> ds = ray.data.from_pandas(df) # doctest: +SKIP
+        >>> # Internally, this column is represented the corresponding
+        >>> # Arrow tensor extension type.
+        >>> ds.schema() # doctest: +SKIP
+        one: int64
+        two: extension<arrow.py_extension_type<ArrowTensorType>>
+        >>> # You can write the dataset to Parquet.
+        >>> ds.write_parquet("/some/path") # doctest: +SKIP
+        >>> # And you can read it back.
+        >>> read_ds = ray.data.read_parquet("/some/path") # doctest: +SKIP
+        >>> read_ds.schema() # doctest: +SKIP
+        one: int64
+        two: extension<arrow.py_extension_type<ArrowTensorType>>
+
+        >>> read_df = ray.get(read_ds.to_pandas_refs())[0] # doctest: +SKIP
+        >>> read_df.dtypes # doctest: +SKIP
+        one          int64
+        two    TensorDtype(shape=(3, 2, 2, 2), dtype=int64)
+        dtype: object
+        >>> # The tensor extension type is preserved along the
+        >>> # Pandas --> Arrow --> Parquet --> Arrow --> Pandas
+        >>> # conversion chain.
+        >>> read_df.equals(df) # doctest: +SKIP
+        True
+    """
+
+    SUPPORTED_REDUCERS = {
+        "sum": np.sum,
+        "all": np.all,
+        "any": np.any,
+        "min": np.min,
+        "max": np.max,
+        "mean": np.mean,
+        "median": np.median,
+        "prod": np.prod,
+        "std": np.std,
+        "var": np.var,
+    }
+
+    # See https://github.com/pandas-dev/pandas/blob/master/pandas/core/arrays/base.py
+    # for interface documentation and the subclassing contract.
+    def __init__(
+        self,
+        values: Union[
+            np.ndarray,
+            ABCSeries,
+            Sequence[Union[np.ndarray, TensorArrayElement]],
+            TensorArrayElement,
+            Any,
+        ],
+    ):
+        """
+        Args:
+            values: A NumPy ndarray or sequence of NumPy ndarrays of equal
+                shape.
+        """
+        # Try to convert some well-known objects to ndarrays before handing off to
+        # ndarray handling logic.
+        if isinstance(values, ABCSeries):
+            values = _create_possibly_ragged_ndarray(values)
+        elif isinstance(values, Sequence):
+            values = [
+                np.asarray(v) if isinstance(v, TensorArrayElement) else v
+                for v in values
+            ]
+            values = _create_possibly_ragged_ndarray(values)
+        elif isinstance(values, TensorArrayElement):
+            values = np.array([np.asarray(values)], copy=False)
+
+        if isinstance(values, np.ndarray):
+            if values.dtype.type is np.object_:
+                if len(values) == 0:
+                    # Tensor is empty, pass through to create empty TensorArray.
+                    pass
+                elif all(
+                    isinstance(v, (np.ndarray, TensorArrayElement, Sequence))
+                    and not isinstance(v, str)
+                    for v in values
+                ):
+                    values = [np.asarray(v) for v in values]
+                    # Try to convert ndarrays of ndarrays/TensorArrayElements with an
+                    # opaque object type to a properly typed ndarray of ndarrays.
+                    values = _create_possibly_ragged_ndarray(values)
+                else:
+                    raise TypeError(
+                        "Expected a well-typed ndarray or an object-typed ndarray of "
+                        "ndarray pointers, but got an object-typed ndarray whose "
+                        f"subndarrays are of type {type(values[0])}."
+                    )
+        elif isinstance(values, TensorArray):
+            raise TypeError("Use the copy() method to create a copy of a TensorArray.")
+        else:
+            raise TypeError(
+                "Expected a numpy.ndarray or sequence of numpy.ndarray, "
+                f"but received {values} of type {type(values).__name__} instead."
+            )
+        assert isinstance(values, np.ndarray)
+        self._tensor = values
+        self._is_variable_shaped = None
+
+    @classmethod
+    def _from_sequence(
+        cls, scalars, *, dtype: Optional[Dtype] = None, copy: bool = False
+    ):
+        """
+        Construct a new ExtensionArray from a sequence of scalars.
+
+        Parameters
+        ----------
+        scalars : Sequence
+            Each element will be an instance of the scalar type for this
+            array, ``cls.dtype.type`` or be converted into this type in this
+            method.
+        dtype : dtype, optional
+            Construct for this particular dtype. This should be a Dtype
+            compatible with the ExtensionArray.
+        copy : bool, default False
+            If True, copy the underlying data.
+
+        Returns
+        -------
+        ExtensionArray
+        """
+        if copy and isinstance(scalars, np.ndarray):
+            scalars = scalars.copy()
+        elif isinstance(scalars, TensorArray):
+            scalars = scalars._tensor.copy() if copy else scalars._tensor
+        return TensorArray(scalars)
+
+    @classmethod
+    def _from_factorized(
+        cls, values: np.ndarray, original: pd.api.extensions.ExtensionArray
+    ):
+        """
+        Reconstruct an ExtensionArray after factorization.
+
+        Parameters
+        ----------
+        values : ndarray
+            An integer ndarray with the factorized values.
+        original : ExtensionArray
+            The original ExtensionArray that factorize was called on.
+
+        See Also
+        --------
+        factorize : Top-level factorize method that dispatches here.
+        ExtensionArray.factorize : Encode the extension array as an enumerated
+            type.
+        """
+        raise NotImplementedError
+
+    def __getitem__(
+        self, item: Union[int, slice, np.ndarray]
+    ) -> Union["TensorArray", "TensorArrayElement"]:
+        """
+        Select a subset of self.
+
+        Parameters
+        ----------
+        item : int, slice, or ndarray
+            * int: The position in 'self' to get.
+            * slice: A slice object, where 'start', 'stop', and 'step' are
+              integers or None
+            * ndarray: A 1-d boolean NumPy ndarray the same length as 'self'
+
+        Returns
+        -------
+        item : scalar or ExtensionArray
+
+        Notes
+        -----
+        For scalar ``item``, return a scalar value suitable for the array's
+        type. This should be an instance of ``self.dtype.type``.
+        For slice ``key``, return an instance of ``ExtensionArray``, even
+        if the slice is length 0 or 1.
+        For a boolean mask, return an instance of ``ExtensionArray``, filtered
+        to the values where ``item`` is True.
+        """
+        # Return scalar if single value is selected, a TensorArrayElement for
+        # single array element, or TensorArray for slice.
+        if isinstance(item, int):
+            value = self._tensor[item]
+            if np.isscalar(value):
+                return value
+            else:
+                return TensorArrayElement(value)
+        else:
+            # BEGIN workaround for Pandas issue #42430
+            if isinstance(item, tuple) and len(item) > 1 and item[0] == Ellipsis:
+                if len(item) > 2:
+                    # Hopefully this case is not possible, but can't be sure
+                    raise ValueError(
+                        "Workaround Pandas issue #42430 not "
+                        "implemented for tuple length > 2"
+                    )
+                item = item[1]
+            # END workaround for issue #42430
+            if isinstance(item, TensorArray):
+                item = np.asarray(item)
+            item = check_array_indexer(self, item)
+            return TensorArray(self._tensor[item])
+
+    def __len__(self) -> int:
+        """
+        Length of this array.
+
+        Returns
+        -------
+        length : int
+        """
+        return len(self._tensor)
+
+    @property
+    def dtype(self) -> pd.api.extensions.ExtensionDtype:
+        """
+        An instance of 'ExtensionDtype'.
+        """
+        if self.is_variable_shaped:
+            # A tensor is only considered variable-shaped if it's non-empty, so no
+            # non-empty check is needed here.
+            dtype = self._tensor[0].dtype
+            shape = (None,) * self._tensor[0].ndim
+        else:
+            dtype = self.numpy_dtype
+            shape = self.numpy_shape[1:]
+        return TensorDtype(shape, dtype)
+
+    @property
+    def is_variable_shaped(self):
+        """
+        Whether this TensorArray holds variable-shaped tensor elements.
+        """
+        if self._is_variable_shaped is None:
+            self._is_variable_shaped = _is_ndarray_variable_shaped_tensor(self._tensor)
+        return self._is_variable_shaped
+
+    @property
+    def nbytes(self) -> int:
+        """
+        The number of bytes needed to store this object in memory.
+        """
+        return self._tensor.nbytes
+
+    def isna(self) -> "TensorArray":
+        """
+        A 1-D array indicating if each value is missing.
+
+        Returns
+        -------
+        na_values : Union[np.ndarray, ExtensionArray]
+            In most cases, this should return a NumPy ndarray. For
+            exceptional cases like ``SparseArray``, where returning
+            an ndarray would be expensive, an ExtensionArray may be
+            returned.
+
+        Notes
+        -----
+        If returning an ExtensionArray, then
+
+        * ``na_values._is_boolean`` should be True
+        * `na_values` should implement :func:`ExtensionArray._reduce`
+        * ``na_values.any`` and ``na_values.all`` should be implemented
+        """
+        if self._tensor.dtype.type is np.object_:
+            # Avoid comparing with __eq__ because the elements of the tensor
+            # may do something funny with that operation.
+            return np.array(
+                [self._tensor[i] is None for i in range(len(self))], dtype=bool
+            )
+        elif self._tensor.dtype.type is np.str_:
+            return np.all(self._tensor == "", axis=tuple(range(1, self._tensor.ndim)))
+        else:
+            return np.all(
+                np.isnan(self._tensor), axis=tuple(range(1, self._tensor.ndim))
+            )
+
+    def take(
+        self, indices: Sequence[int], allow_fill: bool = False, fill_value: Any = None
+    ) -> "TensorArray":
+        """
+        Take elements from an array.
+
+        Parameters
+        ----------
+        indices : sequence of int
+            Indices to be taken.
+        allow_fill : bool, default False
+            How to handle negative values in `indices`.
+
+            * False: negative values in `indices` indicate positional indices
+              from the right (the default). This is similar to
+              :func:`numpy.take`.
+
+            * True: negative values in `indices` indicate
+              missing values. These values are set to `fill_value`. Any other
+              other negative values raise a ``ValueError``.
+
+        fill_value : any, optional
+            Fill value to use for NA-indices when `allow_fill` is True.
+            This may be ``None``, in which case the default NA value for
+            the type, ``self.dtype.na_value``, is used.
+
+            For many ExtensionArrays, there will be two representations of
+            `fill_value`: a user-facing "boxed" scalar, and a low-level
+            physical NA value. `fill_value` should be the user-facing version,
+            and the implementation should handle translating that to the
+            physical version for processing the take if necessary.
+
+        Returns
+        -------
+        ExtensionArray
+
+        Raises
+        ------
+        IndexError
+            When the indices are out of bounds for the array.
+        ValueError
+            When `indices` contains negative values other than ``-1``
+            and `allow_fill` is True.
+
+        See Also
+        --------
+        numpy.take : Take elements from an array along an axis.
+        api.extensions.take : Take elements from an array.
+
+        Notes
+        -----
+        ExtensionArray.take is called by ``Series.__getitem__``, ``.loc``,
+        ``iloc``, when `indices` is a sequence of values. Additionally,
+        it's called by :meth:`Series.reindex`, or any other method
+        that causes realignment, with a `fill_value`.
+
+        Examples
+        --------
+        Here's an example implementation, which relies on casting the
+        extension array to object dtype. This uses the helper method
+        :func:`pandas.api.extensions.take`.
+
+        .. code-block:: python
+
+           def take(self, indices, allow_fill=False, fill_value=None):
+               from pandas.core.algorithms import take
+
+               # If the ExtensionArray is backed by an ndarray, then
+               # just pass that here instead of coercing to object.
+               data = self.astype(object)
+
+               if allow_fill and fill_value is None:
+                   fill_value = self.dtype.na_value
+
+               # fill value should always be translated from the scalar
+               # type for the array, to the physical storage type for
+               # the data, before passing to take.
+
+               result = take(data, indices, fill_value=fill_value,
+                             allow_fill=allow_fill)
+               return self._from_sequence(result, dtype=self.dtype)
+        """
+        if allow_fill:
+            # With allow_fill being True, negative values in `indices` indicate
+            # missing values and should be set to `fill_value`.
+            indices = np.asarray(indices, dtype=np.intp)
+            validate_indices(indices, len(self._tensor))
+
+            # Check if there are missing indices to fill, otherwise we can
+            # delegate to NumPy ndarray .take().
+            has_missing = np.any(indices < 0)
+            if has_missing:
+                if fill_value is None:
+                    fill_value = np.nan
+
+                # Create an array populated with fill value.
+                values = np.full((len(indices),) + self._tensor.shape[1:], fill_value)
+
+                # Put tensors at the given positive indices into array.
+                is_nonneg = indices >= 0
+                np.put(values, np.where(is_nonneg)[0], self._tensor[indices[is_nonneg]])
+
+                return TensorArray(values)
+
+        # Delegate take to NumPy array.
+        values = self._tensor.take(indices, axis=0)
+
+        return TensorArray(values)
+
+    def copy(self) -> "TensorArray":
+        """
+        Return a copy of the array.
+
+        Returns
+        -------
+        ExtensionArray
+        """
+        # TODO(Clark): Copy cached properties.
+        return TensorArray(self._tensor.copy())
+
+    @classmethod
+    def _concat_same_type(cls, to_concat: Sequence["TensorArray"]) -> "TensorArray":
+        """
+        Concatenate multiple array of this dtype.
+
+        Parameters
+        ----------
+        to_concat : sequence of this type
+
+        Returns
+        -------
+        ExtensionArray
+        """
+        should_flatten = False
+        shape = None
+        for a in to_concat:
+            if shape is None:
+                shape = a.dtype.element_shape
+            if a.is_variable_shaped or a.dtype.element_shape != shape:
+                should_flatten = True
+                break
+        if should_flatten:
+            concated = TensorArray(
+                np.array([e for a in to_concat for e in a._tensor], dtype=object)
+            )
+        else:
+            concated = TensorArray(np.concatenate([a._tensor for a in to_concat]))
+        return concated
+
+    def __setitem__(self, key: Union[int, np.ndarray], value: Any) -> None:
+        """
+        Set one or more values inplace.
+
+        This method is not required to satisfy the pandas extension array
+        interface.
+
+        Parameters
+        ----------
+        key : int, ndarray, or slice
+            When called from, e.g. ``Series.__setitem__``, ``key`` will be
+            one of
+
+            * scalar int
+            * ndarray of integers.
+            * boolean ndarray
+            * slice object
+
+        value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object
+            value or values to be set of ``key``.
+
+        Returns
+        -------
+        None
+        """
+        key = check_array_indexer(self, key)
+        if isinstance(value, TensorArrayElement) or np.isscalar(value):
+            value = np.asarray(value)
+        if isinstance(value, list):
+            value = [
+                np.asarray(v) if isinstance(v, TensorArrayElement) else v for v in value
+            ]
+        if isinstance(value, ABCSeries) and isinstance(value.dtype, TensorDtype):
+            value = value.values
+        if value is None or isinstance(value, Sequence) and len(value) == 0:
+            self._tensor[key] = np.full_like(self._tensor[key], np.nan)
+        elif isinstance(key, (int, slice, np.ndarray)):
+            self._tensor[key] = value
+        else:
+            raise NotImplementedError(
+                f"__setitem__ with key type '{type(key)}' not implemented"
+            )
+
+    def __contains__(self, item) -> bool:
+        """
+        Return for `item in self`.
+        """
+        if isinstance(item, TensorArrayElement):
+            np_item = np.asarray(item)
+            if np_item.size == 1 and np.isnan(np_item).all():
+                return self.isna().any()
+        return super().__contains__(item)
+
+    def __repr__(self):
+        return self._tensor.__repr__()
+
+    def __str__(self):
+        return self._tensor.__str__()
+
+    def _values_for_factorize(self) -> Tuple[np.ndarray, Any]:
+        # TODO(Clark): return self._tensor, np.nan
+        raise NotImplementedError
+
+    def _reduce(self, name: str, skipna: bool = True, **kwargs):
+        """
+        Return a scalar result of performing the reduction operation.
+
+        Parameters
+        ----------
+        name : str
+            Name of the function, supported values are:
+            { any, all, min, max, sum, mean, median, prod,
+            std, var, sem, kurt, skew }.
+        skipna : bool, default True
+            If True, skip NaN values.
+        **kwargs
+            Additional keyword arguments passed to the reduction function.
+            Currently, `ddof` is the only supported kwarg.
+
+        Returns
+        -------
+        scalar
+
+        Raises
+        ------
+        TypeError : subclass does not define reductions
+        """
+        supported_kwargs = ["ddof"]
+        reducer_kwargs = {}
+        for kw in supported_kwargs:
+            try:
+                reducer_kwargs[kw] = kwargs[kw]
+            except KeyError:
+                pass
+        try:
+            return TensorArrayElement(
+                self.SUPPORTED_REDUCERS[name](self._tensor, axis=0, **reducer_kwargs)
+            )
+        except KeyError:
+            raise NotImplementedError(f"'{name}' aggregate not implemented.") from None
+
+    def __array__(self, dtype: np.dtype = None, **kwargs) -> np.ndarray:
+        return np.asarray(self._tensor, dtype=dtype, **kwargs)
+
+    def __array_ufunc__(self, ufunc: Callable, method: str, *inputs, **kwargs):
+        """
+        Supports NumPy ufuncs without requiring sloppy coercion to an
+        ndarray.
+        """
+        out = kwargs.get("out", ())
+        for x in inputs + out:
+            if not isinstance(x, (TensorArray, np.ndarray, numbers.Number)):
+                return NotImplemented
+
+        # Defer to the implementation of the ufunc on unwrapped values.
+        inputs = tuple(x._tensor if isinstance(x, TensorArray) else x for x in inputs)
+        if out:
+            kwargs["out"] = tuple(
+                x._tensor if isinstance(x, TensorArray) 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 to_numpy(
+        self,
+        dtype: np.dtype = None,
+        copy: bool = False,
+        na_value: Any = pd.api.extensions.no_default,
+    ):
+        """
+        Convert to a NumPy ndarray.
+
+        .. versionadded:: 1.0.0
+
+        This is similar to :meth:`numpy.asarray`, but may provide additional
+        control over how the conversion is done.
+
+        Parameters
+        ----------
+        dtype : str or numpy.dtype, optional
+            The dtype to pass to :meth:`numpy.asarray`.
+        copy : bool, default False
+            Whether to ensure that the returned value is a not a view on
+            another array. Note that ``copy=False`` does not *ensure* that
+            ``to_numpy()`` is no-copy. Rather, ``copy=True`` ensure that
+            a copy is made, even if not strictly necessary.
+        na_value : Any, optional
+            The value to use for missing values. The default value depends
+            on `dtype` and the type of the array.
+
+        Returns
+        -------
+        numpy.ndarray
+        """
+        if dtype is not None:
+            dtype = pd.api.types.pandas_dtype(dtype)
+            if copy:
+                values = np.array(self._tensor, dtype=dtype, copy=True)
+            else:
+                values = self._tensor.astype(dtype)
+        elif copy:
+            values = self._tensor.copy()
+        else:
+            values = self._tensor
+        return values
+
+    @property
+    def numpy_dtype(self):
+        """
+        Get the dtype of the tensor.
+        :return: The numpy dtype of the backing ndarray
+        """
+        return self._tensor.dtype
+
+    @property
+    def numpy_ndim(self):
+        """
+        Get the number of tensor dimensions.
+        :return: integer for the number of dimensions
+        """
+        return self._tensor.ndim
+
+    @property
+    def numpy_shape(self):
+        """
+        Get the shape of the tensor.
+        :return: A tuple of integers for the numpy shape of the backing ndarray
+        """
+        return self._tensor.shape
+
+    @property
+    def numpy_size(self):
+        """
+        Get the size of the tensor.
+        :return: integer for the number of elements in the tensor
+        """
+        return self._tensor.size
+
+    def astype(self, dtype, copy=True):
+        """
+        Cast to a NumPy array with 'dtype'.
+
+        Parameters
+        ----------
+        dtype : str or dtype
+            Typecode or data-type to which the array is cast.
+        copy : bool, default True
+            Whether to copy the data, even if not necessary. If False,
+            a copy is made only if the old dtype does not match the
+            new dtype.
+
+        Returns
+        -------
+        array : ndarray
+            NumPy ndarray with 'dtype' for its dtype.
+        """
+        dtype = pd.api.types.pandas_dtype(dtype)
+
+        if isinstance(dtype, TensorDtype):
+            values = TensorArray(self._tensor.copy()) if copy else self
+        elif not (
+            pd.api.types.is_object_dtype(dtype) and pd.api.types.is_string_dtype(dtype)
+        ):
+            values = np.array([str(t) for t in self._tensor])
+            if isinstance(dtype, pd.StringDtype):
+                return dtype.construct_array_type()._from_sequence(values, copy=False)
+            else:
+                return values
+        elif pd.api.types.is_object_dtype(dtype):
+            # Interpret astype(object) as "cast to an array of numpy arrays"
+            values = np.empty(len(self), dtype=object)
+            for i in range(len(self)):
+                values[i] = self._tensor[i]
+        else:
+            values = self._tensor.astype(dtype, copy=copy)
+        return values
+
+    def any(self, axis=None, out=None, keepdims=False):
+        """
+        Test whether any array element along a given axis evaluates to True.
+
+        See numpy.any() documentation for more information
+        https://numpy.org/doc/stable/reference/generated/numpy.any.html#numpy.any
+
+        :param axis: Axis or axes along which a logical OR reduction is
+            performed.
+        :param out: Alternate output array in which to place the result.
+        :param keepdims: If this is set to True, the axes which are reduced are
+            left in the result as dimensions with size one.
+        :return: single boolean unless axis is not None else TensorArray
+        """
+        result = self._tensor.any(axis=axis, out=out, keepdims=keepdims)
+        return result if axis is None else TensorArray(result)
+
+    def all(self, axis=None, out=None, keepdims=False):
+        """
+        Test whether all array elements along a given axis evaluate to True.
+
+        :param axis: Axis or axes along which a logical AND reduction is
+            performed.
+        :param out: Alternate output array in which to place the result.
+        :param keepdims: If this is set to True, the axes which are reduced are
+            left in the result as dimensions with size one.
+        :return: single boolean unless axis is not None else TensorArray
+        """
+        result = self._tensor.all(axis=axis, out=out, keepdims=keepdims)
+        return result if axis is None else TensorArray(result)
+
+    def __arrow_array__(self, type=None):
+        """
+        Convert this TensorArray to an ArrowTensorArray extension array.
+
+        This and TensorDtype.__from_arrow__ make up the
+        Pandas extension type + array <--> Arrow extension type + array
+        interoperability protocol. See
+        https://pandas.pydata.org/pandas-docs/stable/development/extending.html#compatibility-with-apache-arrow
+        for more information.
+        """
+        from ray.air.util.tensor_extensions.arrow import (
+            ArrowTensorArray,
+            ArrowVariableShapedTensorArray,
+        )
+
+        if self.is_variable_shaped:
+            return ArrowVariableShapedTensorArray.from_numpy(self._tensor)
+        else:
+            return ArrowTensorArray.from_numpy(self._tensor)
+
+    @property
+    def _is_boolean(self):
+        """
+        Whether this extension array should be considered boolean.
+
+        By default, ExtensionArrays are assumed to be non-numeric.
+        Setting this to True will affect the behavior of several places,
+        e.g.
+
+        * is_bool
+        * boolean indexing
+
+        Returns
+        -------
+        bool
+        """
+        # This is needed to support returning a TensorArray from .isnan().
+        return self.dtype._is_boolean()
+
+
+# Add operators from the mixin to the TensorArrayElement and TensorArray
+# classes.
+TensorArrayElement._add_arithmetic_ops()
+TensorArrayElement._add_comparison_ops()
+TensorArrayElement._add_logical_ops()
+TensorArray._add_arithmetic_ops()
+TensorArray._add_comparison_ops()
+TensorArray._add_logical_ops()
+
+
+@PublicAPI(stability="beta")
+def column_needs_tensor_extension(s: pd.Series) -> bool:
+    """Return whether the provided pandas Series column needs a tensor extension
+    representation. This tensor extension representation provides more efficient slicing
+    and interop with ML frameworks.
+
+    Args:
+        s: The pandas Series column that may need to be represented using the tensor
+            extension.
+
+    Returns:
+        Whether the provided Series needs a tensor extension representation.
+    """
+    # NOTE: This is an O(1) check.
+    return (
+        s.dtype.type is np.object_ and not s.empty and isinstance(s.iloc[0], np.ndarray)
+    )

infer_4_37_2/lib/python3.10/site-packages/ray/air/util/tensor_extensions/utils.py

@@ -0,0 +1,137 @@
+import warnings
+from typing import TYPE_CHECKING, Any, Sequence, Union
+
+import numpy as np
+
+from ray.util import PublicAPI
+
+if TYPE_CHECKING:
+    from pandas.core.dtypes.generic import ABCSeries
+
+
+def _is_ndarray_tensor(arr: np.ndarray) -> bool:
+    """Return whether the provided NumPy ndarray is comprised of tensors.
+
+    NOTE: Tensor is defined as a NumPy array such that `len(arr.shape) > 1`
+    """
+
+    # Case of uniform-shaped (ie non-ragged) tensor
+    if arr.ndim > 1:
+        return True
+
+    # Case of ragged tensor (as produced by `create_ragged_ndarray` utility)
+    elif (
+        arr.dtype.type is np.object_ and len(arr) > 0 and isinstance(arr[0], np.ndarray)
+    ):
+        return True
+
+    return False
+
+
+def _is_ndarray_variable_shaped_tensor(arr: np.ndarray) -> bool:
+    """Return whether the provided NumPy ndarray is comprised of variable-shaped
+    tensors.
+
+    NOTE: This is an O(rows) check.
+    """
+    if arr.dtype.type is not np.object_:
+        return False
+    if len(arr) == 0:
+        return False
+    if not isinstance(arr[0], np.ndarray):
+        return False
+    shape = arr[0].shape
+    for a in arr[1:]:
+        if not isinstance(a, np.ndarray):
+            return False
+        if a.shape != shape:
+            return True
+    return True
+
+
+def _create_possibly_ragged_ndarray(
+    values: Union[np.ndarray, "ABCSeries", Sequence[Any]]
+) -> np.ndarray:
+    """
+    Create a possibly ragged ndarray.
+    Using the np.array() constructor will fail to construct a ragged ndarray that has a
+    uniform first dimension (e.g. uniform channel dimension in imagery). This function
+    catches this failure and tries a create-and-fill method to construct the ragged
+    ndarray.
+    """
+    try:
+        with warnings.catch_warnings():
+            # For NumPy < 1.24, constructing a ragged ndarray directly via
+            # `np.array(...)` without the `dtype=object` parameter will raise a
+            # VisibleDeprecationWarning which we suppress.
+            # More details: https://stackoverflow.com/q/63097829
+            warnings.simplefilter("ignore", category=np.VisibleDeprecationWarning)
+            return np.array(values, copy=False)
+    except ValueError as e:
+        # Constructing a ragged ndarray directly via `np.array(...)`
+        # without the `dtype=object` parameter will raise a ValueError.
+        # For NumPy < 1.24, the message is of the form:
+        # "could not broadcast input array from shape..."
+        # For NumPy >= 1.24, the message is of the form:
+        # "The requested array has an inhomogeneous shape..."
+        # More details: https://github.com/numpy/numpy/pull/22004
+        error_str = str(e)
+        if (
+            "could not broadcast input array from shape" in error_str
+            or "The requested array has an inhomogeneous shape" in error_str
+        ):
+            # Fall back to strictly creating a ragged ndarray.
+            return create_ragged_ndarray(values)
+        else:
+            # Re-raise original error if the failure wasn't a broadcast error.
+            raise e from None
+
+
+@PublicAPI(stability="alpha")
+def create_ragged_ndarray(values: Sequence[Any]) -> np.ndarray:
+    """Create an array that contains arrays of different length
+
+    If you're working with variable-length arrays like images, use this function to
+    create ragged arrays instead of ``np.array``.
+
+    .. note::
+        ``np.array`` fails to construct ragged arrays if the input arrays have a uniform
+        first dimension:
+
+        .. testsetup::
+
+            import numpy as np
+            from ray.air.util.tensor_extensions.utils import create_ragged_ndarray
+
+        .. doctest::
+
+            >>> values = [np.zeros((3, 1)), np.zeros((3, 2))]
+            >>> np.array(values, dtype=object)
+            Traceback (most recent call last):
+                ...
+            ValueError: could not broadcast input array from shape (3,1) into shape (3,)
+            >>> create_ragged_ndarray(values)
+            array([array([[0.],
+                          [0.],
+                          [0.]]), array([[0., 0.],
+                                         [0., 0.],
+                                         [0., 0.]])], dtype=object)
+
+        Or if you're creating a ragged array from a single array:
+
+        .. doctest::
+
+            >>> values = [np.zeros((3, 1))]
+            >>> np.array(values, dtype=object)[0].dtype
+            dtype('O')
+            >>> create_ragged_ndarray(values)[0].dtype
+            dtype('float64')
+
+        ``create_ragged_ndarray`` avoids the limitations of ``np.array`` by creating an
+        empty array and filling it with pointers to the variable-length arrays.
+    """  # noqa: E501
+    # Create an empty object-dtyped 1D array.
+    arr = np.empty(len(values), dtype=object)
+    # Try to fill the 1D array of pointers with the (ragged) tensors.
+    arr[:] = list(values)
+    return arr

infer_4_37_2/lib/python3.10/site-packages/ray/core/generated/agent_manager_pb2.py

@@ -0,0 +1,32 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: src/ray/protobuf/agent_manager.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n$src/ray/protobuf/agent_manager.proto\x12\x07ray.rpc*F\n\x0e\x41gentRpcStatus\x12\x17\n\x13\x41GENT_RPC_STATUS_OK\x10\x00\x12\x1b\n\x17\x41GENT_RPC_STATUS_FAILED\x10\x01\x42\x03\xf8\x01\x01\x62\x06proto3')
+
+_AGENTRPCSTATUS = DESCRIPTOR.enum_types_by_name['AgentRpcStatus']
+AgentRpcStatus = enum_type_wrapper.EnumTypeWrapper(_AGENTRPCSTATUS)
+AGENT_RPC_STATUS_OK = 0
+AGENT_RPC_STATUS_FAILED = 1
+
+
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  DESCRIPTOR._serialized_options = b'\370\001\001'
+  _AGENTRPCSTATUS._serialized_start=49
+  _AGENTRPCSTATUS._serialized_end=119
+# @@protoc_insertion_point(module_scope)

infer_4_37_2/lib/python3.10/site-packages/ray/core/generated/autoscaler_pb2_grpc.py

@@ -0,0 +1,198 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from . import autoscaler_pb2 as src_dot_ray_dot_protobuf_dot_autoscaler__pb2
+
+
+class AutoscalerStateServiceStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.GetClusterResourceState = channel.unary_unary(
+                '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterResourceState',
+                request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateRequest.SerializeToString,
+                response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateReply.FromString,
+                )
+        self.ReportAutoscalingState = channel.unary_unary(
+                '/ray.rpc.autoscaler.AutoscalerStateService/ReportAutoscalingState',
+                request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateRequest.SerializeToString,
+                response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateReply.FromString,
+                )
+        self.RequestClusterResourceConstraint = channel.unary_unary(
+                '/ray.rpc.autoscaler.AutoscalerStateService/RequestClusterResourceConstraint',
+                request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintRequest.SerializeToString,
+                response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintReply.FromString,
+                )
+        self.GetClusterStatus = channel.unary_unary(
+                '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterStatus',
+                request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusRequest.SerializeToString,
+                response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusReply.FromString,
+                )
+        self.DrainNode = channel.unary_unary(
+                '/ray.rpc.autoscaler.AutoscalerStateService/DrainNode',
+                request_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeRequest.SerializeToString,
+                response_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeReply.FromString,
+                )
+
+
+class AutoscalerStateServiceServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def GetClusterResourceState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def ReportAutoscalingState(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def RequestClusterResourceConstraint(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def GetClusterStatus(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def DrainNode(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_AutoscalerStateServiceServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'GetClusterResourceState': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetClusterResourceState,
+                    request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateRequest.FromString,
+                    response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateReply.SerializeToString,
+            ),
+            'ReportAutoscalingState': grpc.unary_unary_rpc_method_handler(
+                    servicer.ReportAutoscalingState,
+                    request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateRequest.FromString,
+                    response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateReply.SerializeToString,
+            ),
+            'RequestClusterResourceConstraint': grpc.unary_unary_rpc_method_handler(
+                    servicer.RequestClusterResourceConstraint,
+                    request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintRequest.FromString,
+                    response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintReply.SerializeToString,
+            ),
+            'GetClusterStatus': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetClusterStatus,
+                    request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusRequest.FromString,
+                    response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusReply.SerializeToString,
+            ),
+            'DrainNode': grpc.unary_unary_rpc_method_handler(
+                    servicer.DrainNode,
+                    request_deserializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeRequest.FromString,
+                    response_serializer=src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeReply.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'ray.rpc.autoscaler.AutoscalerStateService', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class AutoscalerStateService(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def GetClusterResourceState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterResourceState',
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateRequest.SerializeToString,
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterResourceStateReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def ReportAutoscalingState(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/ReportAutoscalingState',
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateRequest.SerializeToString,
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.ReportAutoscalingStateReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def RequestClusterResourceConstraint(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/RequestClusterResourceConstraint',
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintRequest.SerializeToString,
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.RequestClusterResourceConstraintReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def GetClusterStatus(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/GetClusterStatus',
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusRequest.SerializeToString,
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.GetClusterStatusReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def DrainNode(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/ray.rpc.autoscaler.AutoscalerStateService/DrainNode',
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeRequest.SerializeToString,
+            src_dot_ray_dot_protobuf_dot_autoscaler__pb2.DrainNodeReply.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

infer_4_37_2/lib/python3.10/site-packages/ray/core/generated/common_pb2_grpc.py

@@ -0,0 +1,4 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+