import json
import os
import unittest

from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin


class 						a__							(       __snake_case				,						unittest.TestCase		):
			A__    :       Any        =      DebertaTokenizer
			A__    :       Union[str, Any]        =      True
			A__    :       str        =      DebertaTokenizerFast



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Any:
								super().setUp()

								# Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
								__a		 =       [
								    'l',
								    'o',
								    'w',
								    'e',
								    'r',
								    's',
								    't',
								    'i',
								    'd',
								    'n',
								    '\u0120',
								    '\u0120l',
								    '\u0120n',
								    '\u0120lo',
								    '\u0120low',
								    'er',
								    '\u0120lowest',
								    '\u0120newer',
								    '\u0120wider',
								    '[UNK]',
								]
								__a		 =       dict(zip(UpperCAmelCase				,						range(len(UpperCAmelCase   )   )   )   )
								__a		 =       ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
								__a		 =       {'unk_token': '[UNK]'}

								__a		 =       os.path.join(self.tmpdirname				,						VOCAB_FILES_NAMES['vocab_file']   )
								__a		 =       os.path.join(self.tmpdirname				,						VOCAB_FILES_NAMES['merges_file']   )
								with open(self.vocab_file				,						'w'				,						encoding='utf-8'   ) as fp:
													fp.write(json.dumps(UpperCAmelCase   ) + '\n'   )
								with open(self.merges_file				,						'w'				,						encoding='utf-8'   ) as fp:
													fp.write('\n'.join(UpperCAmelCase   )   )



			def __SCREAMING_SNAKE_CASE							(						self				,						**UpperCAmelCase   )			->   List[Any]:
								kwargs.update(self.special_tokens_map   )
								return self.tokenizer_class.from_pretrained(self.tmpdirname				,						**UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase   )			->   Tuple:
								__a		 =       'lower newer'
								__a		 =       'lower newer'
								return input_text, output_text



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[int]:
								__a		 =       self.get_tokenizer()
								__a		 =       'lower newer'
								__a		 =       ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
								__a		 =       tokenizer.tokenize(UpperCAmelCase   )
								self.assertListEqual(UpperCAmelCase				,						UpperCAmelCase   )

								__a		 =       tokens + [tokenizer.unk_token]
								__a		 =       [0, 1, 2, 1_5, 1_0, 9, 3, 2, 1_5, 1_9]
								self.assertListEqual(tokenizer.convert_tokens_to_ids(UpperCAmelCase   )				,						UpperCAmelCase   )



			def __SCREAMING_SNAKE_CASE							(						self   )			->   int:
								__a		 =       self.get_tokenizer()
								__a		 =       tokenizer('Hello'				,						'World'   )
								__a		 =       [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
								self.assertListEqual(tokd['token_type_ids']				,						UpperCAmelCase   )



			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								__a		 =       self.tokenizer_class.from_pretrained('microsoft/deberta-base'   )

								__a		 =       tokenizer.encode('sequence builders'				,						add_special_tokens=UpperCAmelCase   )
								__a		 =       tokenizer.encode('multi-sequence build'				,						add_special_tokens=UpperCAmelCase   )

								__a		 =       tokenizer.encode(
								    'sequence builders'				,						add_special_tokens=UpperCAmelCase				,						add_prefix_space=UpperCAmelCase   )
								__a		 =       tokenizer.encode(
								    'sequence builders'				,						'multi-sequence build'				,						add_special_tokens=UpperCAmelCase				,						add_prefix_space=UpperCAmelCase   )

								__a		 =       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase   )
								__a		 =       tokenizer.build_inputs_with_special_tokens(UpperCAmelCase				,						UpperCAmelCase   )

								assert encoded_sentence == encoded_text_from_decode
								assert encoded_pair == encoded_pair_from_decode







			@slow
			def __SCREAMING_SNAKE_CASE							(						self   )			->   Tuple:
								__a		 =       [self.tokenizer_class]
								if self.test_rust_tokenizer:
													tokenizer_classes.append(self.rust_tokenizer_class   )

								for tokenizer_class in tokenizer_classes:
													__a		 =       tokenizer_class.from_pretrained('microsoft/deberta-base'   )

													__a		 =       [
													    'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
													    'ALBERT incorporates two parameter reduction techniques',
													    'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
													    ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
													    ' vocabulary embedding.',
													]

													__a		 =       tokenizer(UpperCAmelCase				,						padding=UpperCAmelCase   )
													__a		 =       [tokenizer.decode(UpperCAmelCase				,						skip_special_tokens=UpperCAmelCase   ) for seq in encoding['input_ids']]

													# fmt: off
													__a		 =       {
													    'input_ids': [
													        [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 3_5, 8_3, 2_5_1_9_1, 1_6_3, 1_8_8_5_4, 1_3, 1_2_1_5_6, 1_2, 1_6_1_0_1, 2_5_3_7_6, 1_3_8_0_7, 9, 2_2_2_0_5, 2_7_8_9_3, 1_6_3_5, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
													        [1, 2_1_1_8, 1_1_1_2_6, 5_6_5, 2_4_5_3_6, 8_0, 4_3_7_9_7, 4_8_7_8, 7_3_7_3, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
													        [1, 1_3_3, 7_8, 6_5, 1_6, 1_0, 3_7_2_4, 1_5_3_8, 3_3_1_8_3, 1_1_3_0_3, 4_3_7_9_7, 1_9_3_8, 4, 8_7_0, 2_4_1_6_5, 2_9_1_0_5, 5, 7_3_9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 3_6_1_7_3, 8_8, 8_0, 6_5_0, 7_8_2_1, 4_5_9_4_0, 6, 5_2, 2_5_5_9, 5, 1_8_3_6, 9, 5, 7_3_9_7, 1_3_1_7_1, 3_1, 5, 1_8_3_6, 9, 3_2_6_4_4, 3_3_1_8_3, 1_1_3_0_3, 4, 2]
													    ],
													    'token_type_ids': [
													        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
													        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
													        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
													    ],
													    'attention_mask': [
													        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
													        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
													        [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
													    ]
													}
													# fmt: on

													__a		 =       [
													    'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
													    'ALBERT incorporates two parameter reduction techniques',
													    'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
													    ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
													    ' vocabulary embedding.',
													]

													self.assertDictEqual(encoding.data				,						UpperCAmelCase   )

													for expected, decoded in zip(UpperCAmelCase				,						UpperCAmelCase   ):
																		self.assertEqual(UpperCAmelCase				,						UpperCAmelCase   )





from collections import defaultdict
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase						):
					__a		 =       first_str.lower().strip()
					__a		 =       second_str.lower().strip()

					# Remove whitespace
					__a		 =       first_str.replace(' '				,    ''						)
					__a		 =       second_str.replace(' '				,    ''						)

					# Strings of different lengths are not anagrams
					if len(__lowerCamelCase						) != len(__lowerCamelCase						):
										return False

					# Default values for count should be 0
					__a		 =       defaultdict(__lowerCamelCase						)

					# For each character in input strings,
					# increment count in the corresponding
					for i in range(len(__lowerCamelCase						)						):
										count[first_str[i]] += 1
										count[second_str[i]] -= 1

					return all(_count == 0 for _count in count.values()						)


if __name__ == "__main__":
	from doctest import testmod

	testmod()
	lowerCamelCase_    :		List[str]							=	input("""Enter the first string """).strip()
	lowerCamelCase_    :		Optional[Any]							=	input("""Enter the second string """).strip()

	lowerCamelCase_    :		str							=	check_anagrams(input_a, input_b)
	print(F'''{input_a} and {input_b} are {'' if status else 'not '}anagrams.''')




