def scan_data_status(
        self,
        partition_id: str,
        data_fields: list[str],
        task_name: str,
    ) -> list[int]:
        """
        Find samples that are ready for consumption in a specific partition.
        Delegates scanning functionality to the partition's own method.

        Args:
            partition_id: ID of the partition
            data_fields: List of required field names
            task_name: Name of the consumer task
            batch_size: Number of samples needed

        Returns:
            List of sample indices that are ready for consumption
        """

        partition = self._get_partition(partition_id)
        if not partition:
            return []

        # Use partition's own scanning method
        ready_sample_indices = partition.scan_data_status(data_fields, task_name)

        return ready_sample_indices

        if mode == "fetch":
            # Find ready samples within current data partition and package into BatchMeta when reading

            start_time = time.time()
            while True:
                # ready_for_consume_indexes: samples where all required fields are produced
                # (production status is ready) and not yet consumed
                ready_for_consume_indexes = self.scan_data_status(partition_id, data_fields, task_name)

                if len(ready_for_consume_indexes) < batch_size:
                    if time.time() - start_time > TQ_CONTROLLER_GET_METADATA_TIMEOUT:
                        # TODO: non_blocking related logics here @ningbenzhe
                        # if self.non_blocking:
                        #     logger.info()
                        #     return BatchMeta.empty()
                        raise TimeoutError(
                            f"Timeout while waiting for sufficient data for task {task_name}. "
                            f"Required: {batch_size}, Available: {len(ready_for_consume_indexes)}"
                        )
                    logger.warning(
                        f"Insufficient data for task {task_name}. Required: {batch_size} samples with "
                        f"fields {data_fields} in partition {partition_id}, but only have "
                        f"{len(ready_for_consume_indexes)} samples meeting the criteria. "
                        f"Retrying in {TQ_CONTROLLER_GET_METADATA_CHECK_INTERVAL}s..."
                    )
                    time.sleep(TQ_CONTROLLER_GET_METADATA_CHECK_INTERVAL)
                else:
                    break

            if len(ready_for_consume_indexes) < batch_size:
                raise RuntimeError(
                    "Unexpected error: ready_for_consume_indexes has insufficient samples before sampling. "
                )

            batch_global_indexes, consumed_indexes = self.sampler(
                ready_for_consume_indexes,
                batch_size,
                **(sampling_config or {}),
            )

            # Check if we got valid results from the sampler
            if len(batch_global_indexes) != batch_size:
                raise RuntimeError(
                    f"Sampler returned insufficient samples. Please check the sampler logic. "
                    f"Expected: {batch_size}, before sampling: {len(ready_for_consume_indexes)}, "
                    f"after sampling: {len(batch_global_indexes)}"
                )