




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   (      UpperCamelCase__      ):

						def      A__    (		self :List[Any]			):
										'''simple docstring'''

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

						def      A__    (		self :int			):
										'''simple docstring'''

										with self.assertRaises(__snake_case			):
														__magic_name__						:						List[Any]										=pa.array(TypedSequence([1, 2, 3]			)     ,			type=pa.intaa()			)

						def      A__    (		self :Tuple			):
										'''simple docstring'''

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

						def      A__    (		self :Union[str, Any]			):
										'''simple docstring'''

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

						def      A__    (		self :str			):
										'''simple docstring'''

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

						def      A__    (		self :List[str]			):
										'''simple docstring'''

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

						def      A__    (		self :List[str]			):
										'''simple docstring'''

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

						def      A__    (		self :Optional[Any]			):
										'''simple docstring'''

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

						def      A__    (		self :int			):
										'''simple docstring'''

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

						def      A__    (		self :int			):
										'''simple docstring'''

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

						def      A__    (		self :Union[str, Any]			):
										'''simple docstring'''

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


						@require_pil
						def      A__    (		self :Optional[Any]			):
										'''simple docstring'''

										import PIL.Image

										__magic_name__						:						int										=PIL.Image.fromarray(np.arange(10     ,			dtype=np.uinta			).reshape(2     ,			5			)			)
										with patch(
										    """datasets.arrow_writer.cast_to_python_objects"""     ,			side_effect=__snake_case			) as mock_cast_to_python_objects:
														__magic_name__						:						Optional[Any]										=pa.array(TypedSequence([{"""path""": None, """bytes""": B"""image_bytes"""}, pil_image]     ,			type=Image()			)			)
														__magic_name__					,			__magic_name__						:						List[Any]										=mock_cast_to_python_objects.call_args_list[-1]
														self.assertIn("""optimize_list_casting"""     ,			__snake_case			)
														self.assertFalse(kwargs["""optimize_list_casting"""]			)




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[Any]										=pa.BufferReader(lowerCamelCase ) if isinstance(lowerCamelCase						,  pa.Buffer ) else pa.memory_map(lowerCamelCase )
				__magic_name__						:						int										=pa.ipc.open_stream(lowerCamelCase )
				__magic_name__						:						pa.Table										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Tuple										=pa.BufferOutputStream()
				__magic_name__						:						Any										=pa.schema(lowerCamelCase ) if fields else None
				with ArrowWriter(stream=lowerCamelCase						,  schema=lowerCamelCase						,  writer_batch_size=lowerCamelCase ) as writer:
								writer.write({"""col_1""": """foo""", """col_2""": 1} )
								writer.write({"""col_1""": """bar""", """col_2""": 2} )
								__magic_name__					,			__magic_name__						:						List[Any]										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				if not fields:
								__magic_name__						:						int										={"""col_1""": pa.string(), """col_2""": pa.intaa()}
				assert writer._schema == pa.schema(lowerCamelCase						,  metadata=writer._schema.metadata )
				_check_output(output.getvalue()						,  expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )




def 		lowerCAmelCase_ (						):
				__magic_name__						:						int										=pa.BufferOutputStream()
				__magic_name__						:						int										=Features({"""labels""": ClassLabel(names=["""neg""", """pos"""] )} )
				with ArrowWriter(stream=lowerCamelCase						,  features=lowerCamelCase ) as writer:
								writer.write({"""labels""": 0} )
								writer.write({"""labels""": 1} )
								__magic_name__					,			__magic_name__						:						Union[str, Any]										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				assert writer._schema == features.arrow_schema
				assert writer._schema.metadata == features.arrow_schema.metadata
				__magic_name__						:						List[Any]										=pa.BufferReader(output.getvalue() )
				__magic_name__						:						Any										=pa.ipc.open_stream(lowerCamelCase )
				__magic_name__						:						pa.Table										=f.read_all()
				__magic_name__						:						Optional[int]										=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(lowerCamelCase )




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




