


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__ (					__snake_case  ):






						"""simple docstring"""




						def 	_UpperCamelCase					(       self      ):
							lowerCamelCase_					:				int              =  pa.array(TypedSequence([1, 2, 3]      )      )
							self.assertEqual(arr.type ,				pa.intaa()      )




						def 	_UpperCamelCase					(       self      ):






							with self.assertRaises(a_      ):
								lowerCamelCase_					:				List[str]              =  pa.array(TypedSequence([1, 2, 3]      ) ,				type=pa.intaa()      )




						def 	_UpperCamelCase					(       self      ):






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




						def 	_UpperCamelCase					(       self      ):
							lowerCamelCase_					:				List[Any]              =  pa.array(TypedSequence([1, 2, 3] ,				type=Value("int32"      )      )      )
							self.assertEqual(arr.type ,				pa.intaa()      )




						def 	_UpperCamelCase					(       self      ):






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




						def 	_UpperCamelCase					(       self      ):
							lowerCamelCase_					:				Any              =  pa.array(TypedSequence([1, 2, 3] ,				try_type=Value("int32"      )      )      )
							self.assertEqual(arr.type ,				pa.intaa()      )




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




						def 	_UpperCamelCase					(       self      ):
							lowerCamelCase_					:				Dict              =  pa.array(TypedSequence([[[1, 2, 3]]] ,				type=ArrayaD((1, 3) ,				"int64"      )      )      )
							self.assertEqual(arr.type ,				ArrayaDExtensionType((1, 3) ,				"int64"      )      )




						def 	_UpperCamelCase					(       self      ):






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




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




						def 	_UpperCamelCase					(       self      ):
							lowerCamelCase_					:				List[str]              =  pa.array(TypedSequence(["foo", "bar"] ,				try_type=ArrayaD((1, 3) ,				"int64"      )      )      )
							self.assertEqual(arr.type ,				pa.string()      )




						@require_pil
						def 	_UpperCamelCase					(       self      ):
							import PIL.Image

							lowerCamelCase_					:				Optional[Any]              =  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_					:				Dict              =  pa.array(TypedSequence([{"path": None, "bytes": b"image_bytes"}, pil_image] ,				type=Image()      )      )
								lowerCamelCase_       ,lowerCamelCase_					:				Any              =  mock_cast_to_python_objects.call_args_list[-1]
								self.assertIn("optimize_list_casting" ,				a_      )
								self.assertFalse(kwargs["optimize_list_casting"]      )







