Add files using upload-large-folder tool

.gitattributes

@@ -4443,3 +4443,5 @@ tool_server/.venv/lib/python3.12/site-packages/ray/core/src/ray/raylet/raylet fi
 tool_server/.venv/lib/python3.12/site-packages/ray/dag/__pycache__/compiled_dag_node.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/ray/data/__pycache__/dataset.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
 tool_server/.venv/lib/python3.12/site-packages/ray/data/__pycache__/read_api.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/ray/rllib/algorithms/__pycache__/algorithm.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+tool_server/.venv/lib/python3.12/site-packages/ray/rllib/algorithms/__pycache__/algorithm_config.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/issue_detection/detectors/__init__.py

@@ -0,0 +1,19 @@
+from ray.data._internal.issue_detection.detectors.hanging_detector import (
+    HangingExecutionIssueDetector,
+    HangingExecutionIssueDetectorConfig,
+)
+from ray.data._internal.issue_detection.detectors.hash_shuffle_detector import (
+    HashShuffleAggregatorIssueDetector,
+)
+from ray.data._internal.issue_detection.detectors.high_memory_detector import (
+    HighMemoryIssueDetector,
+    HighMemoryIssueDetectorConfig,
+)
+
+__all__ = [
+    "HangingExecutionIssueDetector",
+    "HangingExecutionIssueDetectorConfig",
+    "HighMemoryIssueDetector",
+    "HighMemoryIssueDetectorConfig",
+    "HashShuffleAggregatorIssueDetector",
+]

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/issue_detection/detectors/hanging_detector.py

