


import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, PerceiverTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
				lowerCAmelCase       		=    """pt"""
elif is_tf_available():
				lowerCAmelCase       		=    """tf"""
else:
				lowerCAmelCase       		=    """jax"""




class 							lowerCamelCase   (  _UpperCamelCase							,						unittest.TestCase ):
	_lowerCAmelCase     :		int										=						PerceiverTokenizer
	_lowerCAmelCase     :		List[Any]										=						False


	def  A(    self):
							super().setUp()
							__UpperCAmelCase			:							Optional[Any]	    =	PerceiverTokenizer()
							tokenizer.save_pretrained(self.tmpdirname)


	@cached_property
	def  A(    self):
							return PerceiverTokenizer.from_pretrained('''deepmind/language-perceiver''')


	def  A(    self				,     **lowercase__):
							return self.tokenizer_class.from_pretrained(self.tmpdirname				,     **lowercase__)


	def  A(    self				,     lowercase__				,     lowercase__=False				,     lowercase__=2_0				,     lowercase__=5):
							# XXX The default common tokenizer tests assume that every ID is decodable on its own.
							# This assumption is invalid for Perceiver because single bytes might not be
							# valid utf-8 (byte 128 for instance).
							# Here we're overriding the smallest possible method to provide
							# a clean sequence without making the same assumption.

							__UpperCAmelCase			:							Union[str, Any]	    =	[]
							for i in range(len(lowercase__)):
													try:
																			__UpperCAmelCase			:							Union[str, Any]	    =	tokenizer.decode([i]				,     clean_up_tokenization_spaces=lowercase__)
													except UnicodeDecodeError:
																			pass
													toks.append((i, tok))

							__UpperCAmelCase			:							List[Any]	    =	list(filter(lambda lowercase__: re.match(r'''^[ a-zA-Z]+$'''				,     t[1])				,     lowercase__))
							__UpperCAmelCase			:							Any	    =	list(filter(lambda lowercase__: [t[0]] == tokenizer.encode(t[1]				,     add_special_tokens=lowercase__)				,     lowercase__))
							if max_length is not None and len(lowercase__) > max_length:
													__UpperCAmelCase			:							str	    =	toks[:max_length]
							if min_length is not None and len(lowercase__) < min_length and len(lowercase__) > 0:
													while len(lowercase__) < min_length:
																			__UpperCAmelCase			:							Dict	    =	toks + toks
        # toks_str = [t[1] for t in toks]
							__UpperCAmelCase			:							Optional[Any]	    =	[t[0] for t in toks]

							# Ensure consistency
							__UpperCAmelCase			:							Any	    =	tokenizer.decode(lowercase__				,     clean_up_tokenization_spaces=lowercase__)
							if " " not in output_txt and len(lowercase__) > 1:
													__UpperCAmelCase			:							str	    =	(
													    tokenizer.decode([toks_ids[0]]				,     clean_up_tokenization_spaces=lowercase__)
													    + ''' '''
													    + tokenizer.decode(toks_ids[1:]				,     clean_up_tokenization_spaces=lowercase__)
													)
							if with_prefix_space:
													__UpperCAmelCase			:							List[Any]	    =	''' ''' + output_txt
							__UpperCAmelCase			:							Optional[int]	    =	tokenizer.encode(lowercase__				,     add_special_tokens=lowercase__)
							return output_txt, output_ids


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	self.perceiver_tokenizer
							__UpperCAmelCase			:							Dict	    =	'''Unicode €.'''
							__UpperCAmelCase			:							Tuple	    =	tokenizer(lowercase__)
							__UpperCAmelCase			:							str	    =	[4, 9_1, 1_1_6, 1_1_1, 1_0_5, 1_1_7, 1_0_6, 1_0_7, 3_8, 2_3_2, 1_3_6, 1_7_8, 5_2, 5]
							self.assertEqual(encoded['''input_ids''']				,     lowercase__)

							# decoding
							__UpperCAmelCase			:							str	    =	tokenizer.decode(lowercase__)
							self.assertEqual(lowercase__				,     '''[CLS]Unicode €.[SEP]''')

							__UpperCAmelCase			:							Optional[Any]	    =	tokenizer('''e è é ê ë''')
							__UpperCAmelCase			:							Tuple	    =	[4, 1_0_7, 3_8, 2_0_1, 1_7_4, 3_8, 2_0_1, 1_7_5, 3_8, 2_0_1, 1_7_6, 3_8, 2_0_1, 1_7_7, 5]
							self.assertEqual(encoded['''input_ids''']				,     lowercase__)
							# decoding
							__UpperCAmelCase			:							Optional[int]	    =	tokenizer.decode(lowercase__)
							self.assertEqual(lowercase__				,     '''[CLS]e è é ê ë[SEP]''')

							# encode/decode, but with `encode` instead of `__call__`
							self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë'''))				,     '''[CLS]e è é ê ë[SEP]''')


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	self.perceiver_tokenizer
							__UpperCAmelCase			:							List[Any]	    =	['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
							# fmt: off
							__UpperCAmelCase			:							Optional[Any]	    =	[4, 7_1, 3_8, 1_1_4, 1_1_7, 1_1_6, 1_0_9, 3_8, 1_1_8, 1_0_3, 1_2_0, 1_0_3, 1_0_9, 1_2_0, 1_0_3, 1_1_8, 1_1_0, 3_8, 1_0_8, 1_1_7, 1_2_0, 3_8, 1_2_1, 1_2_3, 1_1_5, 1_1_5, 1_0_3, 1_2_0, 1_1_1, 1_2_8, 1_0_3, 1_2_2, 1_1_1, 1_1_7, 1_1_6, 5_2, 5, 0]
							# fmt: on
							__UpperCAmelCase			:							List[str]	    =	tokenizer(lowercase__				,     padding=lowercase__				,     return_tensors=lowercase__)
							self.assertIsInstance(lowercase__				,     lowercase__)

							if FRAMEWORK != "jax":
													__UpperCAmelCase			:							List[str]	    =	list(batch.input_ids.numpy()[0])
							else:
													__UpperCAmelCase			:							Union[str, Any]	    =	list(batch.input_ids.tolist()[0])

							self.assertListEqual(lowercase__				,     lowercase__)

							self.assertEqual((2, 3_8)				,     batch.input_ids.shape)
							self.assertEqual((2, 3_8)				,     batch.attention_mask.shape)


	def  A(    self):
							__UpperCAmelCase			:							Union[str, Any]	    =	self.perceiver_tokenizer
							__UpperCAmelCase			:							List[str]	    =	['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
							__UpperCAmelCase			:							Dict	    =	tokenizer(lowercase__				,     padding=lowercase__				,     return_tensors=lowercase__)
							# check if input_ids are returned and no decoder_input_ids
							self.assertIn('''input_ids'''				,     lowercase__)
							self.assertIn('''attention_mask'''				,     lowercase__)
							self.assertNotIn('''decoder_input_ids'''				,     lowercase__)
							self.assertNotIn('''decoder_attention_mask'''				,     lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							Optional[int]	    =	self.perceiver_tokenizer
							__UpperCAmelCase			:							Dict	    =	[
							    '''Summary of the text.''',
							    '''Another summary.''',
							]
							__UpperCAmelCase			:							str	    =	tokenizer(
							    text_target=lowercase__				,     max_length=3_2				,     padding='''max_length'''				,     truncation=lowercase__				,     return_tensors=lowercase__)
							self.assertEqual(3_2				,     targets['''input_ids'''].shape[1])


	def  A(    self):
							# safety check on max_len default value so we are sure the test works
							__UpperCAmelCase			:							Optional[Any]	    =	self.get_tokenizers()
							for tokenizer in tokenizers:
													with self.subTest(F"{tokenizer.__class__.__name__}"):
																			self.assertNotEqual(tokenizer.model_max_length				,     4_2)

        # Now let's start the test
							__UpperCAmelCase			:							Union[str, Any]	    =	self.get_tokenizers()
							for tokenizer in tokenizers:
													with self.subTest(F"{tokenizer.__class__.__name__}"):
																			# Isolate this from the other tests because we save additional tokens/etc
																			__UpperCAmelCase			:							str	    =	tempfile.mkdtemp()

																			__UpperCAmelCase			:							List[Any]	    =	''' He is very happy, UNwant\u00E9d,running'''
																			__UpperCAmelCase			:							Union[str, Any]	    =	tokenizer.encode(lowercase__				,     add_special_tokens=lowercase__)
																			tokenizer.save_pretrained(lowercase__)

																			__UpperCAmelCase			:							List[Any]	    =	tokenizer.__class__.from_pretrained(lowercase__)
																			__UpperCAmelCase			:							Dict	    =	after_tokenizer.encode(lowercase__				,     add_special_tokens=lowercase__)
																			self.assertListEqual(lowercase__				,     lowercase__)

																			shutil.rmtree(lowercase__)

							__UpperCAmelCase			:							List[str]	    =	self.get_tokenizers(model_max_length=4_2)
							for tokenizer in tokenizers:
													with self.subTest(F"{tokenizer.__class__.__name__}"):
																			# Isolate this from the other tests because we save additional tokens/etc
																			__UpperCAmelCase			:							Union[str, Any]	    =	tempfile.mkdtemp()

																			__UpperCAmelCase			:							List[str]	    =	''' He is very happy, UNwant\u00E9d,running'''
																			tokenizer.add_tokens(['''bim''', '''bambam'''])
																			__UpperCAmelCase			:							Optional[Any]	    =	tokenizer.additional_special_tokens
																			additional_special_tokens.append('''new_additional_special_token''')
																			tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens})
																			__UpperCAmelCase			:							List[str]	    =	tokenizer.encode(lowercase__				,     add_special_tokens=lowercase__)
																			tokenizer.save_pretrained(lowercase__)

																			__UpperCAmelCase			:							Tuple	    =	tokenizer.__class__.from_pretrained(lowercase__)
																			__UpperCAmelCase			:							Dict	    =	after_tokenizer.encode(lowercase__				,     add_special_tokens=lowercase__)
																			self.assertListEqual(lowercase__				,     lowercase__)
																			self.assertIn('''new_additional_special_token'''				,     after_tokenizer.additional_special_tokens)
																			self.assertEqual(after_tokenizer.model_max_length				,     4_2)

																			__UpperCAmelCase			:							Any	    =	tokenizer.__class__.from_pretrained(lowercase__				,     model_max_length=4_3)
																			self.assertEqual(tokenizer.model_max_length				,     4_3)

																			shutil.rmtree(lowercase__)


	def  A(    self):
							__UpperCAmelCase			:							int	    =	[]
							if self.test_slow_tokenizer:
													tokenizer_list.append((self.tokenizer_class, self.get_tokenizer()))

							if self.test_rust_tokenizer:
													tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer()))

							for tokenizer_class, tokenizer_utils in tokenizer_list:
													with tempfile.TemporaryDirectory() as tmp_dir:
																			tokenizer_utils.save_pretrained(lowercase__)

																			with open(os.path.join(lowercase__				,     '''special_tokens_map.json''')				,     encoding='''utf-8''') as json_file:
																									__UpperCAmelCase			:							Optional[Any]	    =	json.load(lowercase__)

																			with open(os.path.join(lowercase__				,     '''tokenizer_config.json''')				,     encoding='''utf-8''') as json_file:
																									__UpperCAmelCase			:							Any	    =	json.load(lowercase__)

																			__UpperCAmelCase			:							Tuple	    =	[F"<extra_id_{i}>" for i in range(1_2_5)]

																			__UpperCAmelCase			:							str	    =	added_tokens_extra_ids + [
																			    '''an_additional_special_token'''
																			]
																			__UpperCAmelCase			:							Union[str, Any]	    =	added_tokens_extra_ids + [
																			    '''an_additional_special_token'''
																			]

																			with open(os.path.join(lowercase__				,     '''special_tokens_map.json''')				,     '''w'''				,     encoding='''utf-8''') as outfile:
																									json.dump(lowercase__				,     lowercase__)
																			with open(os.path.join(lowercase__				,     '''tokenizer_config.json''')				,     '''w'''				,     encoding='''utf-8''') as outfile:
																									json.dump(lowercase__				,     lowercase__)

																			# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
																			# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
																			# "special_tokens_map.json" files
																			__UpperCAmelCase			:							Optional[Any]	    =	tokenizer_class.from_pretrained(
																			    lowercase__				,     )
																			self.assertIn(
																			    '''an_additional_special_token'''				,     tokenizer_without_change_in_init.additional_special_tokens)
																			self.assertEqual(
																			    ['''an_additional_special_token''']				,     tokenizer_without_change_in_init.convert_ids_to_tokens(
																			        tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token''']))				,     )

																			# Now we test that we can change the value of additional_special_tokens in the from_pretrained
																			__UpperCAmelCase			:							Tuple	    =	added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token'''				,     lstrip=lowercase__)]
																			__UpperCAmelCase			:							List[str]	    =	tokenizer_class.from_pretrained(
																			    lowercase__				,     additional_special_tokens=lowercase__				,     )

																			self.assertIn('''a_new_additional_special_token'''				,     tokenizer.additional_special_tokens)
																			self.assertEqual(
																			    ['''a_new_additional_special_token''']				,     tokenizer.convert_ids_to_tokens(
																			        tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token''']))				,     )


	def  A(    self):
							__UpperCAmelCase			:							Tuple	    =	self.perceiver_tokenizer
							self.assertEqual(tokenizer.decode([1_7_8])				,     '''�''')


	def  A(    self):
							pass


	def  A(    self):
							pass


	def  A(    self):
							pass


	def  A(    self):
							pass


	def  A(    self):
							# The default common tokenizer tests uses invalid tokens for Perceiver that can only accept one-character
							# strings and special added tokens as tokens
							__UpperCAmelCase			:							str	    =	self.get_tokenizers(fast=lowercase__				,     do_lower_case=lowercase__)
							for tokenizer in tokenizers:
													with self.subTest(F"{tokenizer.__class__.__name__}"):
																			__UpperCAmelCase			:							int	    =	['''[CLS]''', '''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''s''', '''t''', '''[SEP]''']
																			__UpperCAmelCase			:							List[Any]	    =	tokenizer.convert_tokens_to_string(lowercase__)

																			self.assertIsInstance(lowercase__				,     lowercase__)





def     __SCREAMING_SNAKE_CASE							(       lowercase_      ,       lowercase_      )		->     int:




						'''simple docstring'''







						return 1 if input_a == input_a else 0




def     __SCREAMING_SNAKE_CASE							(       )		->     None:




						'''simple docstring'''







						assert xnor_gate(0      ,       0      ) == 1
						assert xnor_gate(0      ,       1      ) == 0
						assert xnor_gate(1      ,       0      ) == 0
						assert xnor_gate(1      ,       1      ) == 1


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