@pytest.mark.parametrize("""writer_batch_size"""						,  [None, 2, 10] )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						List[str]										=pa.BufferOutputStream()
				with ArrowWriter(
				    stream=lowerCamelCase						,  writer_batch_size=lowerCamelCase						,  hash_salt="""split_name"""						,  check_duplicates=lowerCamelCase						,  ) as writer:
								with pytest.raises(lowerCamelCase ):
												writer.write({"""col_1""": """foo""", """col_2""": 1}						,  key=10 )
												writer.write({"""col_1""": """bar""", """col_2""": 2}						,  key=10 )
												__magic_name__					,			__magic_name__						:						Optional[int]										=writer.finalize()




@pytest.mark.parametrize("""writer_batch_size"""						,  [None, 2, 10] )
def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						str										=pa.BufferOutputStream()
				with ArrowWriter(
				    stream=lowerCamelCase						,  writer_batch_size=lowerCamelCase						,  hash_salt="""split_name"""						,  check_duplicates=lowerCamelCase						,  ) as writer:
								writer.write({"""col_1""": """foo""", """col_2""": 1}						,  key=1 )
								writer.write({"""col_1""": """bar""", """col_2""": 2}						,  key=2 )
								__magic_name__					,			__magic_name__						:						Optional[Any]										=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_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						str										=pa.BufferOutputStream()
				__magic_name__						:						Union[str, Any]										=pa.schema(lowerCamelCase ) if fields else None
				with ArrowWriter(stream=lowerCamelCase						,  schema=lowerCamelCase						,  writer_batch_size=lowerCamelCase ) as writer:
								writer.write_batch({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} )
								writer.write_batch({"""col_1""": [], """col_2""": []} )
								__magic_name__					,			__magic_name__						:						List[str]										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				if not fields:
								__magic_name__						:						Union[str, Any]										={"""col_1""": pa.string(), """col_2""": pa.intaa()}
				assert writer._schema == pa.schema(lowerCamelCase						,  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_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Optional[int]										=pa.BufferOutputStream()
				__magic_name__						:						Any										=pa.schema(lowerCamelCase ) if fields else None
				with ArrowWriter(stream=lowerCamelCase						,  schema=lowerCamelCase						,  writer_batch_size=lowerCamelCase ) as writer:
								writer.write_table(pa.Table.from_pydict({"""col_1""": ["""foo""", """bar"""], """col_2""": [1, 2]} ) )
								__magic_name__					,			__magic_name__						:						List[Any]										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				if not fields:
								__magic_name__						:						int										={"""col_1""": pa.string(), """col_2""": pa.intaa()}
				assert writer._schema == pa.schema(lowerCamelCase						,  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_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Union[str, Any]										=pa.BufferOutputStream()
				__magic_name__						:						Union[str, Any]										=pa.schema(lowerCamelCase ) if fields else None
				with ArrowWriter(stream=lowerCamelCase						,  schema=lowerCamelCase						,  writer_batch_size=lowerCamelCase ) 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]} ) )
								__magic_name__					,			__magic_name__						:						Dict										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				if not fields:
								__magic_name__						:						int										={"""col_1""": pa.string(), """col_2""": pa.intaa()}
				assert writer._schema == pa.schema(lowerCamelCase						,  metadata=writer._schema.metadata )
				_check_output(output.getvalue()						,  expected_num_chunks=num_examples if writer_batch_size == 1 else 1 )




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




def 		lowerCAmelCase_ (						lowerCamelCase ):
				if pa.types.is_list(lowerCamelCase ):
								return get_base_dtype(arr_type.value_type )
				else:
								return arr_type




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				if isinstance(lst[0]						,  lowerCamelCase ):
								change_first_primitive_element_in_list(lst[0]						,  lowerCamelCase )
				else:
								__magic_name__						:						Any										=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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Optional[Any]										=pa.array(TypedSequence(lowerCamelCase						,  optimized_int_type=lowerCamelCase ) )
				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_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				# in range
				__magic_name__						:						int										=pa.array(OptimizedTypedSequence(lowerCamelCase						,  col=lowerCamelCase ) )
				assert get_base_dtype(arr.type ) == expected_dtype

				# not in range
				if col != "other":
								# avoids errors due to in-place modifications
								__magic_name__						:						List[str]										=copy.deepcopy(lowerCamelCase )
								__magic_name__						:						Optional[Any]										=np.iinfo(expected_dtype.to_pandas_dtype() ).max + 1
								change_first_primitive_element_in_list(lowerCamelCase						,  lowerCamelCase )
								__magic_name__						:						Optional[int]										=pa.array(OptimizedTypedSequence(lowerCamelCase						,  col=lowerCamelCase ) )
								assert get_base_dtype(arr.type ) == pa.intaa()