@@ -0,0 +1,163 @@
+import time
+from collections import defaultdict
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Dict, List, Set
+
+from ray.data._internal.issue_detection.issue_detector import (
+    Issue,
+    IssueDetector,
+    IssueType,
+)
+
+if TYPE_CHECKING:
+    from ray.data._internal.execution.interfaces.op_runtime_metrics import (
+        TaskDurationStats,
+    )
+    from ray.data._internal.execution.streaming_executor import StreamingExecutor
+    from ray.data.context import DataContext
+
+# Default minimum count of tasks before using adaptive thresholds
+DEFAULT_OP_TASK_STATS_MIN_COUNT = 10
+# Default multiple of standard deviations to use as hanging threshold
+DEFAULT_OP_TASK_STATS_STD_FACTOR = 10
+# Default detection time interval.
+DEFAULT_DETECTION_TIME_INTERVAL_S = 30.0
+
+
+@dataclass
+class HangingExecutionState:
+    operator_id: str
+    task_idx: int
+    bytes_output: int
+    start_time_hanging: float
+
+
+@dataclass
+class HangingExecutionIssueDetectorConfig:
+    op_task_stats_min_count: int = field(default=DEFAULT_OP_TASK_STATS_MIN_COUNT)
+    op_task_stats_std_factor: float = field(default=DEFAULT_OP_TASK_STATS_STD_FACTOR)
+    detection_time_interval_s: float = DEFAULT_DETECTION_TIME_INTERVAL_S
+
+
+class HangingExecutionIssueDetector(IssueDetector):
+    def __init__(self, executor: "StreamingExecutor", ctx: "DataContext"):
+        super().__init__(executor, ctx)
+        self._detector_cfg: HangingExecutionIssueDetectorConfig = (
+            ctx.issue_detectors_config.hanging_detector_config
+        )
+        self._op_task_stats_min_count = self._detector_cfg.op_task_stats_min_count
+        self._op_task_stats_std_factor_threshold = (
+            self._detector_cfg.op_task_stats_std_factor
+        )
+
+        # Map of operator id to dict of task_idx to hanging execution info (bytes read and
+        # start time for hanging time calculation)
+        self._state_map: Dict[str, Dict[int, HangingExecutionState]] = defaultdict(dict)
+        # Map of operator id to set of task_idx that are hanging
+        self._hanging_op_tasks: Dict[str, Set[int]] = defaultdict(set)
+        # Map of operator id to operator name
+        self._op_id_to_name: Dict[str, str] = {}
+
+    def _create_issues(
+        self,
+        hanging_op_tasks: List[HangingExecutionState],
+        op_task_stats_map: Dict[str, "TaskDurationStats"],
+    ) -> List[Issue]:
+        issues = []
+        for state in hanging_op_tasks:
+            if state.task_idx not in self._hanging_op_tasks[state.operator_id]:
+                op_name = self._op_id_to_name.get(state.operator_id, state.operator_id)
+                duration = time.perf_counter() - state.start_time_hanging
+                avg_duration = op_task_stats_map[state.operator_id].mean()
+                message = (
+                    f"A task of operator {op_name} with task index "
+                    f"{state.task_idx} has been running for {duration:.2f}s, which is longer"
+                    f" than the average task duration of this operator ({avg_duration:.2f}s)."
+                    f" If this message persists, please check the stack trace of the "
+                    "task for potential hanging issues."
+                )
+                issues.append(
+                    Issue(
+                        dataset_name=self._executor._dataset_id,
+                        operator_id=state.operator_id,
+                        issue_type=IssueType.HANGING,
+                        message=message,
+                    )
+                )
+                self._hanging_op_tasks[state.operator_id].add(state.task_idx)
+
+        return issues
+
+    def detect(self) -> List[Issue]:
+        op_task_stats_map: Dict[str, "TaskDurationStats"] = {}
+        for operator, op_state in self._executor._topology.items():
+            op_metrics = operator.metrics
+            op_task_stats_map[operator.id] = op_metrics._op_task_duration_stats
+            self._op_id_to_name[operator.id] = operator.name
+            if op_state._finished:
+                # Remove finished operators / tasks from the state map
+                if operator.id in self._state_map:
+                    del self._state_map[operator.id]
+                if operator.id in self._hanging_op_tasks:
+                    del self._hanging_op_tasks[operator.id]
+            else:
+                active_tasks_idx = set()
+                for task in operator.get_active_tasks():
+                    task_info = op_metrics._running_tasks.get(task.task_index(), None)
+                    if task_info is None:
+                        # if the task is not in the running tasks map, it has finished
+                        # remove it from the state map and hanging op tasks, if present
+                        self._state_map[operator.id].pop(task.task_index(), None)
+                        self._hanging_op_tasks[operator.id].discard(task.task_index())
+                        continue
+
+                    active_tasks_idx.add(task.task_index())
+                    bytes_output = task_info.bytes_outputs
+
+                    prev_state_value = self._state_map[operator.id].get(
+                        task.task_index(), None
+                    )
+
+                    if (
+                        prev_state_value is None
+                        or bytes_output != prev_state_value.bytes_output
+                    ):
+                        self._state_map[operator.id][
+                            task.task_index()
+                        ] = HangingExecutionState(
+                            operator_id=operator.id,
+                            task_idx=task.task_index(),
+                            bytes_output=bytes_output,
+                            start_time_hanging=time.perf_counter(),
+                        )
+
+                # Remove any tasks that are no longer active
+                task_idxs_to_remove = (
+                    set(self._state_map[operator.id].keys()) - active_tasks_idx
+                )
+                for task_idx in task_idxs_to_remove:
+                    del self._state_map[operator.id][task_idx]
+
+        hanging_op_tasks = []
+        for op_id, op_state_values in self._state_map.items():
+            op_task_stats = op_task_stats_map[op_id]
+            for task_idx, state_value in op_state_values.items():
+                curr_time = time.perf_counter() - state_value.start_time_hanging
+                if op_task_stats.count() > self._op_task_stats_min_count:
+                    mean = op_task_stats.mean()
+                    stddev = op_task_stats.stddev()
+                    threshold = mean + self._op_task_stats_std_factor_threshold * stddev
+
+                    if curr_time > threshold:
+                        hanging_op_tasks.append(state_value)
+
+        # create issues for newly detected hanging tasks, then update the hanging task set
+        issues = self._create_issues(
+            hanging_op_tasks=hanging_op_tasks,
+            op_task_stats_map=op_task_stats_map,
+        )
+
+        return issues
+
+    def detection_time_interval_s(self) -> float:
+        return self._detector_cfg.detection_time_interval_s

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/issue_detection/detectors/hash_shuffle_detector.py

