




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     lowerCamelCase__(					UpperCAmelCase__):
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             __lowerCamelCase   =						pa.array(TypedSequence([1, 2, 3]   )   )
             self.assertEqual(arr.type    ,       pa.intaa()   )
      def 			lowerCAmelCase__						(				self: List[str]   ):
             with self.assertRaises(_a   ):
                    __lowerCamelCase   =						pa.array(TypedSequence([1, 2, 3]   )    ,       type=pa.intaa()   )
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             with self.assertRaises(_a   ):
                    __lowerCamelCase   =						pa.array(TypedSequence([1, 2, 3]    ,       try_type=Value("""bool"""   )    ,       type=Value("""int64"""   )   )   )
      def 			lowerCAmelCase__						(				self: List[Any]   ):
             __lowerCamelCase   =						pa.array(TypedSequence([1, 2, 3]    ,       type=Value("""int32"""   )   )   )
             self.assertEqual(arr.type    ,       pa.intaa()   )
      def 			lowerCAmelCase__						(				self: Union[str, Any]   ):
             with self.assertRaises((TypeError, pa.lib.ArrowInvalid)   ):
                    __lowerCamelCase   =						pa.array(TypedSequence(["""foo""", """bar"""]    ,       type=Value("""int64"""   )   )   )
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             __lowerCamelCase   =						pa.array(TypedSequence([1, 2, 3]    ,       try_type=Value("""int32"""   )   )   )
             self.assertEqual(arr.type    ,       pa.intaa()   )
      def 			lowerCAmelCase__						(				self: List[str]   ):
             __lowerCamelCase   =						pa.array(TypedSequence(["""foo""", """bar"""]    ,       try_type=Value("""int64"""   )   )   )
             self.assertEqual(arr.type    ,       pa.string()   )
      def 			lowerCAmelCase__						(				self: Optional[Any]   ):
             __lowerCamelCase   =						pa.array(TypedSequence([[[1, 2, 3]]]    ,       type=ArrayaD((1, 3)    ,       """int64"""   )   )   )
             self.assertEqual(arr.type    ,       ArrayaDExtensionType((1, 3)    ,       """int64"""   )   )
      def 			lowerCAmelCase__						(				self: Dict   ):
             with self.assertRaises((TypeError, pa.lib.ArrowInvalid)   ):
                    __lowerCamelCase   =						pa.array(TypedSequence(["""foo""", """bar"""]    ,       type=ArrayaD((1, 3)    ,       """int64"""   )   )   )
      def 			lowerCAmelCase__						(				self: Optional[int]   ):
             __lowerCamelCase   =						pa.array(TypedSequence([[[1, 2, 3]]]    ,       try_type=ArrayaD((1, 3)    ,       """int64"""   )   )   )
             self.assertEqual(arr.type    ,       ArrayaDExtensionType((1, 3)    ,       """int64"""   )   )
      def 			lowerCAmelCase__						(				self: int   ):
             __lowerCamelCase   =						pa.array(TypedSequence(["""foo""", """bar"""]    ,       try_type=ArrayaD((1, 3)    ,       """int64"""   )   )   )
             self.assertEqual(arr.type    ,       pa.string()   )




      @require_pil
      def 			lowerCAmelCase__						(				self: int   ):
             import PIL.Image

             __lowerCamelCase   =						PIL.Image.fromarray(np.arange(10    ,       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 					lowerCamelCase__       (						A__       :					int  ,			A__       :					Optional[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferReader(snake_case__	) if isinstance(snake_case__  ,			pa.Buffer	) else pa.memory_map(snake_case__	)
       __lowerCamelCase   =						pa.ipc.open_stream(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 					lowerCamelCase__       (						A__       :					int  ,			A__       :					Optional[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       __lowerCamelCase   =						pa.schema(snake_case__	) if fields else None
       with ArrowWriter(stream=snake_case__  ,			schema=snake_case__  ,			writer_batch_size=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(snake_case__  ,			metadata=writer._schema.metadata	)
       _check_output(output.getvalue()  ,			expected_num_chunks=num_examples if writer_batch_size == 1 else 1	)




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       __lowerCamelCase   =						Features({"""labels""": ClassLabel(names=["""neg""", """pos"""]	)}	)
       with ArrowWriter(stream=snake_case__  ,			features=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(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(snake_case__	)




@pytest.mark.parametrize("""writer_batch_size"""  ,			[None, 1, 10]	)
def 					lowerCamelCase__       (						A__       :					List[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       with ArrowWriter(
           stream=snake_case__  ,			writer_batch_size=snake_case__  ,			hash_salt="""split_name"""  ,			check_duplicates=snake_case__  ,			) as writer:
              with pytest.raises(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 					lowerCamelCase__       (						A__       :					List[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       with ArrowWriter(
           stream=snake_case__  ,			writer_batch_size=snake_case__  ,			hash_salt="""split_name"""  ,			check_duplicates=snake_case__  ,			) as writer:
              with pytest.raises(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 					lowerCamelCase__       (						A__       :					Tuple	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       with ArrowWriter(
           stream=snake_case__  ,			writer_batch_size=snake_case__  ,			hash_salt="""split_name"""  ,			check_duplicates=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 					lowerCamelCase__       (						A__       :					Optional[int]  ,			A__       :					Optional[int]	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       __lowerCamelCase   =						pa.schema(snake_case__	) if fields else None
       with ArrowWriter(stream=snake_case__  ,			schema=snake_case__  ,			writer_batch_size=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(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 					lowerCamelCase__       (						A__       :					Any  ,			A__       :					Dict	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       __lowerCamelCase   =						pa.schema(snake_case__	) if fields else None
       with ArrowWriter(stream=snake_case__  ,			schema=snake_case__  ,			writer_batch_size=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(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 					lowerCamelCase__       (						A__       :					Optional[Any]  ,			A__       :					int	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       __lowerCamelCase   =						pa.schema(snake_case__	) if fields else None
       with ArrowWriter(stream=snake_case__  ,			schema=snake_case__  ,			writer_batch_size=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(snake_case__  ,			metadata=writer._schema.metadata	)
       _check_output(output.getvalue()  ,			expected_num_chunks=num_examples if writer_batch_size == 1 else 1	)




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       with tempfile.TemporaryDirectory() as tmp_dir:
              __lowerCamelCase   =						{"""col_1""": pa.string(), """col_2""": pa.intaa()}
              __lowerCamelCase   =						os.path.join(snake_case__  ,			"""test.arrow"""	)
              with ArrowWriter(path=snake_case__  ,			schema=pa.schema(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(snake_case__  ,			metadata=writer._schema.metadata	)
              _check_output(snake_case__  ,			1	)




def 					lowerCamelCase__       (						A__       :					Union[str, Any]	):





       '''simple docstring'''



       if pa.types.is_list(snake_case__	):
              return get_base_dtype(arr_type.value_type	)
       else:
              return arr_type




def 					lowerCamelCase__       (						A__       :					Union[str, Any]  ,			A__       :					Dict	):





       '''simple docstring'''



       if isinstance(lst[0]  ,			snake_case__	):
              change_first_primitive_element_in_list(lst[0]  ,			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 					lowerCamelCase__       (						A__       :					List[str]  ,			A__       :					Tuple  ,			A__       :					Any	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.array(TypedSequence(snake_case__  ,			optimized_int_type=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 					lowerCamelCase__       (						A__       :					List[str]  ,			A__       :					List[Any]  ,			A__       :					List[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						pa.array(OptimizedTypedSequence(snake_case__  ,			col=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(snake_case__	)
              __lowerCamelCase   =						np.iinfo(expected_dtype.to_pandas_dtype()	).max + 1
              change_first_primitive_element_in_list(snake_case__  ,			snake_case__	)
              __lowerCamelCase   =						pa.array(OptimizedTypedSequence(snake_case__  ,			col=snake_case__	)	)
              assert get_base_dtype(arr.type	) == pa.intaa()




@pytest.mark.parametrize("""raise_exception"""  ,			[False, True]	)
def 					lowerCamelCase__       (						A__       :					Tuple  ,			A__       :					List[Any]	):





       '''simple docstring'''



       __lowerCamelCase   =						str(tmp_path / """dataset-train.arrow"""	)
       try:
              with ArrowWriter(path=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 					lowerCamelCase__       (						A__       :					Any	):





       '''simple docstring'''



       __lowerCamelCase   =						"""mock://dataset-train.arrow"""
       with ArrowWriter(path=snake_case__  ,			storage_options=mockfs.storage_options	) as writer:
              assert isinstance(writer._fs  ,			type(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(snake_case__	)




def 					lowerCamelCase__       (						):





       '''simple docstring'''



       __lowerCamelCase   =						pa.BufferOutputStream()
       with ParquetWriter(stream=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(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 					lowerCamelCase__       (						A__       :					Tuple  ,			A__       :					int	):





       '''simple docstring'''



       import PIL.Image

       __lowerCamelCase   =						str(tmp_path / """test_image_rgb.jpg"""	)
       PIL.Image.fromarray(np.zeros((5, 5)  ,			dtype=np.uinta	)	).save(snake_case__  ,			format="""png"""	)
       __lowerCamelCase   =						pa.BufferOutputStream()
       with ParquetWriter(
           stream=snake_case__  ,			features=Features({"""image""": Image()}	)  ,			embed_local_files=snake_case__	) as writer:
              writer.write({"""image""": image_path}	)
              writer.finalize()
       __lowerCamelCase   =						pa.BufferReader(output.getvalue()	)
       __lowerCamelCase   =						pq.read_table(snake_case__	)
       __lowerCamelCase   =						pa_table.to_pydict()
       if embed_local_files:
              assert isinstance(out["""image"""][0]["""path"""]  ,			snake_case__	)
              with open(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 					lowerCamelCase__       (						):





       '''simple docstring'''



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







"""simple docstring"""




def     a__ (				snake_case__				)						->					list:

			if len(snake_case__				) < 2:
						return collection

			def circle_sort_util(snake_case__       , snake_case__       , snake_case__				) -> bool:
						lowerCamelCase			      =					False

						if low == high:
									return swapped

						lowerCamelCase			      =					low
						lowerCamelCase			      =					high

						while left < right:
									if collection[left] > collection[right]:
												lowerCamelCase      ,   lowerCamelCase			      =					(
												    collection[right],
												    collection[left],
												)
												lowerCamelCase			      =					True

									left += 1
									right -= 1

						if left == right and collection[left] > collection[right + 1]:
									lowerCamelCase      ,   lowerCamelCase			      =					(
									    collection[right + 1],
									    collection[left],
									)

									lowerCamelCase			      =					True

						lowerCamelCase			      =					low + int((high - low) / 2				)
						lowerCamelCase			      =					circle_sort_util(snake_case__       , snake_case__       , snake_case__				)
						lowerCamelCase			      =					circle_sort_util(snake_case__       , mid + 1       , snake_case__				)

						return swapped or left_swap or right_swap

			lowerCamelCase			      =					True

			while is_not_sorted is True:
						lowerCamelCase			      =					circle_sort_util(snake_case__       , 0       , len(snake_case__				) - 1				)

			return collection


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