def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				List[str]              =  pa.BufferReader(_lowercase) if isinstance(_lowercase     ,	pa.Buffer) else pa.memory_map(_lowercase)
	lowerCamelCase_					:				int              =  pa.ipc.open_stream(_lowercase)
	lowerCamelCase_					:				Any              =  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 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				List[Any]              =  pa.BufferOutputStream()
	lowerCamelCase_					:				Union[str, Any]              =  pa.schema(_lowercase) if fields else None
	with ArrowWriter(stream=_lowercase     ,	schema=_lowercase     ,	writer_batch_size=_lowercase) as writer:
		writer.write({"col_1": "foo", "col_2": 1})
		writer.write({"col_1": "bar", "col_2": 2})
		lowerCamelCase_       ,lowerCamelCase_					:				Tuple              =  writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		lowerCamelCase_					:				int              =  {"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(_lowercase     ,	metadata=writer._schema.metadata)
	_check_output(output.getvalue()     ,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1)







def 							__magic_name__    (     ):
	'''simple docstring'''


	lowerCamelCase_					:				Tuple              =  pa.BufferOutputStream()
	lowerCamelCase_					:				Dict              =  Features({"labels": ClassLabel(names=["neg", "pos"])})
	with ArrowWriter(stream=_lowercase     ,	features=_lowercase) as writer:
		writer.write({"labels": 0})
		writer.write({"labels": 1})
		lowerCamelCase_       ,lowerCamelCase_					:				List[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
	lowerCamelCase_					:				Tuple              =  pa.BufferReader(output.getvalue())
	lowerCamelCase_					:				int              =  pa.ipc.open_stream(_lowercase)
	lowerCamelCase_					:				Optional[Any]              =  f.read_all()
	lowerCamelCase_					:				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(_lowercase)







@pytest.mark.parametrize("writer_batch_size"     ,	[None, 1, 10])
def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Union[str, Any]              =  pa.BufferOutputStream()
	with ArrowWriter(
	    stream=_lowercase     ,	writer_batch_size=_lowercase     ,	hash_salt="split_name"     ,	check_duplicates=_lowercase     ,	) as writer:
		with pytest.raises(_lowercase):
			writer.write({"col_1": "foo", "col_2": 1}     ,	key=[1, 2])
			lowerCamelCase_       ,lowerCamelCase_					:				Any              =  writer.finalize()







@pytest.mark.parametrize("writer_batch_size"     ,	[None, 2, 10])
def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Any              =  pa.BufferOutputStream()
	with ArrowWriter(
	    stream=_lowercase     ,	writer_batch_size=_lowercase     ,	hash_salt="split_name"     ,	check_duplicates=_lowercase     ,	) as writer:
		with pytest.raises(_lowercase):
			writer.write({"col_1": "foo", "col_2": 1}     ,	key=10)
			writer.write({"col_1": "bar", "col_2": 2}     ,	key=10)
			lowerCamelCase_       ,lowerCamelCase_					:				List[Any]              =  writer.finalize()







@pytest.mark.parametrize("writer_batch_size"     ,	[None, 2, 10])
def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Optional[Any]              =  pa.BufferOutputStream()
	with ArrowWriter(
	    stream=_lowercase     ,	writer_batch_size=_lowercase     ,	hash_salt="split_name"     ,	check_duplicates=_lowercase     ,	) as writer:
		writer.write({"col_1": "foo", "col_2": 1}     ,	key=1)
		writer.write({"col_1": "bar", "col_2": 2}     ,	key=2)
		lowerCamelCase_       ,lowerCamelCase_					:				str              =  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 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Optional[int]              =  pa.BufferOutputStream()
	lowerCamelCase_					:				Tuple              =  pa.schema(_lowercase) if fields else None
	with ArrowWriter(stream=_lowercase     ,	schema=_lowercase     ,	writer_batch_size=_lowercase) as writer:
		writer.write_batch({"col_1": ["foo", "bar"], "col_2": [1, 2]})
		writer.write_batch({"col_1": [], "col_2": []})
		lowerCamelCase_       ,lowerCamelCase_					:				str              =  writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		lowerCamelCase_					:				List[str]              =  {"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(_lowercase     ,	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 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Optional[int]              =  pa.BufferOutputStream()
	lowerCamelCase_					:				Dict              =  pa.schema(_lowercase) if fields else None
	with ArrowWriter(stream=_lowercase     ,	schema=_lowercase     ,	writer_batch_size=_lowercase) as writer:
		writer.write_table(pa.Table.from_pydict({"col_1": ["foo", "bar"], "col_2": [1, 2]}))
		lowerCamelCase_       ,lowerCamelCase_					:				Optional[Any]              =  writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		lowerCamelCase_					:				str              =  {"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(_lowercase     ,	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 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				int              =  pa.BufferOutputStream()
	lowerCamelCase_					:				Optional[int]              =  pa.schema(_lowercase) if fields else None
	with ArrowWriter(stream=_lowercase     ,	schema=_lowercase     ,	writer_batch_size=_lowercase) 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_					:				str              =  writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	if not fields:
		lowerCamelCase_					:				Tuple              =  {"col_1": pa.string(), "col_2": pa.intaa()}
	assert writer._schema == pa.schema(_lowercase     ,	metadata=writer._schema.metadata)
	_check_output(output.getvalue()     ,	expected_num_chunks=num_examples if writer_batch_size == 1 else 1)







def 							__magic_name__    (     ):
	'''simple docstring'''


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







def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


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







def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	if isinstance(lst[0]     ,	_lowercase):
		change_first_primitive_element_in_list(lst[0]     ,	_lowercase)
	else:
		lowerCamelCase_					:				Tuple              =  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 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Optional[int]              =  pa.array(TypedSequence(_lowercase     ,	optimized_int_type=_lowercase))
	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 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Dict              =  pa.array(OptimizedTypedSequence(_lowercase     ,	col=_lowercase))
	assert get_base_dtype(arr.type) == expected_dtype

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







@pytest.mark.parametrize("raise_exception"     ,	[False, True])
def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				Union[str, Any]              =  str(tmp_path / "dataset-train.arrow")
	try:
		with ArrowWriter(path=_lowercase) as writer:
			if raise_exception:
				raise pa.lib.ArrowInvalid()
			else:
				writer.stream.close()
	except pa.lib.ArrowInvalid:
		pass
	finally:
		assert writer.stream.closed







def 							__magic_name__    (     lowerCAmelCase_):
	'''simple docstring'''


	lowerCamelCase_					:				List[Any]              =  "mock://dataset-train.arrow"
	with ArrowWriter(path=_lowercase     ,	storage_options=mockfs.storage_options) as writer:
		assert isinstance(writer._fs     ,	type(_lowercase))
		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_					:				Any              =  writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	assert mockfs.exists(_lowercase)







def 							__magic_name__    (     ):
	'''simple docstring'''


	lowerCamelCase_					:				Optional[int]              =  pa.BufferOutputStream()
	with ParquetWriter(stream=_lowercase) as writer:
		writer.write({"col_1": "foo", "col_2": 1})
		writer.write({"col_1": "bar", "col_2": 2})
		lowerCamelCase_       ,lowerCamelCase_					:				int              =  writer.finalize()
	assert num_examples == 2
	assert num_bytes > 0
	lowerCamelCase_					:				Optional[int]              =  pa.BufferReader(output.getvalue())
	lowerCamelCase_					:				Union[str, Any]              =  pq.read_table(_lowercase)
	assert pa_table.to_pydict() == {"col_1": ["foo", "bar"], "col_2": [1, 2]}







@require_pil
@pytest.mark.parametrize("embed_local_files"     ,	[False, True])
def 							__magic_name__    (     lowerCAmelCase_     ,	lowerCAmelCase_):
	'''simple docstring'''


	import PIL.Image

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


	lowerCamelCase_					:				List[str]              =  pa.schema([pa.field("col_1"     ,	pa.string()     ,	nullable=_lowercase)])
	lowerCamelCase_					:				Any              =  pa.BufferOutputStream()
	with ArrowWriter(stream=_lowercase) as writer:
		writer._build_writer(inferred_schema=_lowercase)
		assert writer._schema == pa.schema([pa.field("col_1"     ,	pa.string())])





"""simple docstring"""



import math
from datetime import datetime, timedelta
def      UpperCAmelCase     (       _lowercase :   int	)						-> datetime:


	"""simple docstring"""




	lowerCAmelCase_      							=			year % 1_9
	lowerCAmelCase_      							=			year % 4
	lowerCAmelCase_      							=			year % 7
	lowerCAmelCase_      							=			math.floor(year / 1_0_0	)
	lowerCAmelCase_      							=			math.floor((1_3 + 8 * leap_day_inhibits) / 2_5	)
	lowerCAmelCase_      							=			leap_day_inhibits / 4
	lowerCAmelCase_      							=			(
	    1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 3_0
	lowerCAmelCase_      							=			(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

	# days to be added to March 21
	lowerCAmelCase_      							=			(1_9 * metonic_cycle + secular_moon_shift) % 3_0

	# PHM -> Paschal Full Moon
	lowerCAmelCase_      							=			(
	    2 * julian_leap_year
	    + 4 * non_leap_year
	    + 6 * days_to_add
	    + century_starting_point
	) % 7

	if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
		return datetime(_lowercase			,   4			,   1_9	)
	elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
		return datetime(_lowercase			,   4			,   1_8	)
	else:
		return datetime(_lowercase			,   3			,   2_2	) + timedelta(
		    days=int(days_to_add + days_from_phm_to_sunday	)	)


if __name__ == "__main__":
		for year in (19_94, 20_00, 20_10, 20_21, 20_23):
				lowercase_							=							'will be' if year > datetime.now().year else 'was'
				print(f"""Easter in {year} {tense} {gauss_easter(year)}""")