@@ -0,0 +1,110 @@
+import time
+from typing import TYPE_CHECKING, List
+
+import ray
+from ray.data._internal.execution.operators.hash_shuffle import (
+    AggregatorHealthInfo,
+    HashShuffleOperator,
+)
+from ray.data._internal.issue_detection.issue_detector import (
+    Issue,
+    IssueDetector,
+    IssueType,
+)
+from ray.data._internal.util import GiB
+
+if TYPE_CHECKING:
+    from ray.data._internal.execution.streaming_executor import StreamingExecutor
+    from ray.data.context import DataContext
+
+
+class HashShuffleAggregatorIssueDetector(IssueDetector):
+    """Detector for hash shuffle aggregator health issues."""
+
+    def __init__(self, executor: "StreamingExecutor", ctx: "DataContext"):
+        super().__init__(executor, ctx)
+        self._last_warning_times = {}  # Track per-operator warning times
+
+    def detect(self) -> List[Issue]:
+        issues = []
+        current_time = time.time()
+
+        # Find all hash shuffle operators in the topology
+        for op in self._executor._topology.keys():
+            if not isinstance(op, HashShuffleOperator):
+                continue
+
+            # Skip if operator doesn't have aggregator pool yet
+            if op._aggregator_pool is None:
+                continue
+
+            pool = op._aggregator_pool
+            aggregator_info = pool.check_aggregator_health()
+
+            if aggregator_info is None:
+                continue
+
+            # Check if we should emit a warning for this operator
+            should_warn = self._should_emit_warning(
+                op.id, current_time, aggregator_info
+            )
+
+            if should_warn:
+                message = self._format_health_warning(aggregator_info)
+                issues.append(
+                    Issue(
+                        dataset_name=self._executor._dataset_id,
+                        operator_id=op.id,
+                        issue_type=IssueType.HANGING,
+                        message=message,
+                    )
+                )
+                self._last_warning_times[op.id] = current_time
+
+        return issues
+
+    def detection_time_interval_s(self) -> float:
+        return self._ctx.hash_shuffle_aggregator_health_warning_interval_s
+
+    def _should_emit_warning(
+        self, op_id: str, current_time: float, info: AggregatorHealthInfo
+    ) -> bool:
+        """Check if we should emit a warning for this operator."""
+        if not info.has_unready_aggregators:
+            # Clear warning time if all aggregators are healthy
+            self._last_warning_times.pop(op_id, None)
+            return False
+
+        # Check if enough time has passed since start
+        if (
+            current_time - info.started_at
+            < self._ctx.min_hash_shuffle_aggregator_wait_time_in_s
+        ):
+            return False
+
+        # Check if enough time has passed since last warning
+        last_warning = self._last_warning_times.get(op_id)
+        if last_warning is None:
+            return True
+
+        return current_time - last_warning >= self.detection_time_interval_s()
+
+    def _format_health_warning(self, info: AggregatorHealthInfo) -> str:
+        """Format the health warning message."""
+        available_resources = ray.available_resources()
+        available_cpus = available_resources.get("CPU", 0)
+        cluster_resources = ray.cluster_resources()
+        total_memory = cluster_resources.get("memory", 0)
+        available_memory = available_resources.get("memory", 0)
+
+        return (
+            f"Only {info.ready_aggregators} out of {info.total_aggregators} "
+            f"hash-shuffle aggregators are ready after {info.wait_time:.1f} secs. "
+            f"This might indicate resource contention for cluster resources "
+            f"(available CPUs: {available_cpus}, required CPUs: {info.required_resources.cpu}). "
+            f"Cluster only has {available_memory / GiB:.2f} GiB available memory, required memory: {info.required_resources.memory / GiB:.2f} GiB. "
+            f"{total_memory / GiB:.2f} GiB total memory. "
+            f"Consider increasing cluster size or reducing the number of aggregators "
+            f"via `DataContext.max_hash_shuffle_aggregators`. "
+            f"Will continue checking every {self.detection_time_interval_s()}s."
+        )

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/issue_detection/detectors/high_memory_detector.py