@pytest.mark.parametrize("""raise_exception"""						,  [False, True] )
def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						Optional[Any]										=str(tmp_path / """dataset-train.arrow""" )
				try:
								with ArrowWriter(path=lowerCamelCase ) 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_ (						lowerCamelCase ):
				__magic_name__						:						Dict										="""mock://dataset-train.arrow"""
				with ArrowWriter(path=lowerCamelCase						,  storage_options=mockfs.storage_options ) as writer:
								assert isinstance(writer._fs						,  type(lowerCamelCase ) )
								assert writer._fs.storage_options == mockfs.storage_options
								writer.write({"""col_1""": """foo""", """col_2""": 1} )
								writer.write({"""col_1""": """bar""", """col_2""": 2} )
								__magic_name__					,			__magic_name__						:						str										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				assert mockfs.exists(lowerCamelCase )




def 		lowerCAmelCase_ (						):
				__magic_name__						:						int										=pa.BufferOutputStream()
				with ParquetWriter(stream=lowerCamelCase ) as writer:
								writer.write({"""col_1""": """foo""", """col_2""": 1} )
								writer.write({"""col_1""": """bar""", """col_2""": 2} )
								__magic_name__					,			__magic_name__						:						List[Any]										=writer.finalize()
				assert num_examples == 2
				assert num_bytes > 0
				__magic_name__						:						str										=pa.BufferReader(output.getvalue() )
				__magic_name__						:						pa.Table										=pq.read_table(lowerCamelCase )
				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_ (						lowerCamelCase						,  lowerCamelCase ):
				import PIL.Image

				__magic_name__						:						List[Any]										=str(tmp_path / """test_image_rgb.jpg""" )
				PIL.Image.fromarray(np.zeros((5, 5)						,  dtype=np.uinta ) ).save(lowerCamelCase						,  format="""png""" )
				__magic_name__						:						Tuple										=pa.BufferOutputStream()
				with ParquetWriter(
				    stream=lowerCamelCase						,  features=Features({"""image""": Image()} )						,  embed_local_files=lowerCamelCase ) as writer:
								writer.write({"""image""": image_path} )
								writer.finalize()
				__magic_name__						:						Dict										=pa.BufferReader(output.getvalue() )
				__magic_name__						:						pa.Table										=pq.read_table(lowerCamelCase )
				__magic_name__						:						str										=pa_table.to_pydict()
				if embed_local_files:
								assert isinstance(out["""image"""][0]["""path"""]						,  lowerCamelCase )
								with open(lowerCamelCase						,  """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_ (						):
				__magic_name__						:						List[str]										=pa.schema([pa.field("""col_1"""						,  pa.string()						,  nullable=lowerCamelCase )] )
				__magic_name__						:						str										=pa.BufferOutputStream()
				with ArrowWriter(stream=lowerCamelCase ) as writer:
								writer._build_writer(inferred_schema=lowerCamelCase )
								assert writer._schema == pa.schema([pa.field("""col_1"""						,  pa.string() )] )










from __future__ import annotations

from fractions import Fraction




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase ):
				return (
				    num != den and num % 10 == den // 10 and (num // 10) / (den % 10) == num / den
				)




def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						List[str]										=[]
				__magic_name__						:						List[Any]										=11
				__magic_name__						:						Tuple										=int("""1""" + """0""" * digit_len )
				for num in range(lowerCamelCase						,  lowerCamelCase ):
								while den <= 99:
												if (num != den) and (num % 10 == den // 10) and (den % 10 != 0):
																if is_digit_cancelling(lowerCamelCase						,  lowerCamelCase ):
																				solutions.append(F"{num}/{den}" )
												den += 1
								num += 1
								__magic_name__						:						List[str]										=10
				return solutions




def 		lowerCAmelCase_ (						lowerCamelCase = 2 ):
				__magic_name__						:						str										=1.0
				for fraction in fraction_list(lowerCamelCase ):
								__magic_name__						:						int										=Fraction(lowerCamelCase )
								result *= frac.denominator / frac.numerator
				return int(lowerCamelCase )


if __name__ == "__main__":
							print(solution())




