




'''simple docstring'''



import os
import unittest

from transformers.models.cpmant.tokenization_cpmant import VOCAB_FILES_NAMES, CpmAntTokenizer
from transformers.testing_utils import require_jieba, tooslow

from ...test_tokenization_common import TokenizerTesterMixin






@require_jieba
class 							_a				(			SCREAMING_SNAKE_CASE ,      unittest.TestCase ):





       '''simple docstring'''






       A						:				Optional[int]        =						CpmAntTokenizer
       A						:				Dict        =						False







       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             super().setUp()

             SCREAMING_SNAKE_CASE   :      List[str]    					=						[
                 '<d>',
                 '</d>',
                 '<s>',
                 '</s>',
                 '</_>',
                 '<unk>',
                 '<pad>',
                 '</n>',
                 '我',
                 '是',
                 'C',
                 'P',
                 'M',
                 'A',
                 'n',
                 't',
             ]
             SCREAMING_SNAKE_CASE   :      Any    					=						os.path.join(self.tmpdirname,							VOCAB_FILES_NAMES['vocab_file']  )
             with open(self.vocab_file,							'w',							encoding='utf-8'  ) as vocab_writer:
                   vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]  )  )







       @tooslow
       def        UpperCamelCase_							(      self  ):







             '''simple docstring'''







             SCREAMING_SNAKE_CASE   :      Any    					=						CpmAntTokenizer.from_pretrained('openbmb/cpm-ant-10b'  )
             SCREAMING_SNAKE_CASE   :      Tuple    					=						'今天天气真好！'
             SCREAMING_SNAKE_CASE   :      Tuple    					=						['今天', '天气', '真', '好', '！']
             SCREAMING_SNAKE_CASE   :      List[str]    					=						tokenizer.tokenize(A  )
             self.assertListEqual(A,							A  )
             SCREAMING_SNAKE_CASE   :      int    					=						'今天天气真好！'
             SCREAMING_SNAKE_CASE   :      Dict    					=						[tokenizer.bos_token] + tokens

             SCREAMING_SNAKE_CASE   :      List[Any]    					=						[6, 9_802, 14_962, 2_082, 831, 244]
             self.assertListEqual(tokenizer.convert_tokens_to_ids(A  ),							A  )

             SCREAMING_SNAKE_CASE   :      List[str]    					=						tokenizer.decode(A  )
             self.assertEqual(A,							A  )






"""simple docstring"""
from collections import defaultdict

def 				_snake_case      (   __snake_case							:      str						, __snake_case							:      str   ):




   """simple docstring"""







   _lowerCamelCase	:					Tuple   =		first_str.lower().strip()
   _lowerCamelCase	:					int   =		second_str.lower().strip()

   # Remove whitespace
   _lowerCamelCase	:					Any   =		first_str.replace(""" """						, """"""   )
   _lowerCamelCase	:					List[str]   =		second_str.replace(""" """						, """"""   )

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

   # Default values for count should be 0
   _lowerCamelCase	:					defaultdict[str, int]   =		defaultdict(__snake_case   )

   # For each character in input strings,
   # increment count in the corresponding
   for i in range(len(__snake_case   )   ):
      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()
 UpperCAmelCase				=						input("""Enter the first string """).strip()
 UpperCAmelCase				=						input("""Enter the second string """).strip()

 UpperCAmelCase				=						check_anagrams(input_a, input_b)
 print(f'''{input_a} and {input_b} are {"" if status else "not "}anagrams.''')