@@ -0,0 +1,101 @@
+import textwrap
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Dict, List
+
+from ray.data._internal.execution.operators.map_operator import MapOperator
+from ray.data._internal.execution.util import memory_string
+from ray.data._internal.issue_detection.issue_detector import (
+    Issue,
+    IssueDetector,
+    IssueType,
+)
+
+if TYPE_CHECKING:
+    from ray.data._internal.execution.streaming_executor import StreamingExecutor
+    from ray.data.context import DataContext
+
+HIGH_MEMORY_PERIODIC_WARNING = """
+Operator '{op_name}' uses {memory_per_task} of memory per task on average, but Ray
+only requests {initial_memory_request} per task at the start of the pipeline.
+
+To avoid out-of-memory errors, consider setting `memory={memory_per_task}` in the
+appropriate function or method call. (This might be unnecessary if the number of
+concurrent tasks is low.)
+
+To change the frequency of this warning, set
+`DataContext.get_current().issue_detectors_config.high_memory_detector_config.detection_time_interval_s`,
+or disable the warning by setting value to -1. (current value:
+{detection_time_interval_s})
+"""  # noqa: E501
+
+
+@dataclass
+class HighMemoryIssueDetectorConfig:
+    detection_time_interval_s: float = 30
+
+
+class HighMemoryIssueDetector(IssueDetector):
+
+    # Many nodes have a 4 GiB : 1 core ratio, but this isn't always the case (e.g., for
+    # high memory nodes).
+    _MEMORY_PER_CORE_ESTIMATE = 4 * 1024**3
+
+    def __init__(self, executor: "StreamingExecutor", ctx: "DataContext"):
+        super().__init__(executor, ctx)
+        self._detector_cfg = ctx.issue_detectors_config.high_memory_detector_config
+
+        self._initial_memory_requests: Dict[MapOperator, int] = {}
+        for op in self._executor._topology.keys():
+            if isinstance(op, MapOperator):
+                self._initial_memory_requests[op] = (
+                    op._get_runtime_ray_remote_args().get("memory") or 0
+                )
+
+    def detect(self) -> List[Issue]:
+        issues = []
+        for op in self._executor._topology.keys():
+            if not isinstance(op, MapOperator):
+                continue
+
+            if op.metrics.average_max_uss_per_task is None:
+                continue
+
+            remote_args = op._get_runtime_ray_remote_args()
+            num_cpus_per_task = remote_args.get("num_cpus", 1)
+            max_memory_per_task = self._MEMORY_PER_CORE_ESTIMATE * num_cpus_per_task
+
+            if (
+                op.metrics.average_max_uss_per_task > self._initial_memory_requests[op]
+                and op.metrics.average_max_uss_per_task >= max_memory_per_task
+            ):
+                message = HIGH_MEMORY_PERIODIC_WARNING.format(
+                    op_name=op.name,
+                    memory_per_task=memory_string(op.metrics.average_max_uss_per_task),
+                    initial_memory_request=memory_string(
+                        self._initial_memory_requests[op]
+                    ),
+                    detection_time_interval_s=self.detection_time_interval_s(),
+                )
+                issues.append(
+                    Issue(
+                        dataset_name=self._executor._dataset_id,
+                        operator_id=op.id,
+                        issue_type=IssueType.HIGH_MEMORY,
+                        message=_format_message(message),
+                    )
+                )
+
+        return issues
+
+    def detection_time_interval_s(self) -> float:
+        return self._detector_cfg.detection_time_interval_s
+
+
+def _format_message(message: str) -> str:
+    # Apply some formatting to make the message look nicer when printed.
+    formatted_paragraphs = []
+    for paragraph in message.split("\n\n"):
+        formatted_paragraph = textwrap.fill(paragraph, break_long_words=False).strip()
+        formatted_paragraphs.append(formatted_paragraph)
+    formatted_message = "\n\n".join(formatted_paragraphs)
+    return "\n\n" + formatted_message + "\n"

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/__init__.py

@@ -0,0 +1,18 @@
+from .logical_operator import LogicalOperator
+from .logical_plan import LogicalPlan
+from .operator import Operator
+from .optimizer import Optimizer, Rule
+from .physical_plan import PhysicalPlan
+from .plan import Plan
+from .source_operator import SourceOperator
+
+__all__ = [
+    "LogicalOperator",
+    "LogicalPlan",
+    "Operator",
+    "Optimizer",
+    "PhysicalPlan",
+    "Plan",
+    "Rule",
+    "SourceOperator",
+]

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/logical_operator.py

