






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      a_ (      _A      ,   _A  )			->			List[Any]:







				"""simple docstring"""
				snake_case__									=     []
				for part_id in partition_order:
								snake_case__									=     df.where(f'''SPARK_PARTITION_ID() = {part_id}'''  ).collect()
								for row_idx, row in enumerate(_A  ):
												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      a_ (      )			->			Optional[Any]:







				"""simple docstring"""
				snake_case__									=     pyspark.sql.SparkSession.builder.master('local[*]'  ).appName('pyspark'  ).getOrCreate()
				snake_case__									=     spark.range(100  ).repartition(1  )
				snake_case__									=     Spark(_A  )
				# 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      a_ (      )			->			str:







				"""simple docstring"""
				snake_case__									=     pyspark.sql.SparkSession.builder.master('local[*]'  ).appName('pyspark'  ).getOrCreate()
				snake_case__									=     spark.range(10  ).repartition(2  )
				snake_case__									=     [1, 0]
				snake_case__									=     _generate_iterable_examples(_A      ,   _A  )  # Reverse the partitions.
				snake_case__									=     _get_expected_row_ids_and_row_dicts_for_partition_order(_A      ,   _A  )

				for i, (row_id, row_dict) in enumerate(generate_fn()  ):
								snake_case__							,						snake_case__									=     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      a_ (      )			->			Dict:







				"""simple docstring"""
				snake_case__									=     pyspark.sql.SparkSession.builder.master('local[*]'  ).appName('pyspark'  ).getOrCreate()
				snake_case__									=     spark.range(10  ).repartition(1  )
				snake_case__									=     SparkExamplesIterable(_A  )
				assert it.n_shards == 1
				for i, (row_id, row_dict) in enumerate(_A  ):
								assert row_id == f'''0_{i}'''
								assert row_dict == {"id": i}
@require_not_windows
@require_dill_gt_0_3_2
def      a_ (      )			->			Optional[int]:







				"""simple docstring"""
				snake_case__									=     pyspark.sql.SparkSession.builder.master('local[*]'  ).appName('pyspark'  ).getOrCreate()
				snake_case__									=     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__									=     lambda _A  : x.reverse()
								snake_case__									=     _get_expected_row_ids_and_row_dicts_for_partition_order(_A      ,   [2, 1, 0]  )

								snake_case__									=     SparkExamplesIterable(_A  ).shuffle_data_sources(_A  )
								assert shuffled_it.n_shards == 3
								for i, (row_id, row_dict) in enumerate(_A  ):
												snake_case__							,						snake_case__									=     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      a_ (      )			->			Optional[int]:







				"""simple docstring"""
				snake_case__									=     pyspark.sql.SparkSession.builder.master('local[*]'  ).appName('pyspark'  ).getOrCreate()
				snake_case__									=     spark.range(20  ).repartition(4  )

				# Partitions 0 and 2
				snake_case__									=     SparkExamplesIterable(_A  ).shard_data_sources(worker_id=0      ,   num_workers=2  )
				assert shard_it_a.n_shards == 2
				snake_case__									=     _get_expected_row_ids_and_row_dicts_for_partition_order(_A      ,   [0, 2]  )
				for i, (row_id, row_dict) in enumerate(_A  ):
								snake_case__							,						snake_case__									=     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__									=     SparkExamplesIterable(_A  ).shard_data_sources(worker_id=1      ,   num_workers=2  )
				assert shard_it_a.n_shards == 2
				snake_case__									=     _get_expected_row_ids_and_row_dicts_for_partition_order(_A      ,   [1, 3]  )
				for i, (row_id, row_dict) in enumerate(_A  ):
								snake_case__							,						snake_case__									=     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      a_ (      )			->			Optional[int]:







				"""simple docstring"""
				snake_case__									=     pyspark.sql.SparkSession.builder.master('local[*]'  ).appName('pyspark'  ).getOrCreate()
				snake_case__									=     spark.range(100  ).repartition(1  )
				snake_case__									=     Spark(_A  )
				# 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












from __future__ import annotations
def      a_ (      _A      ,   _A  )			->			str:







				"""simple docstring"""
				# Checks if the entire collection has been sorted
				if len(_A  ) <= 1 or n <= 1:
								return

				insert_next(_A      ,   n - 1  )
				rec_insertion_sort(_A      ,   n - 1  )
def      a_ (      _A      ,   _A  )			->			Tuple:







				"""simple docstring"""
				# Checks order between adjacent elements
				if index >= len(_A  ) or collection[index - 1] <= collection[index]:
								return

				# Swaps adjacent elements since they are not in ascending order
				snake_case__							,						snake_case__									=     (
				    collection[index],
				    collection[index - 1],
				)

				insert_next(_A      ,   index + 1  )


if __name__ == "__main__":
							__UpperCamelCase					:		Optional[int]	  =						input("""Enter integers separated by spaces: """)
							__UpperCamelCase					:		list[int]	  =						[int(num) for num in numbers.split()]
							rec_insertion_sort(number_list, len(number_list))
							print(number_list)




