






import pytest

from datasets.splits import SplitDict, SplitInfo
from datasets.utils.py_utils import asdict







@pytest.mark.parametrize(
    "split_dict"  ,						[
        SplitDict(),
        SplitDict({"train": SplitInfo(name="train"  ,						num_bytes=1337  ,						num_examples=42  ,						dataset_name="my_dataset"     )}     ),
        SplitDict({"train": SplitInfo(name="train"  ,						num_bytes=1337  ,						num_examples=42     )}     ),
        SplitDict({"train": SplitInfo()}     ),
    ]  ,						)
def   SCREAMING_SNAKE_CASE       (				snake_case_      :							SplitDict     ):
	snake_case__				:   List[Any]     =						split_dict._to_yaml_list()
	assert len(snake_case_     ) == len(snake_case_     )
	snake_case__				:   str     =						SplitDict._from_yaml_list(snake_case_     )
	for split_name, split_info in split_dict.items():
		# dataset_name field is deprecated, and is therefore not part of the YAML dump
		snake_case__				:   Tuple     =						None
		# the split name of split_dict takes over the name of the split info object
		snake_case__				:   Optional[Any]     =						split_name
	assert split_dict == reloaded







@pytest.mark.parametrize(
    "split_info"  ,						[SplitInfo(), SplitInfo(dataset_name=snake_case_     ), SplitInfo(dataset_name="my_dataset"     )]     )
def   SCREAMING_SNAKE_CASE       (				snake_case_      :							Any     ):
	# For backward compatibility, we need asdict(split_dict) to return split info dictrionaries with the "dataset_name"
	# field even if it's deprecated. This way old versionso of `datasets` can still reload dataset_infos.json files
	snake_case__				:   Optional[int]     =						asdict(SplitDict({"train": split_info}     )     )
	assert "dataset_name" in split_dict_asdict["train"]
	assert split_dict_asdict["train"]["dataset_name"] == split_info.dataset_name











from unittest.mock import patch

import pyspark

from datasets.packaged_modules.spark.spark import (
    Spark,
    SparkExamplesIterable,
    _generate_iterable_examples,
)

from ..utils import (
    require_dill_gt_0_3_2,
    require_not_windows,
)







def   SCREAMING_SNAKE_CASE       (				snake_case_      :							List[Any]  ,						snake_case_      :							Union[str, Any]     ):
	snake_case__				:   Optional[int]     =						[]
	for part_id in partition_order:
		snake_case__				:   List[Any]     =						df.where(F'''SPARK_PARTITION_ID() = {part_id}'''     ).collect()
		for row_idx, row in enumerate(snake_case_     ):
			expected_row_ids_and_row_dicts.append((F'''{part_id}_{row_idx}''', row.asDict())     )
	return expected_row_ids_and_row_dicts







@require_not_windows
@require_dill_gt_0_3_2
def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Tuple     =						pyspark.sql.SparkSession.builder.master("local[*]"     ).appName("pyspark"     ).getOrCreate()
	snake_case__				:   Union[str, Any]     =						spark.range(100     ).repartition(1     )
	snake_case__				:   Any     =						Spark(snake_case_     )
	# The id ints will be converted to Pyarrow int64s, so each row will be 8 bytes. Setting a max_shard_size of 16 means
	# that each partition can hold 2 rows.
	spark_builder._repartition_df_if_needed(max_shard_size=16     )
	# Given that the dataframe has 100 rows and each partition has 2 rows, we expect 50 partitions.
	assert spark_builder.df.rdd.getNumPartitions() == 50







@require_not_windows
@require_dill_gt_0_3_2
def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Dict     =						pyspark.sql.SparkSession.builder.master("local[*]"     ).appName("pyspark"     ).getOrCreate()
	snake_case__				:   Optional[Any]     =						spark.range(10     ).repartition(2     )
	snake_case__				:   Optional[Any]     =						[1, 0]
	snake_case__				:   Dict     =						_generate_iterable_examples(snake_case_  ,						snake_case_     )  # Reverse the partitions.
	snake_case__				:   Tuple     =						_get_expected_row_ids_and_row_dicts_for_partition_order(snake_case_  ,						snake_case_     )

	for i, (row_id, row_dict) in enumerate(generate_fn()     ):
		snake_case__,		snake_case__				:   Tuple     =						expected_row_ids_and_row_dicts[i]
		assert row_id == expected_row_id
		assert row_dict == expected_row_dict