@@ -0,0 +1,88 @@
+from typing import TYPE_CHECKING, Any, Callable, Dict, Iterator, List, Optional
+
+from .operator import Operator
+from ray.data.block import BlockMetadata
+
+if TYPE_CHECKING:
+    from ray.data.block import Schema
+
+
+class LogicalOperator(Operator):
+    """Abstract class for logical operators.
+
+    A logical operator describes transformation, and later is converted into
+    physical operator.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        input_dependencies: List["LogicalOperator"],
+        num_outputs: Optional[int] = None,
+    ):
+        super().__init__(
+            name,
+            input_dependencies,
+        )
+        for x in input_dependencies:
+            assert isinstance(x, LogicalOperator), x
+        self._num_outputs = num_outputs
+
+    def estimated_num_outputs(self) -> Optional[int]:
+        """Returns the estimated number of blocks that
+        would be outputted by this logical operator.
+
+        This method does not execute the plan, so it does not take into consideration
+        block splitting. This method only considers high-level block constraints like
+        `Dataset.repartition(num_blocks=X)`. A more accurate estimation can be given by
+        `PhysicalOperator.num_outputs_total()` during execution.
+        """
+        if self._num_outputs is not None:
+            return self._num_outputs
+        elif len(self._input_dependencies) == 1:
+            return self._input_dependencies[0].estimated_num_outputs()
+        return None
+
+    # Override the following 3 methods to correct type hints.
+
+    @property
+    def input_dependencies(self) -> List["LogicalOperator"]:
+        return super().input_dependencies  # type: ignore
+
+    @property
+    def output_dependencies(self) -> List["LogicalOperator"]:
+        return super().output_dependencies  # type: ignore
+
+    def post_order_iter(self) -> Iterator["LogicalOperator"]:
+        return super().post_order_iter()  # type: ignore
+
+    def _apply_transform(
+        self, transform: Callable[["LogicalOperator"], "LogicalOperator"]
+    ) -> "LogicalOperator":
+        return super()._apply_transform(transform)  # type: ignore
+
+    def _get_args(self) -> Dict[str, Any]:
+        """This Dict must be serializable"""
+        return vars(self)
+
+    def infer_schema(self) -> Optional["Schema"]:
+        """Returns the inferred schema of the output blocks."""
+        return None
+
+    def infer_metadata(self) -> "BlockMetadata":
+        """A ``BlockMetadata`` that represents the aggregate metadata of the outputs.
+
+        This method is used by methods like :meth:`~ray.data.Dataset.schema` to
+        efficiently return metadata.
+        """
+        return BlockMetadata(None, None, None, None)
+
+    def is_lineage_serializable(self) -> bool:
+        """Returns whether the lineage of this operator can be serialized.
+
+        An operator is lineage serializable if you can serialize it on one machine and
+        deserialize it on another without losing information. Operators that store
+        object references (e.g., ``InputData``) aren't lineage serializable because the
+        objects aren't available on the deserialized machine.
+        """
+        return True

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/logical_plan.py

@@ -0,0 +1,31 @@
+from typing import TYPE_CHECKING, List
+
+from .logical_operator import LogicalOperator
+from .plan import Plan
+
+if TYPE_CHECKING:
+    from ray.data import DataContext
+
+
+class LogicalPlan(Plan):
+    """The plan with a DAG of logical operators."""
+
+    def __init__(self, dag: LogicalOperator, context: "DataContext"):
+        super().__init__(context)
+        self._dag = dag
+
+    @property
+    def dag(self) -> LogicalOperator:
+        """Get the DAG of logical operators."""
+        return self._dag
+
+    def sources(self) -> List[LogicalOperator]:
+        """List of operators that are sources for this plan's DAG."""
+        # If an operator has no input dependencies, it's a source.
+        if not any(self._dag.input_dependencies):
+            return [self._dag]
+
+        sources = []
+        for op in self._dag.input_dependencies:
+            sources.extend(LogicalPlan(op, self._context).sources())
+        return sources

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/operator.py

