






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    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							with self.assertRaises(UpperCAmelCase    ):
													_UpperCAmelCase									=			pa.array(TypedSequence([1, 2, 3]       ,    try_type=Value('bool'    )       ,    type=Value('int64'    )    )    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	@require_pil
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							import PIL.Image

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



def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  List[str]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferReader(__lowerCAmelCase	) if isinstance(__lowerCAmelCase ,		pa.Buffer	) else pa.memory_map(__lowerCAmelCase	)
						_UpperCAmelCase									=			pa.ipc.open_stream(__lowerCAmelCase	)
						_UpperCAmelCase									=			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    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  List[str]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferOutputStream()
						_UpperCAmelCase									=			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}	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												_UpperCAmelCase									=			{'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 __A    (      )->  Union[str, Any]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferOutputStream()
						_UpperCAmelCase									=			Features({'labels': ClassLabel(names=['neg', 'pos']	)}	)
						with ArrowWriter(stream=__lowerCAmelCase ,		features=__lowerCAmelCase	) as writer:
												writer.write({'labels': 0}	)
												writer.write({'labels': 1}	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						assert writer._schema == features.arrow_schema
						assert writer._schema.metadata == features.arrow_schema.metadata
						_UpperCAmelCase									=			pa.BufferReader(output.getvalue()	)
						_UpperCAmelCase									=			pa.ipc.open_stream(__lowerCAmelCase	)
						_UpperCAmelCase									=			f.read_all()
						_UpperCAmelCase									=			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 __A    (      __lowerCAmelCase	)->  Dict:





						"""simple docstring"""



						_UpperCAmelCase									=			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]	)
																		_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()


@pytest.mark.parametrize('writer_batch_size' ,		[None, 2, 10]	)
def __A    (      __lowerCAmelCase	)->  Any:





						"""simple docstring"""



						_UpperCAmelCase									=			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	)
																		_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()


@pytest.mark.parametrize('writer_batch_size' ,		[None, 2, 10]	)
def __A    (      __lowerCAmelCase	)->  Any:





						"""simple docstring"""



						_UpperCAmelCase									=			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	)
												_UpperCAmelCase					, _UpperCAmelCase									=			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    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  Optional[int]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferOutputStream()
						_UpperCAmelCase									=			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': []}	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												_UpperCAmelCase									=			{'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 __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  Optional[Any]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferOutputStream()
						_UpperCAmelCase									=			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]}	)	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												_UpperCAmelCase									=			{'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 __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  List[str]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferOutputStream()
						_UpperCAmelCase									=			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]}	)	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						if not fields:
												_UpperCAmelCase									=			{'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 __A    (      )->  int:





						"""simple docstring"""



						with tempfile.TemporaryDirectory() as tmp_dir:
												_UpperCAmelCase									=			{'col_1': pa.string(), 'col_2': pa.intaa()}
												_UpperCAmelCase									=			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]}	)
																		_UpperCAmelCase					, _UpperCAmelCase									=			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 __A    (      __lowerCAmelCase	)->  Tuple:





						"""simple docstring"""



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


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  Dict:





						"""simple docstring"""



						if isinstance(lst[0] ,		__lowerCAmelCase	):
												change_first_primitive_element_in_list(lst[0] ,		__lowerCAmelCase	)
						else:
												_UpperCAmelCase									=			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    (      __lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	)->  int:





						"""simple docstring"""



						_UpperCAmelCase									=			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 __A    (      __lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	)->  Any:





						"""simple docstring"""



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


@pytest.mark.parametrize('raise_exception' ,		[False, True]	)
def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  Optional[Any]:





						"""simple docstring"""



						_UpperCAmelCase									=			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 __A    (      __lowerCAmelCase	)->  str:





						"""simple docstring"""



						_UpperCAmelCase									=			'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}	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						assert mockfs.exists(__lowerCAmelCase	)