@require_not_windows
@require_dill_gt_0_3_2
def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Optional[int]     =						pyspark.sql.SparkSession.builder.master("local[*]"     ).appName("pyspark"     ).getOrCreate()
	snake_case__				:   Optional[int]     =						spark.range(10     ).repartition(1     )
	snake_case__				:   Union[str, Any]     =						SparkExamplesIterable(snake_case_     )
	assert it.n_shards == 1
	for i, (row_id, row_dict) in enumerate(snake_case_     ):
		assert row_id == F'''0_{i}'''
		assert row_dict == {"id": i}







@require_not_windows
@require_dill_gt_0_3_2
def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Optional[int]     =						pyspark.sql.SparkSession.builder.master("local[*]"     ).appName("pyspark"     ).getOrCreate()
	snake_case__				:   str     =						spark.range(30     ).repartition(3     )
	# Mock the generator so that shuffle reverses the partition indices.
	with patch("numpy.random.Generator"     ) as generator_mock:
		snake_case__				:   Union[str, Any]     =						lambda snake_case_     : x.reverse()
		snake_case__				:   Optional[int]     =						_get_expected_row_ids_and_row_dicts_for_partition_order(snake_case_  ,						[2, 1, 0]     )

		snake_case__				:   List[Any]     =						SparkExamplesIterable(snake_case_     ).shuffle_data_sources(snake_case_     )
		assert shuffled_it.n_shards == 3
		for i, (row_id, row_dict) in enumerate(snake_case_     ):
			snake_case__,		snake_case__				:   Optional[Any]     =						expected_row_ids_and_row_dicts[i]
			assert row_id == expected_row_id
			assert row_dict == expected_row_dict







@require_not_windows
@require_dill_gt_0_3_2
def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Any     =						pyspark.sql.SparkSession.builder.master("local[*]"     ).appName("pyspark"     ).getOrCreate()
	snake_case__				:   Tuple     =						spark.range(20     ).repartition(4     )

	# Partitions 0 and 2
	snake_case__				:   List[Any]     =						SparkExamplesIterable(snake_case_     ).shard_data_sources(worker_id=0  ,						num_workers=2     )
	assert shard_it_a.n_shards == 2
	snake_case__				:   List[str]     =						_get_expected_row_ids_and_row_dicts_for_partition_order(snake_case_  ,						[0, 2]     )
	for i, (row_id, row_dict) in enumerate(snake_case_     ):
		snake_case__,		snake_case__				:   Optional[int]     =						expected_row_ids_and_row_dicts_a[i]
		assert row_id == expected_row_id
		assert row_dict == expected_row_dict

	# Partitions 1 and 3
	snake_case__				:   Any     =						SparkExamplesIterable(snake_case_     ).shard_data_sources(worker_id=1  ,						num_workers=2     )
	assert shard_it_a.n_shards == 2
	snake_case__				:   List[Any]     =						_get_expected_row_ids_and_row_dicts_for_partition_order(snake_case_  ,						[1, 3]     )
	for i, (row_id, row_dict) in enumerate(snake_case_     ):
		snake_case__,		snake_case__				:   Optional[Any]     =						expected_row_ids_and_row_dicts_a[i]
		assert row_id == expected_row_id
		assert row_dict == expected_row_dict







@require_not_windows
@require_dill_gt_0_3_2
def   SCREAMING_SNAKE_CASE       (				):
	snake_case__				:   Dict     =						pyspark.sql.SparkSession.builder.master("local[*]"     ).appName("pyspark"     ).getOrCreate()
	snake_case__				:   Tuple     =						spark.range(100     ).repartition(1     )
	snake_case__				:   Union[str, Any]     =						Spark(snake_case_     )
	# Choose a small max_shard_size for maximum partitioning.
	spark_builder._repartition_df_if_needed(max_shard_size=1     )
	# The new number of partitions should not be greater than the number of rows.
	assert spark_builder.df.rdd.getNumPartitions() == 100