@@ -0,0 +1,95 @@
+from typing import Callable, Iterator, List
+
+
+class Operator:
+    """Abstract class for operators.
+
+    Operators live on the driver side of the Dataset only.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        input_dependencies: List["Operator"],
+    ):
+        self._name = name
+        self._input_dependencies = input_dependencies
+        self._output_dependencies = []
+
+        self._wire_output_deps(input_dependencies)
+
+    @property
+    def name(self) -> str:
+        return self._name
+
+    @property
+    def dag_str(self) -> str:
+        """String representation of the whole DAG."""
+        if self.input_dependencies:
+            out_str = ", ".join([x.dag_str for x in self.input_dependencies])
+            out_str += " -> "
+        else:
+            out_str = ""
+        out_str += f"{self.__class__.__name__}[{self._name}]"
+        return out_str
+
+    @property
+    def input_dependencies(self) -> List["Operator"]:
+        """List of operators that provide inputs for this operator."""
+        assert hasattr(
+            self, "_input_dependencies"
+        ), "Operator.__init__() was not called."
+        return self._input_dependencies
+
+    @property
+    def output_dependencies(self) -> List["Operator"]:
+        """List of operators that consume outputs from this operator."""
+        assert hasattr(
+            self, "_output_dependencies"
+        ), "Operator.__init__() was not called."
+        return self._output_dependencies
+
+    def post_order_iter(self) -> Iterator["Operator"]:
+        """Depth-first traversal of this operator and its input dependencies."""
+        for op in self.input_dependencies:
+            yield from op.post_order_iter()
+        yield self
+
+    def _apply_transform(
+        self, transform: Callable[["Operator"], "Operator"]
+    ) -> "Operator":
+        """Recursively applies transformation (in post-order) to the operators DAG
+
+        NOTE: This operation should be opting in to avoid in-place modifications,
+              instead creating new operations whenever any operator needs to be
+              updated.
+        """
+
+        transformed_input_ops = []
+        new_ops = []
+
+        for input_op in self.input_dependencies:
+            transformed_input_op = input_op._apply_transform(transform)
+            transformed_input_ops.append(transformed_input_op)
+            # Keep track of new input ops
+            if transformed_input_op is not input_op:
+                new_ops.append(transformed_input_op)
+
+        if new_ops:
+            # NOTE: Only newly created ops need to have output deps
+            #       wired in
+            self._wire_output_deps(new_ops)
+            self._input_dependencies = transformed_input_ops
+
+        return transform(self)
+
+    def _wire_output_deps(self, input_dependencies: List["Operator"]):
+        for x in input_dependencies:
+            assert isinstance(x, Operator), x
+            x._output_dependencies.append(self)
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}[{self._name}]"
+
+    def __str__(self) -> str:
+        return repr(self)

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/optimizer.py

@@ -0,0 +1,47 @@
+from typing import List, Type
+
+from .plan import Plan
+
+
+class Rule:
+    """Abstract class for optimization rule."""
+
+    def apply(self, plan: Plan) -> Plan:
+        """Apply the optimization rule to the execution plan."""
+        raise NotImplementedError
+
+    @classmethod
+    def dependencies(cls) -> List[Type["Rule"]]:
+        """List of rules that must be applied before this rule."""
+        return []
+
+    @classmethod
+    def dependents(cls) -> List[Type["Rule"]]:
+        """List of rules that must be applied after this rule."""
+        return []
+
+
+class Optimizer:
+    """Abstract class for optimizers.
+
+    An optimizers transforms a DAG of operators with a list of predefined rules.
+    """
+
+    @property
+    def rules(self) -> List[Rule]:
+        """List of predefined rules for this optimizer."""
+        raise NotImplementedError
+
+    def optimize(self, plan: Plan) -> Plan:
+        """Optimize operators with a list of rules."""
+        # Apply rules until the plan is not changed
+        previous_plan = plan
+        while True:
+            for rule in self.rules:
+                plan = rule.apply(plan)
+            # TODO: Eventually we should implement proper equality.
+            # Using str to check equality seems brittle
+            if plan.dag.dag_str == previous_plan.dag.dag_str:
+                break
+            previous_plan = plan
+        return plan

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/physical_plan.py

@@ -0,0 +1,34 @@
+from typing import TYPE_CHECKING, Dict
+
+from .logical_operator import LogicalOperator
+from .plan import Plan
+
+if TYPE_CHECKING:
+    from ray.data import DataContext
+    from ray.data._internal.execution.interfaces import PhysicalOperator
+
+
+class PhysicalPlan(Plan):
+    """The plan with a DAG of physical operators."""
+
+    def __init__(
+        self,
+        dag: "PhysicalOperator",
+        op_map: Dict["PhysicalOperator", LogicalOperator],
+        context: "DataContext",
+    ):
+        super().__init__(context)
+        self._dag = dag
+        self._op_map = op_map
+
+    @property
+    def dag(self) -> "PhysicalOperator":
+        """Get the DAG of physical operators."""
+        return self._dag
+
+    @property
+    def op_map(self) -> Dict["PhysicalOperator", LogicalOperator]:
+        """
+        Get a mapping from physical operators to their corresponding logical operator.
+        """
+        return self._op_map

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/plan.py

@@ -0,0 +1,25 @@
+from typing import TYPE_CHECKING
+
+from .operator import Operator
+
+if TYPE_CHECKING:
+    from ray.data import DataContext
+
+
+class Plan:
+    """Abstract class for logical/physical execution plans.
+
+    This plan should hold an operator representing the plan DAG and any auxiliary data
+    that's useful for plan optimization or execution.
+    """
+
+    def __init__(self, context: "DataContext"):
+        self._context = context
+
+    @property
+    def dag(self) -> Operator:
+        raise NotImplementedError
+
+    @property
+    def context(self) -> "DataContext":
+        return self._context

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/interfaces/source_operator.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, List, Optional
+
+if TYPE_CHECKING:
+
+    from ray.data.dataset import RefBundle
+
+
+class SourceOperator(ABC):
+    """Mixin for Logical operators that can be logical source nodes.
+    Subclasses: Read, InputData, FromAbstract.
+    """
+
+    @abstractmethod
+    def output_data(self) -> Optional[List["RefBundle"]]:
+        """The output data of this operator if already known, or ``None``."""
+        pass

tool_server/.venv/lib/python3.12/site-packages/ray/data/_internal/logical/operators/all_to_all_operator.py

@@ -0,0 +1,205 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from ray.data._internal.logical.interfaces import LogicalOperator
+from ray.data._internal.planner.exchange.interfaces import ExchangeTaskSpec
+from ray.data._internal.planner.exchange.shuffle_task_spec import ShuffleTaskSpec
+from ray.data._internal.planner.exchange.sort_task_spec import SortKey, SortTaskSpec
+from ray.data.aggregate import AggregateFn
+from ray.data.block import BlockMetadata
+
+if TYPE_CHECKING:
+
+    from ray.data.block import Schema
+
+
+class AbstractAllToAll(LogicalOperator):
+    """Abstract class for logical operators should be converted to physical
+    AllToAllOperator.
+    """
+
+    def __init__(
+        self,
+        name: str,
+        input_op: LogicalOperator,
+        num_outputs: Optional[int] = None,
+        sub_progress_bar_names: Optional[List[str]] = None,
+        ray_remote_args: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Args:
+            name: Name for this operator. This is the name that will appear when
+                inspecting the logical plan of a Dataset.
+            input_op: The operator preceding this operator in the plan DAG. The outputs
+                of `input_op` will be the inputs to this operator.
+            num_outputs: The number of expected output bundles outputted by this
+                operator.
+            ray_remote_args: Args to provide to :func:`ray.remote`.
+        """
+        super().__init__(name, [input_op], num_outputs)
+        self._num_outputs = num_outputs
+        self._ray_remote_args = ray_remote_args or {}
+        self._sub_progress_bar_names = sub_progress_bar_names
+
+
+class RandomizeBlocks(AbstractAllToAll):
+    """Logical operator for randomize_block_order."""
+
+    def __init__(
+        self,
+        input_op: LogicalOperator,
+        seed: Optional[int] = None,
+    ):
+        super().__init__(
+            "RandomizeBlockOrder",
+            input_op,
+        )
+        self._seed = seed
+
+    def infer_metadata(self) -> "BlockMetadata":
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_metadata()
+
+    def infer_schema(
+        self,
+    ) -> Optional["Schema"]:
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_schema()
+
+
+class RandomShuffle(AbstractAllToAll):
+    """Logical operator for random_shuffle."""
+
+    def __init__(
+        self,
+        input_op: LogicalOperator,
+        name: str = "RandomShuffle",
+        seed: Optional[int] = None,
+        ray_remote_args: Optional[Dict[str, Any]] = None,
+    ):
+        super().__init__(
+            name,
+            input_op,
+            sub_progress_bar_names=[
+                ExchangeTaskSpec.MAP_SUB_PROGRESS_BAR_NAME,
+                ExchangeTaskSpec.REDUCE_SUB_PROGRESS_BAR_NAME,
+            ],
+            ray_remote_args=ray_remote_args,
+        )
+        self._seed = seed
+
+    def infer_metadata(self) -> "BlockMetadata":
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_metadata()
+
+    def infer_schema(
+        self,
+    ) -> Optional["Schema"]:
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_schema()
+
+
+class Repartition(AbstractAllToAll):
+    """Logical operator for repartition."""
+
+    def __init__(
+        self,
+        input_op: LogicalOperator,
+        num_outputs: int,
+        shuffle: bool,
+        keys: Optional[List[str]] = None,
+        sort: bool = False,
+    ):
+        if shuffle:
+            sub_progress_bar_names = [
+                ExchangeTaskSpec.MAP_SUB_PROGRESS_BAR_NAME,
+                ExchangeTaskSpec.REDUCE_SUB_PROGRESS_BAR_NAME,
+            ]
+        else:
+            sub_progress_bar_names = [
+                ShuffleTaskSpec.SPLIT_REPARTITION_SUB_PROGRESS_BAR_NAME,
+            ]
+        super().__init__(
+            "Repartition",
+            input_op,
+            num_outputs=num_outputs,
+            sub_progress_bar_names=sub_progress_bar_names,
+        )
+        self._shuffle = shuffle
+        self._keys = keys
+        self._sort = sort
+
+    def infer_metadata(self) -> "BlockMetadata":
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_metadata()
+
+    def infer_schema(
+        self,
+    ) -> Optional["Schema"]:
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_schema()
+
+
+class Sort(AbstractAllToAll):
+    """Logical operator for sort."""
+
+    def __init__(
+        self,
+        input_op: LogicalOperator,
+        sort_key: SortKey,
+        batch_format: Optional[str] = "default",
+    ):
+        super().__init__(
+            "Sort",
+            input_op,
+            sub_progress_bar_names=[
+                SortTaskSpec.SORT_SAMPLE_SUB_PROGRESS_BAR_NAME,
+                ExchangeTaskSpec.MAP_SUB_PROGRESS_BAR_NAME,
+                ExchangeTaskSpec.REDUCE_SUB_PROGRESS_BAR_NAME,
+            ],
+        )
+        self._sort_key = sort_key
+        self._batch_format = batch_format
+
+    def infer_metadata(self) -> "BlockMetadata":
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_metadata()
+
+    def infer_schema(
+        self,
+    ) -> Optional["Schema"]:
+        assert len(self._input_dependencies) == 1, len(self._input_dependencies)
+        assert isinstance(self._input_dependencies[0], LogicalOperator)
+        return self._input_dependencies[0].infer_schema()
+
+
+class Aggregate(AbstractAllToAll):
+    """Logical operator for aggregate."""
+
+    def __init__(
+        self,
+        input_op: LogicalOperator,
+        key: Optional[str],
+        aggs: List[AggregateFn],
+        num_partitions: Optional[int] = None,
+        batch_format: Optional[str] = "default",
+    ):
+        super().__init__(
+            "Aggregate",
+            input_op,
+            sub_progress_bar_names=[
+                SortTaskSpec.SORT_SAMPLE_SUB_PROGRESS_BAR_NAME,
+                ExchangeTaskSpec.MAP_SUB_PROGRESS_BAR_NAME,
+                ExchangeTaskSpec.REDUCE_SUB_PROGRESS_BAR_NAME,
+            ],
+        )
+        self._key = key
+        self._aggs = aggs
+        self._num_partitions = num_partitions
+        self._batch_format = batch_format