def __A    (      )->  Any:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.BufferOutputStream()
						with ParquetWriter(stream=__lowerCAmelCase	) as writer:
												writer.write({'col_1': 'foo', 'col_2': 1}	)
												writer.write({'col_1': 'bar', 'col_2': 2}	)
												_UpperCAmelCase					, _UpperCAmelCase									=			writer.finalize()
						assert num_examples == 2
						assert num_bytes > 0
						_UpperCAmelCase									=			pa.BufferReader(output.getvalue()	)
						_UpperCAmelCase									=			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 __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  str:





						"""simple docstring"""



						import PIL.Image

						_UpperCAmelCase									=			str(tmp_path / 'test_image_rgb.jpg'	)
						PIL.Image.fromarray(np.zeros((5, 5) ,		dtype=np.uinta	)	).save(__lowerCAmelCase ,		format='png'	)
						_UpperCAmelCase									=			pa.BufferOutputStream()
						with ParquetWriter(
						    stream=__lowerCAmelCase ,		features=Features({'image': Image()}	) ,		embed_local_files=__lowerCAmelCase	) as writer:
												writer.write({'image': image_path}	)
												writer.finalize()
						_UpperCAmelCase									=			pa.BufferReader(output.getvalue()	)
						_UpperCAmelCase									=			pq.read_table(__lowerCAmelCase	)
						_UpperCAmelCase									=			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 __A    (      )->  Optional[Any]:





						"""simple docstring"""



						_UpperCAmelCase									=			pa.schema([pa.field('col_1' ,		pa.string() ,		nullable=__lowerCAmelCase	)]	)
						_UpperCAmelCase									=			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()	)]	)








class __lowerCamelCase :





	"""simple docstring"""






	def __init__(							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			{}  # Mapping from char to TrieNode
							_UpperCAmelCase									=			False

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







							for word in words:
													self.insert(UpperCAmelCase    )

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self
							for char in word:
													if char not in curr.nodes:
																			_UpperCAmelCase									=			TrieNode()
													_UpperCAmelCase									=			curr.nodes[char]
							_UpperCAmelCase									=			True

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self
							for char in word:
													if char not in curr.nodes:
																			return False
													_UpperCAmelCase									=			curr.nodes[char]
							return curr.is_leaf

	def        UpperCamelCase    (							self       ,    UpperCAmelCase    ):
							"""simple docstring"""







							def _delete(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    ) -> bool:
													if index == len(UpperCAmelCase    ):
																			# If word does not exist
																			if not curr.is_leaf:
																									return False
																			_UpperCAmelCase									=			False
																			return len(curr.nodes    ) == 0
													_UpperCAmelCase									=			word[index]
													_UpperCAmelCase									=			curr.nodes.get(UpperCAmelCase    )
													# If char not in current trie node
													if not char_node:
																			return False
													# Flag to check if node can be deleted
													_UpperCAmelCase									=			_delete(UpperCAmelCase       ,    UpperCAmelCase       ,    index + 1    )
													if delete_curr:
																			del curr.nodes[char]
																			return len(curr.nodes    ) == 0
													return delete_curr

							_delete(self       ,    UpperCAmelCase       ,    0    )



def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  None:





						"""simple docstring"""



						if node.is_leaf:
												print(__lowerCAmelCase ,		end=' '	)

						for key, value in node.nodes.items():
												print_words(__lowerCAmelCase ,		word + key	)


def __A    (      )->  bool:





						"""simple docstring"""



						_UpperCAmelCase									=			'banana bananas bandana band apple all beast'.split()
						_UpperCAmelCase									=			TrieNode()
						root.insert_many(__lowerCAmelCase	)
						# print_words(root, "")
						assert all(root.find(__lowerCAmelCase	) for word in words	)
						assert root.find('banana'	)
						assert not root.find('bandanas'	)
						assert not root.find('apps'	)
						assert root.find('apple'	)
						assert root.find('all'	)
						root.delete('all'	)
						assert not root.find('all'	)
						root.delete('banana'	)
						assert not root.find('banana'	)
						assert root.find('bananas'	)
						return True


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  None:





						"""simple docstring"""



						print(str(__lowerCAmelCase	) ,		'works!' if passes else 'doesn\'t work :('	)


def __A    (      )->  None:





						"""simple docstring"""



						assert test_trie()


def __A    (      )->  None:





						"""simple docstring"""



						print_results('Testing trie functionality' ,		test_trie()	)


if __name__ == "__main__":
		main()
