




import copy
import os
import tempfile
from unittest import TestCase
from unittest.mock import patch

import numpy as np
import pyarrow as pa
import pyarrow.parquet as pq
import pytest

from datasets.arrow_writer import ArrowWriter, OptimizedTypedSequence, ParquetWriter, TypedSequence
from datasets.features import ArrayaD, ClassLabel, Features, Image, Value
from datasets.features.features import ArrayaDExtensionType, cast_to_python_objects
from datasets.keyhash import DuplicatedKeysError, InvalidKeyError

from .utils import require_pil
class     a__					(      snake_case__   ):






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence([1, 2, 3]    )    )
											self.assertEqual(arr.type	,    pa.intaa()    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											with self.assertRaises(_A    ):
																__lowerCAmelCase            = pa.array(TypedSequence([1, 2, 3]    )	,    type=pa.intaa()    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											with self.assertRaises(_A    ):
																__lowerCAmelCase            = pa.array(TypedSequence([1, 2, 3]	,    try_type=Value("bool"    )	,    type=Value("int64"    )    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence([1, 2, 3]	,    type=Value("int32"    )    )    )
											self.assertEqual(arr.type	,    pa.intaa()    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											with self.assertRaises((TypeError, pa.lib.ArrowInvalid)    ):
																__lowerCAmelCase            = pa.array(TypedSequence(["foo", "bar"]	,    type=Value("int64"    )    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence([1, 2, 3]	,    try_type=Value("int32"    )    )    )
											self.assertEqual(arr.type	,    pa.intaa()    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence(["foo", "bar"]	,    try_type=Value("int64"    )    )    )
											self.assertEqual(arr.type	,    pa.string()    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence([[[1, 2, 3]]]	,    type=ArrayaD((1, 3)	,    "int64"    )    )    )
											self.assertEqual(arr.type	,    ArrayaDExtensionType((1, 3)	,    "int64"    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											with self.assertRaises((TypeError, pa.lib.ArrowInvalid)    ):
																__lowerCAmelCase            = pa.array(TypedSequence(["foo", "bar"]	,    type=ArrayaD((1, 3)	,    "int64"    )    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence([[[1, 2, 3]]]	,    try_type=ArrayaD((1, 3)	,    "int64"    )    )    )
											self.assertEqual(arr.type	,    ArrayaDExtensionType((1, 3)	,    "int64"    )    )






						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											__lowerCAmelCase            = pa.array(TypedSequence(["foo", "bar"]	,    try_type=ArrayaD((1, 3)	,    "int64"    )    )    )
											self.assertEqual(arr.type	,    pa.string()    )






						@require_pil
						def        __SCREAMING_SNAKE_CASE(     self    ):




											"""simple docstring"""



											import PIL.Image

											__lowerCAmelCase            = PIL.Image.fromarray(np.arange(1_0	,    dtype=np.uinta    ).reshape(2	,    5    )    )
											with patch(
											    "datasets.arrow_writer.cast_to_python_objects"	,    side_effect=_A    ) as mock_cast_to_python_objects:
																__lowerCAmelCase            = pa.array(TypedSequence([{"path": None, "bytes": b"image_bytes"}, pil_image]	,    type=Image()    )    )
																__lowerCAmelCase     ,							__lowerCAmelCase            = mock_cast_to_python_objects.call_args_list[-1]
																self.assertIn("optimize_list_casting"	,    _A    )
																self.assertFalse(kwargs["optimize_list_casting"]    )







def 			_a   (		SCREAMING_SNAKE_CASE_							:       Optional[int]   ,   SCREAMING_SNAKE_CASE_							:       int  ):
					__lowerCAmelCase            = pa.BufferReader(SCREAMING_SNAKE_CASE_  ) if isinstance(SCREAMING_SNAKE_CASE_   ,   pa.Buffer  ) else pa.memory_map(SCREAMING_SNAKE_CASE_  )
					__lowerCAmelCase            = pa.ipc.open_stream(SCREAMING_SNAKE_CASE_  )
					__lowerCAmelCase            = f.read_all()
					assert len(pa_table.to_batches()  ) == expected_num_chunks
					assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}
					del pa_table







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 1, 10]  )
@pytest.mark.parametrize(
    "fields"   ,   [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Optional[int]   ,   SCREAMING_SNAKE_CASE_							:       Dict  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					__lowerCAmelCase            = pa.schema(SCREAMING_SNAKE_CASE_  ) if fields else None
					with ArrowWriter(stream=SCREAMING_SNAKE_CASE_   ,   schema=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write({"col_1": "foo", "col_2": 1}  )
										writer.write({"col_1": "bar", "col_2": 2}  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					if not fields:
										__lowerCAmelCase            = {"col_1": pa.string(), "col_2": pa.intaa()}
					assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE_   ,   metadata=writer._schema.metadata  )
					_check_output(output.getvalue()   ,   expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )







def 			_a   (		):
					__lowerCAmelCase            = pa.BufferOutputStream()
					__lowerCAmelCase            = Features({"labels": ClassLabel(names=["neg", "pos"]  )}  )
					with ArrowWriter(stream=SCREAMING_SNAKE_CASE_   ,   features=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write({"labels": 0}  )
										writer.write({"labels": 1}  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					assert writer._schema == features.arrow_schema
					assert writer._schema.metadata == features.arrow_schema.metadata
					__lowerCAmelCase            = pa.BufferReader(output.getvalue()  )
					__lowerCAmelCase            = pa.ipc.open_stream(SCREAMING_SNAKE_CASE_  )
					__lowerCAmelCase            = f.read_all()
					__lowerCAmelCase            = pa_table.schema
					assert pa_table.num_rows == 2
					assert schema == features.arrow_schema
					assert schema.metadata == features.arrow_schema.metadata
					assert features == Features.from_arrow_schema(SCREAMING_SNAKE_CASE_  )







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 1, 10]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       List[Any]  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					with ArrowWriter(
					    stream=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_   ,   hash_salt="split_name"   ,   check_duplicates=SCREAMING_SNAKE_CASE_   ,   ) as writer:
										with pytest.raises(SCREAMING_SNAKE_CASE_  ):
															writer.write({"col_1": "foo", "col_2": 1}   ,   key=[1, 2]  )
															__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 2, 10]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Any  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					with ArrowWriter(
					    stream=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_   ,   hash_salt="split_name"   ,   check_duplicates=SCREAMING_SNAKE_CASE_   ,   ) as writer:
										with pytest.raises(SCREAMING_SNAKE_CASE_  ):
															writer.write({"col_1": "foo", "col_2": 1}   ,   key=10  )
															writer.write({"col_1": "bar", "col_2": 2}   ,   key=10  )
															__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 2, 10]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       str  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					with ArrowWriter(
					    stream=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_   ,   hash_salt="split_name"   ,   check_duplicates=SCREAMING_SNAKE_CASE_   ,   ) as writer:
										writer.write({"col_1": "foo", "col_2": 1}   ,   key=1  )
										writer.write({"col_1": "bar", "col_2": 2}   ,   key=2  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					_check_output(output.getvalue()   ,   expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 1, 10]  )
@pytest.mark.parametrize(
    "fields"   ,   [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Tuple   ,   SCREAMING_SNAKE_CASE_							:       Tuple  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					__lowerCAmelCase            = pa.schema(SCREAMING_SNAKE_CASE_  ) if fields else None
					with ArrowWriter(stream=SCREAMING_SNAKE_CASE_   ,   schema=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write_batch({"col_1": ["foo", "bar"], "col_2": [1, 2]}  )
										writer.write_batch({"col_1": [], "col_2": []}  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					if not fields:
										__lowerCAmelCase            = {"col_1": pa.string(), "col_2": pa.intaa()}
					assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE_   ,   metadata=writer._schema.metadata  )
					_check_output(output.getvalue()   ,   expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 1, 10]  )
@pytest.mark.parametrize(
    "fields"   ,   [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Union[str, Any]   ,   SCREAMING_SNAKE_CASE_							:       Dict  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					__lowerCAmelCase            = pa.schema(SCREAMING_SNAKE_CASE_  ) if fields else None
					with ArrowWriter(stream=SCREAMING_SNAKE_CASE_   ,   schema=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write_table(pa.Table.from_pydict({"col_1": ["foo", "bar"], "col_2": [1, 2]}  )  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					if not fields:
										__lowerCAmelCase            = {"col_1": pa.string(), "col_2": pa.intaa()}
					assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE_   ,   metadata=writer._schema.metadata  )
					_check_output(output.getvalue()   ,   expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )







@pytest.mark.parametrize("writer_batch_size"   ,   [None, 1, 10]  )
@pytest.mark.parametrize(
    "fields"   ,   [None, {"col_1": pa.string(), "col_2": pa.intaa()}, {"col_1": pa.string(), "col_2": pa.intaa()}]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       str   ,   SCREAMING_SNAKE_CASE_							:       Optional[Any]  ):
					__lowerCAmelCase            = pa.BufferOutputStream()
					__lowerCAmelCase            = pa.schema(SCREAMING_SNAKE_CASE_  ) if fields else None
					with ArrowWriter(stream=SCREAMING_SNAKE_CASE_   ,   schema=SCREAMING_SNAKE_CASE_   ,   writer_batch_size=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write_row(pa.Table.from_pydict({"col_1": ["foo"], "col_2": [1]}  )  )
										writer.write_row(pa.Table.from_pydict({"col_1": ["bar"], "col_2": [2]}  )  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					if not fields:
										__lowerCAmelCase            = {"col_1": pa.string(), "col_2": pa.intaa()}
					assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE_   ,   metadata=writer._schema.metadata  )
					_check_output(output.getvalue()   ,   expected_num_chunks=num_examples if writer_batch_size == 1 else 1  )







def 			_a   (		):
					with tempfile.TemporaryDirectory() as tmp_dir:
										__lowerCAmelCase            = {"col_1": pa.string(), "col_2": pa.intaa()}
										__lowerCAmelCase            = os.path.join(SCREAMING_SNAKE_CASE_   ,   "test.arrow"  )
										with ArrowWriter(path=SCREAMING_SNAKE_CASE_   ,   schema=pa.schema(SCREAMING_SNAKE_CASE_  )  ) as writer:
															writer.write_batch({"col_1": ["foo", "bar"], "col_2": [1, 2]}  )
															__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
										assert num_examples == 2
										assert num_bytes > 0
										assert writer._schema == pa.schema(SCREAMING_SNAKE_CASE_   ,   metadata=writer._schema.metadata  )
										_check_output(SCREAMING_SNAKE_CASE_   ,   1  )







def 			_a   (		SCREAMING_SNAKE_CASE_							:       List[str]  ):
					if pa.types.is_list(SCREAMING_SNAKE_CASE_  ):
										return get_base_dtype(arr_type.value_type  )
					else:
										return arr_type







def 			_a   (		SCREAMING_SNAKE_CASE_							:       Optional[int]   ,   SCREAMING_SNAKE_CASE_							:       Any  ):
					if isinstance(lst[0]   ,   SCREAMING_SNAKE_CASE_  ):
										change_first_primitive_element_in_list(lst[0]   ,   SCREAMING_SNAKE_CASE_  )
					else:
										__lowerCAmelCase            = value







@pytest.mark.parametrize("optimized_int_type, expected_dtype"   ,   [(None, pa.intaa()), (Value("int32"  ), pa.intaa())]  )
@pytest.mark.parametrize("sequence"   ,   [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Optional[int]   ,   SCREAMING_SNAKE_CASE_							:       List[Any]   ,   SCREAMING_SNAKE_CASE_							:       Union[str, Any]  ):
					__lowerCAmelCase            = pa.array(TypedSequence(SCREAMING_SNAKE_CASE_   ,   optimized_int_type=SCREAMING_SNAKE_CASE_  )  )
					assert get_base_dtype(arr.type  ) == expected_dtype







@pytest.mark.parametrize(
    "col, expected_dtype"   ,   [
        ("attention_mask", pa.inta()),
        ("special_tokens_mask", pa.inta()),
        ("token_type_ids", pa.inta()),
        ("input_ids", pa.intaa()),
        ("other", pa.intaa()),
    ]   ,   )
@pytest.mark.parametrize("sequence"   ,   [[1, 2, 3], [[1, 2, 3]], [[[1, 2, 3]]]]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Any   ,   SCREAMING_SNAKE_CASE_							:       Union[str, Any]   ,   SCREAMING_SNAKE_CASE_							:       Union[str, Any]  ):
					# in range
					__lowerCAmelCase            = pa.array(OptimizedTypedSequence(SCREAMING_SNAKE_CASE_   ,   col=SCREAMING_SNAKE_CASE_  )  )
					assert get_base_dtype(arr.type  ) == expected_dtype

					# not in range
					if col != "other":
										# avoids errors due to in-place modifications
										__lowerCAmelCase            = copy.deepcopy(SCREAMING_SNAKE_CASE_  )
										__lowerCAmelCase            = np.iinfo(expected_dtype.to_pandas_dtype()  ).max + 1
										change_first_primitive_element_in_list(SCREAMING_SNAKE_CASE_   ,   SCREAMING_SNAKE_CASE_  )
										__lowerCAmelCase            = pa.array(OptimizedTypedSequence(SCREAMING_SNAKE_CASE_   ,   col=SCREAMING_SNAKE_CASE_  )  )
										assert get_base_dtype(arr.type  ) == pa.intaa()







@pytest.mark.parametrize("raise_exception"   ,   [False, True]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Optional[Any]   ,   SCREAMING_SNAKE_CASE_							:       int  ):
					__lowerCAmelCase            = str(tmp_path / "dataset-train.arrow"  )
					try:
										with ArrowWriter(path=SCREAMING_SNAKE_CASE_  ) as writer:
															if raise_exception:
																				raise pa.lib.ArrowInvalid()
															else:
																				writer.stream.close()
					except pa.lib.ArrowInvalid:
										pass
					finally:
										assert writer.stream.closed







def 			_a   (		SCREAMING_SNAKE_CASE_							:       List[Any]  ):
					__lowerCAmelCase            = "mock://dataset-train.arrow"
					with ArrowWriter(path=SCREAMING_SNAKE_CASE_   ,   storage_options=mockfs.storage_options  ) as writer:
										assert isinstance(writer._fs   ,   type(SCREAMING_SNAKE_CASE_  )  )
										assert writer._fs.storage_options == mockfs.storage_options
										writer.write({"col_1": "foo", "col_2": 1}  )
										writer.write({"col_1": "bar", "col_2": 2}  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					assert mockfs.exists(SCREAMING_SNAKE_CASE_  )







def 			_a   (		):
					__lowerCAmelCase            = pa.BufferOutputStream()
					with ParquetWriter(stream=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write({"col_1": "foo", "col_2": 1}  )
										writer.write({"col_1": "bar", "col_2": 2}  )
										__lowerCAmelCase     ,							__lowerCAmelCase            = writer.finalize()
					assert num_examples == 2
					assert num_bytes > 0
					__lowerCAmelCase            = pa.BufferReader(output.getvalue()  )
					__lowerCAmelCase            = pq.read_table(SCREAMING_SNAKE_CASE_  )
					assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}







@require_pil
@pytest.mark.parametrize("embed_local_files"   ,   [False, True]  )
def 			_a   (		SCREAMING_SNAKE_CASE_							:       Optional[Any]   ,   SCREAMING_SNAKE_CASE_							:       Optional[int]  ):
					import PIL.Image

					__lowerCAmelCase            = str(tmp_path / "test_image_rgb.jpg"  )
					PIL.Image.fromarray(np.zeros((5, 5)   ,   dtype=np.uinta  )  ).save(SCREAMING_SNAKE_CASE_   ,   format="png"  )
					__lowerCAmelCase            = pa.BufferOutputStream()
					with ParquetWriter(
					    stream=SCREAMING_SNAKE_CASE_   ,   features=Features({"image": Image()}  )   ,   embed_local_files=SCREAMING_SNAKE_CASE_  ) as writer:
										writer.write({"image": image_path}  )
										writer.finalize()
					__lowerCAmelCase            = pa.BufferReader(output.getvalue()  )
					__lowerCAmelCase            = pq.read_table(SCREAMING_SNAKE_CASE_  )
					__lowerCAmelCase            = pa_table.to_pydict()
					if embed_local_files:
										assert isinstance(out["image"][0]["path"]   ,   SCREAMING_SNAKE_CASE_  )
										with open(SCREAMING_SNAKE_CASE_   ,   "rb"  ) as f:
															assert out["image"][0]["bytes"] == f.read()
					else:
										assert out["image"][0]["path"] == image_path
										assert out["image"][0]["bytes"] is None







def 			_a   (		):
					__lowerCAmelCase            = pa.schema([pa.field("col_1"   ,   pa.string()   ,   nullable=SCREAMING_SNAKE_CASE_  )]  )
					__lowerCAmelCase            = pa.BufferOutputStream()
					with ArrowWriter(stream=SCREAMING_SNAKE_CASE_  ) as writer:
										writer._build_writer(inferred_schema=SCREAMING_SNAKE_CASE_  )
										assert writer._schema == pa.schema([pa.field("col_1"   ,   pa.string()  )]  )










def 			_a   (		SCREAMING_SNAKE_CASE_							:       list[int]  ):
					__lowerCAmelCase            = len(SCREAMING_SNAKE_CASE_  )
					for i in range(SCREAMING_SNAKE_CASE_  ):
										for j in range(i + 1   ,   SCREAMING_SNAKE_CASE_  ):
															if numbers[j] < numbers[i]:
																				__lowerCAmelCase     ,							__lowerCAmelCase            = numbers[j], numbers[i]
					return numbers


if __name__ == "__main__":
					UpperCamelCase__					    =    input("""Enter numbers separated by a comma:\n""").strip()
					UpperCamelCase__					    =    [int(item) for item in user_input.split(""",""")]
					print(exchange_sort(unsorted))




