ray-project--ray/python/ray/data/BUILD.bazel

load("@rules_python//python:defs.bzl", "py_library", "py_test")
load("//bazel:python.bzl", "doctest", "py_test_module_list")

# Export pytest plugin so it can be used in the documentation tests.
exports_files(
    ["tests/doctest_pytest_plugin.py"],
)

# Run automatic tests against docstrings on all source files.
doctest(
    size = "large",
    files = glob(
        ["**/*.py"],
        exclude = glob([
            "examples/**/*",
            "tests/**/*",
        ]),
    ),
    # Installs data-specific fixtures to run between the doctests.
    pytest_plugin_file = "//python/ray/data:tests/doctest_pytest_plugin.py",
    tags = ["team:data"],
)

py_library(
    name = "conftest",
    srcs = ["tests/conftest.py"],
    deps = ["//python/ray/tests:conftest"],
)

py_test_module_list(
    size = "small",
    files = glob(["tests/unit/**/test_*.py"]),
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test_module_list(
    size = "medium",
    files = glob(["_internal/datasource_v2/tests/test_*.py"]),
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test_module_list(
    size = "small",
    files = glob(["_internal/logical/operators/tests/test_*.py"]),
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test_module_list(
    size = "medium",
    files = glob(["tests/block_batching/test_*.py"]),
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test_module_list(
    size = "medium",
    files = glob(["tests/expressions/test_*.py"]),
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test_module_list(
    size = "medium",
    files = glob(["tests/preprocessors/test_*.py"]),
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_arrow",
    size = "small",
    srcs = ["tests/datasource/test_arrow.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_strict_mode",
    size = "small",
    srcs = ["tests/test_strict_mode.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_issue_detection_manager",
    size = "small",
    srcs = ["tests/test_issue_detection_manager.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_issue_detection",
    size = "small",
    srcs = ["tests/test_issue_detection.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_numpy_support",
    size = "small",
    srcs = ["tests/test_numpy_support.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_sql",
    size = "small",
    srcs = ["tests/datasource/test_sql.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_snowflake",
    size = "small",
    srcs = ["tests/datasource/test_snowflake.py"],
    tags = [
        "exclusive",
        "needs_credentials",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_mongo",
    size = "medium",
    srcs = ["tests/datasource/test_mongo.py"],
    tags = [
        "data_integration",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_bigquery",
    size = "small",
    srcs = ["tests/datasource/test_bigquery.py"],
    tags = [
        "data_integration",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_actor_pool_map_operator",
    size = "medium",
    srcs = ["tests/test_actor_pool_map_operator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_arrow_serialization",
    size = "small",
    srcs = ["tests/test_arrow_serialization.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_arrow_block",
    size = "medium",
    srcs = ["tests/test_arrow_block.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_jumbo_arrow_block",
    size = "large",
    srcs = ["tests/test_jumbo_arrow_block.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_auto_parallelism",
    size = "medium",
    srcs = ["tests/test_auto_parallelism.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_batcher",
    size = "medium",
    srcs = ["tests/test_batcher.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_cudf_batch_format",
    size = "medium",
    srcs = ["tests/test_cudf_batch_format.py"],
    tags = [
        "cudf",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_block_batching",
    size = "small",
    srcs = ["tests/block_batching/test_block_batching.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_block_metadata_schema_cache",
    size = "small",
    srcs = ["tests/unit/test_block_metadata_schema_cache.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_block_sizing",
    size = "medium",
    srcs = ["tests/test_block_sizing.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_context_propagation",
    size = "medium",
    srcs = ["tests/test_context_propagation.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_audio",
    size = "small",
    srcs = ["tests/datasource/test_audio.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_avro",
    size = "small",
    srcs = ["tests/datasource/test_avro.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_agg_e2e",
    size = "medium",
    srcs = ["tests/test_agg_e2e.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_groupby_e2e",
    size = "enormous",
    srcs = ["tests/test_groupby_e2e.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_random_e2e",
    size = "large",
    srcs = ["tests/test_random_e2e.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_repartition_e2e",
    size = "medium",
    srcs = ["tests/test_repartition_e2e.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_unique_e2e",
    size = "small",
    srcs = ["tests/test_unique_e2e.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_join",
    size = "medium",
    srcs = ["tests/test_join.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_binary",
    size = "small",
    srcs = ["tests/datasource/test_binary.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_consumption",
    size = "large",
    srcs = ["tests/test_consumption.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dataset_limits",
    size = "medium",
    srcs = ["tests/test_dataset_limits.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dataset_creation",
    size = "small",
    srcs = ["tests/test_dataset_creation.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dataset_validation",
    size = "medium",
    srcs = ["tests/test_dataset_validation.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dataset_aggregrations",
    size = "large",
    srcs = ["tests/test_dataset_aggregrations.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dataset_iter",
    size = "medium",
    srcs = ["tests/test_dataset_iter.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_csv",
    size = "small",
    srcs = ["tests/datasource/test_csv.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_datasink",
    size = "small",
    srcs = ["tests/datasource/test_datasink.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_ecosystem_modin",
    size = "small",
    srcs = ["tests/test_ecosystem_modin.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_ecosystem_dask",
    size = "small",
    srcs = ["tests/test_ecosystem_dask.py"],
    tags = [
        "custom_setup",
        "dask",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_file_based_datasource",
    size = "small",
    srcs = ["tests/datasource/test_file_based_datasource.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_file_datasink",
    size = "small",
    srcs = ["tests/datasource/test_file_datasink.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_turbopuffer_datasink",
    size = "small",
    srcs = ["tests/datasource/test_turbopuffer_datasink.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_gpu_shuffle",
    size = "medium",
    srcs = ["tests/test_gpu_shuffle.py"],
    tags = [
        "exclusive",
        "gpu",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_gpu_aggregate",
    size = "medium",
    srcs = ["tests/test_gpu_aggregate.py"],
    tags = [
        "exclusive",
        "gpu",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_hash_shuffle",
    size = "medium",
    srcs = ["tests/test_hash_shuffle.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_hash_shuffle_aggregator",
    size = "small",
    srcs = ["tests/test_hash_shuffle_aggregator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_hash_shuffle_v2",
    size = "medium",
    srcs = ["tests/test_hash_shuffle_v2.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_hudi",
    size = "small",
    srcs = ["tests/datasource/test_hudi.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_image",
    size = "medium",
    srcs = ["tests/datasource/test_image.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_iterator",
    size = "small",
    srcs = ["tests/test_iterator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_json",
    size = "small",
    srcs = ["tests/datasource/test_json.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_logging_dataset",
    size = "small",
    srcs = ["tests/test_logging_dataset.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_logging",
    size = "medium",
    srcs = ["tests/test_logging.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_map",
    size = "enormous",
    srcs = ["tests/test_map.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_map_batches",
    size = "large",
    srcs = ["tests/test_map_batches.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_auto_batch_size",
    size = "medium",
    srcs = ["tests/test_auto_batch_size.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_with_column",
    size = "medium",
    srcs = ["tests/test_with_column.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_filter",
    size = "small",
    srcs = ["tests/test_filter.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_numpy",
    size = "small",
    srcs = ["tests/datasource/test_numpy.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_pandas",
    size = "small",
    srcs = ["tests/datasource/test_pandas.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_pandas_block",
    size = "small",
    srcs = ["tests/test_pandas_block.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_parquet",
    size = "large",
    srcs = ["tests/datasource/test_parquet.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_read_parquet_v2",
    size = "small",
    srcs = ["tests/datasource/test_read_parquet_v2.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_projection_fusion",
    size = "small",
    srcs = ["tests/test_projection_fusion.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_predicate_pushdown",
    size = "small",
    srcs = ["tests/test_predicate_pushdown.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_common_subexpr_elimination",
    size = "small",
    srcs = ["tests/test_common_subexpr_elimination.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_idempotency_optimizer_guards",
    size = "small",
    srcs = ["tests/test_idempotency_optimizer_guards.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_infer_schema",
    size = "small",
    srcs = ["tests/test_infer_schema.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_task_pool_map_operator",
    size = "small",
    srcs = ["tests/test_task_pool_map_operator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_tensor",
    size = "small",
    srcs = ["tests/test_tensor.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_tensor_extension",
    size = "small",
    srcs = ["tests/test_tensor_extension.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_text",
    size = "medium",
    srcs = ["tests/datasource/test_text.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_tf",
    size = "medium",
    srcs = ["tests/datasource/test_tf.py"],
    # Adding to use keras 2 & tensorflow >= 2.16 (https://keras.io/getting_started)
    env = {"TF_USE_LEGACY_KERAS": "1"},
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_tfrecords",
    size = "small",
    srcs = ["tests/datasource/test_tfrecords.py"],
    # Adding to use keras 2 & tensorflow >= 2.16 (https://keras.io/getting_started)
    env = {"TF_USE_LEGACY_KERAS": "1"},
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_torch",
    size = "small",
    srcs = ["tests/datasource/test_torch.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_torch_iter_batches",
    size = "small",
    srcs = ["tests/test_torch_iter_batches.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_torch_tensor_utils",
    size = "small",
    srcs = ["tests/test_torch_tensor_utils.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dynamic_block_split",
    size = "large",
    srcs = ["tests/test_dynamic_block_split.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_splitblocks",
    size = "medium",
    srcs = ["tests/test_splitblocks.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_exceptions",
    size = "small",
    srcs = ["tests/test_exceptions.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_operator_fusion",
    size = "medium",
    srcs = ["tests/test_operator_fusion.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_execution_optimizer_basic",
    size = "small",
    srcs = ["tests/test_execution_optimizer_basic.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_execution_optimizer_advanced",
    size = "medium",
    srcs = ["tests/test_execution_optimizer_advanced.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_execution_optimizer_integrations",
    size = "medium",
    srcs = ["tests/test_execution_optimizer_integrations.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_tensorflow_datasets",
    size = "small",
    srcs = ["tests/datasource/test_tensorflow_datasets.py"],
    tags = [
        "exclusive",
        "team:data",
        "tensorflow_datasets",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_execution_optimizer_limit_pushdown",
    size = "medium",
    srcs = ["tests/test_execution_optimizer_limit_pushdown.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_executor_resource_management",
    size = "small",
    srcs = ["tests/test_executor_resource_management.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_huggingface",
    size = "small",
    srcs = ["tests/datasource/test_huggingface.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_iceberg",
    size = "medium",
    srcs = ["tests/datasource/test_iceberg.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_kafka",
    size = "medium",
    srcs = ["tests/datasource/test_kafka.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_metadata_provider",
    size = "small",
    srcs = ["tests/test_metadata_provider.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_object_gc",
    size = "large",
    srcs = ["tests/test_object_gc.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_operators",
    size = "small",
    srcs = ["tests/test_operators.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_block_ref_counter",
    size = "small",
    srcs = ["tests/test_block_ref_counter.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_map_operator",
    size = "medium",
    srcs = ["tests/test_map_operator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_map_transformer",
    size = "small",
    srcs = ["tests/test_map_transformer.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_limit_operator",
    size = "small",
    srcs = ["tests/test_limit_operator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_output_splitter",
    size = "medium",
    srcs = ["tests/test_output_splitter.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_op_runtime_metrics",
    size = "small",
    srcs = ["tests/test_op_runtime_metrics.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_optimize",
    size = "medium",
    srcs = ["tests/test_optimize.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_partitioning",
    size = "small",
    srcs = ["tests/test_partitioning.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_progress_bar",
    size = "small",
    srcs = ["tests/test_progress_bar.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_progress_manager",
    size = "small",
    srcs = ["tests/test_progress_manager.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_random_access",
    size = "small",
    srcs = ["tests/test_random_access.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_randomize_block_order",
    size = "small",
    srcs = ["tests/test_randomize_block_order.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_ranker",
    size = "small",
    srcs = ["tests/test_ranker.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_raydp",
    size = "medium",
    srcs = ["tests/datasource/test_raydp.py"],
    tags = [
        "data_integration",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_size_estimation",
    size = "medium",
    srcs = ["tests/test_size_estimation.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_sort",
    size = "enormous",
    srcs = ["tests/test_sort.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_push_based_shuffle",
    size = "enormous",
    srcs = ["tests/test_push_based_shuffle.py"],
    tags = [
        "data_non_parallel",
        "data_non_parallel_postmerge_only",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_shuffle_diagnostics",
    size = "large",
    srcs = ["tests/test_shuffle_diagnostics.py"],
    tags = [
        "data_non_parallel",
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_split",
    size = "large",
    srcs = ["tests/test_split.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_stats",
    size = "large",
    srcs = ["tests/test_stats.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_streaming_executor",
    size = "medium",
    srcs = ["tests/test_streaming_executor.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_ref_bundle",
    size = "small",
    srcs = ["tests/test_ref_bundle.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_reservation_based_resource_allocator",
    size = "small",
    srcs = ["tests/test_reservation_based_resource_allocator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_resource_manager",
    size = "small",
    srcs = ["tests/test_resource_manager.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_streaming_executor_errored_blocks",
    size = "small",
    srcs = ["tests/test_streaming_executor_errored_blocks.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_streaming_integration",
    size = "medium",
    srcs = ["tests/test_streaming_integration.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_transform_pyarrow",
    size = "small",
    srcs = ["tests/test_transform_pyarrow.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_unify_schemas_performance",
    size = "small",
    srcs = ["tests/test_unify_schemas_performance.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_usage",
    size = "small",
    srcs = ["tests/test_usage.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_util",
    size = "small",
    srcs = ["tests/test_util.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_union",
    size = "small",
    srcs = ["tests/test_union.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_video",
    size = "small",
    srcs = ["tests/datasource/test_video.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_webdataset",
    size = "medium",
    srcs = ["tests/datasource/test_webdataset.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_zarrv2",
    size = "medium",
    srcs = ["tests/datasource/test_zarrv2.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_zip",
    size = "small",
    srcs = ["tests/test_zip.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_backpressure_policies",
    size = "small",
    srcs = ["tests/test_backpressure_policies.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_downstream_capacity_backpressure_policy",
    size = "small",
    srcs = ["tests/test_downstream_capacity_backpressure_policy.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_backpressure_e2e",
    size = "large",
    srcs = ["tests/test_backpressure_e2e.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_bundle_queue",
    size = "small",
    srcs = ["tests/test_bundle_queue.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_actor_autoscaler",
    size = "small",
    srcs = ["tests/test_actor_autoscaler.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_autoscaling_coordinator",
    size = "medium",
    srcs = ["tests/test_autoscaling_coordinator.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_clickhouse",
    size = "small",
    srcs = ["tests/datasource/test_clickhouse.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_lance",
    size = "small",
    srcs = ["tests/datasource/test_lance.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_mcap",
    size = "small",
    srcs = ["tests/datasource/test_mcap.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_default_cluster_autoscaler_v2",
    size = "small",
    srcs = ["tests/test_default_cluster_autoscaler_v2.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_delta_sharing",
    size = "small",
    srcs = ["tests/datasource/test_delta_sharing.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_monotonically_increasing_id",
    size = "small",
    srcs = ["tests/test_monotonically_increasing_id.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_download_expression",
    size = "small",
    srcs = ["tests/test_download_expression.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_context",
    size = "small",
    srcs = ["tests/test_context.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_telemetry",
    size = "medium",
    srcs = ["tests/test_telemetry.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_import",
    size = "small",
    srcs = ["tests/test_import.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_daft",
    size = "small",
    srcs = ["tests/datasource/test_daft.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_state_export",
    size = "medium",
    srcs = ["tests/test_state_export.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_operator_schema_export",
    size = "small",
    srcs = ["tests/test_operator_schema_export.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_delta",
    size = "small",
    srcs = ["tests/datasource/test_delta.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_aggregations",
    size = "medium",
    srcs = ["tests/test_aggregations.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_dataset_stats",
    size = "medium",
    srcs = ["tests/test_dataset_stats.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_preserve_hash_shuffle_blocks",
    size = "medium",
    srcs = ["tests/test_preserve_hash_shuffle_blocks.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_checkpoint",
    size = "medium",
    srcs = ["tests/test_checkpoint.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_read_datasource",
    size = "small",
    srcs = ["tests/test_read_datasource.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_catalog",
    size = "small",
    srcs = ["tests/test_catalog.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_iter_jax",
    size = "small",
    srcs = ["tests/test_iter_jax.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_random_api",
    size = "small",
    srcs = ["tests/test_random_api.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_synthetic_expression",
    size = "small",
    srcs = ["tests/test_synthetic_expression.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)

py_test(
    name = "test_mix",
    size = "small",
    srcs = ["tests/test_mix.py"],
    tags = [
        "exclusive",
        "team:data",
    ],
    deps = [
        ":conftest",
        "//:ray_lib",
    ],
)