
"""simple docstring"""




import unittest

from datasets import load_dataset

from transformers import BloomTokenizerFast
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin



@require_tokenizers
class 			lowerCAmelCase_		(a__				,      unittest.TestCase						):


				"""simple docstring"""



				__UpperCamelCase   :		Dict       =     None
				__UpperCamelCase   :		int       =     BloomTokenizerFast
				__UpperCamelCase   :		Optional[Any]       =     BloomTokenizerFast
				__UpperCamelCase   :		Union[str, Any]       =     True
				__UpperCamelCase   :		Union[str, Any]       =     False
				__UpperCamelCase   :		Any       =     '''tokenizer_file'''
				__UpperCamelCase   :		List[Any]       =     {'''bos_token''': '''<s>''', '''eos_token''': '''</s>''', '''unk_token''': '''<unk>''', '''pad_token''': '''<pad>'''}



				def 			__magic_name__					(self					)      ->	int:



											"""simple docstring"""




											super().setUp()
											SCREAMING_SNAKE_CASE__		: List[Any]     =     BloomTokenizerFast.from_pretrained("""bigscience/tokenizer"""					)
											tokenizer.save_pretrained(self.tmpdirname					)



				def 			__magic_name__					(self     , **SCREAMING_SNAKE_CASE__					)      ->	Union[str, Any]:



											"""simple docstring"""




											kwargs.update(self.special_tokens_map					)
											return BloomTokenizerFast.from_pretrained(self.tmpdirname     , **SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.get_rust_tokenizer()

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     ["""The quick brown fox</s>""", """jumps over the lazy dog</s>"""]
											SCREAMING_SNAKE_CASE__		: Tuple     =     [[21_75, 2_37_14, 7_31_73, 14_42_52, 2], [77, 13_26_19, 34_78, 3_68, 10_95_86, 3_54_33, 2]]

											SCREAMING_SNAKE_CASE__		: Optional[int]     =     tokenizer.batch_encode_plus(SCREAMING_SNAKE_CASE__					)["""input_ids"""]
											self.assertListEqual(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Tuple     =     tokenizer.batch_decode(SCREAMING_SNAKE_CASE__					)
											self.assertListEqual(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__=6					)      ->	Optional[Any]:



											"""simple docstring"""




											for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
																		with self.subTest(F'''{tokenizer.__class__.__name__} ({pretrained_name})'''					):
																									SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.rust_tokenizer_class.from_pretrained(SCREAMING_SNAKE_CASE__     , **SCREAMING_SNAKE_CASE__					)
																									# tokenizer_r.pad_token = None # Hotfixing padding = None
																									# Simple input
																									SCREAMING_SNAKE_CASE__		: Dict     =     """This is a simple input"""
																									SCREAMING_SNAKE_CASE__		: Tuple     =     ["""This is a simple input 1""", """This is a simple input 2"""]
																									SCREAMING_SNAKE_CASE__		: Optional[int]     =     ("""This is a simple input""", """This is a pair""")
																									SCREAMING_SNAKE_CASE__		: Any     =     [
																									    ("""This is a simple input 1""", """This is a simple input 2"""),
																									    ("""This is a simple pair 1""", """This is a simple pair 2"""),
																									]

																									# Simple input tests
																									try:
																																tokenizer_r.encode(SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__					)
																																tokenizer_r.encode_plus(SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__					)

																																tokenizer_r.batch_encode_plus(SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__					)
																																tokenizer_r.encode(SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__					)
																																tokenizer_r.batch_encode_plus(SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__					)
																									except ValueError:
																																self.fail("""Bloom Tokenizer should be able to deal with padding"""					)

																									SCREAMING_SNAKE_CASE__		: Dict     =     None  # Hotfixing padding = None
																									self.assertRaises(SCREAMING_SNAKE_CASE__     , tokenizer_r.encode     , SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__     , padding="""max_length"""					)

																									# Simple input
																									self.assertRaises(SCREAMING_SNAKE_CASE__     , tokenizer_r.encode_plus     , SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__     , padding="""max_length"""					)

																									# Simple input
																									self.assertRaises(
																									    SCREAMING_SNAKE_CASE__     , tokenizer_r.batch_encode_plus     , SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , )

																									# Pair input
																									self.assertRaises(SCREAMING_SNAKE_CASE__     , tokenizer_r.encode     , SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__     , padding="""max_length"""					)

																									# Pair input
																									self.assertRaises(SCREAMING_SNAKE_CASE__     , tokenizer_r.encode_plus     , SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__     , padding="""max_length"""					)

																									# Pair input
																									self.assertRaises(
																									    SCREAMING_SNAKE_CASE__     , tokenizer_r.batch_encode_plus     , SCREAMING_SNAKE_CASE__     , max_length=SCREAMING_SNAKE_CASE__     , padding="""max_length"""     , )



				def 			__magic_name__					(self					)      ->	Optional[int]:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: int     =     self.get_rust_tokenizer()
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     load_dataset("""xnli"""     , """all_languages"""     , split="""test"""     , streaming=SCREAMING_SNAKE_CASE__					)

											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     next(iter(SCREAMING_SNAKE_CASE__					)					)["""premise"""]  # pick up one data
											SCREAMING_SNAKE_CASE__		: Optional[Any]     =     list(sample_data.values()					)

											SCREAMING_SNAKE_CASE__		: Dict     =     list(map(tokenizer.encode     , SCREAMING_SNAKE_CASE__					)					)
											SCREAMING_SNAKE_CASE__		: Any     =     [tokenizer.decode(SCREAMING_SNAKE_CASE__     , clean_up_tokenization_spaces=SCREAMING_SNAKE_CASE__					) for x in output_tokens]
											self.assertListEqual(SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self					)      ->	Optional[Any]:



											"""simple docstring"""




											self.assertGreaterEqual(len(self.tokenizer_class.pretrained_vocab_files_map					)     , 1					)
											self.assertGreaterEqual(len(list(self.tokenizer_class.pretrained_vocab_files_map.values()					)[0]					)     , 1					)






"""simple docstring"""




def lowercase_						(     _snake_case     ,_snake_case		):
							return int((input_a, input_a).count(1		) != 0		)

def lowercase_						(     ):
							assert or_gate(0     ,0		) == 0
							assert or_gate(0     ,1		) == 1
							assert or_gate(1     ,0		) == 1
							assert or_gate(1     ,1		) == 1


if __name__ == "__main__":
					print(or_gate(0, 1))
					print(or_gate(1, 0))
					print(or_gate(0, 0))
					print(or_gate(1, 1))




