





import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin



@custom_tokenizers
class 					__lowerCAmelCase       (			_UpperCAmelCase,     unittest.TestCase     ):
			lowerCamelCase_     :     str       			=      BertJapaneseTokenizer
			lowerCamelCase_     :     Dict       			=      False
			lowerCamelCase_     :     Any       			=      True






			def 			lowerCamelCase  (self    )     ->   Tuple:


							'''simple docstring'''



							super().setUp()

							snake_case_						:    int				=  [
							    '[UNK]',
							    '[CLS]',
							    '[SEP]',
							    'こんにちは',
							    'こん',
							    'にちは',
							    'ばんは',
							    '##こん',
							    '##にちは',
							    '##ばんは',
							    '世界',
							    '##世界',
							    '、',
							    '##、',
							    '。',
							    '##。',
							]

							snake_case_						:    Tuple				=  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]    )    )






			def 			lowerCamelCase  (self					,							__magic_name__    )     ->   Tuple:


							'''simple docstring'''



							snake_case_						:    List[str]				=  'こんにちは、世界。 \nこんばんは、世界。'
							snake_case_						:    Any				=  'こんにちは 、 世界 。 こんばんは 、 世界 。'
							return input_text, output_text






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


							'''simple docstring'''



							snake_case_						:    Any				=  self.get_input_output_texts(SCREAMING_SNAKE_CASE_    )
							snake_case_						:    List[Any]				=  tokenizer.encode(SCREAMING_SNAKE_CASE_					,							add_special_tokens=SCREAMING_SNAKE_CASE_    )
							snake_case_						:    Dict				=  tokenizer.decode(SCREAMING_SNAKE_CASE_					,							clean_up_tokenization_spaces=SCREAMING_SNAKE_CASE_    )
							return text, ids






			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							pass  # TODO add if relevant






			def 			lowerCamelCase  (self    )     ->   List[Any]:


							'''simple docstring'''



							pass  # TODO add if relevant






			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							pass  # TODO add if relevant






			def 			lowerCamelCase  (self    )     ->   Dict:


							'''simple docstring'''



							snake_case_						:    int				=  self.tokenizer_class(self.vocab_file    )

							snake_case_						:    Union[str, Any]				=  tokenizer.tokenize('''こんにちは、世界。\nこんばんは、世界。'''    )
							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
							self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )					,							[3, 12, 10, 14, 4, 9, 12, 10, 14]    )






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							snake_case_						:    int				=  self.tokenizer_class(self.vocab_file					,							word_tokenizer_type='''mecab'''    )
							self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )

							snake_case_						:    List[str]				=  'こんにちは、世界。\nこんばんは、世界。'
							snake_case_						:    Tuple				=  tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
							self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )					,							[3, 12, 10, 14, 4, 9, 12, 10, 14]    )

							snake_case_						:    Tuple				=  os.path.join(self.tmpdirname					,							'''tokenizer.bin'''    )
							with open(SCREAMING_SNAKE_CASE_					,							'''wb'''    ) as handle:
											pickle.dump(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )

							with open(SCREAMING_SNAKE_CASE_					,							'''rb'''    ) as handle:
											snake_case_						:    List[Any]				=  pickle.load(SCREAMING_SNAKE_CASE_    )

							snake_case_						:    List[str]				=  tokenizer_new.tokenize(SCREAMING_SNAKE_CASE_    )

							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )






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


							'''simple docstring'''



							snake_case_						:    Union[str, Any]				=  MecabTokenizer(mecab_dic='''ipadic'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップルストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。''']					,							)






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


							'''simple docstring'''



							try:
											snake_case_						:    Dict				=  MecabTokenizer(mecab_dic='''unidic_lite'''    )
							except ModuleNotFoundError:
											return

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。''']					,							)






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							try:
											snake_case_						:    List[Any]				=  MecabTokenizer(mecab_dic='''unidic'''    )
							except ModuleNotFoundError:
											return

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。''']					,							)






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							snake_case_						:    str				=  MecabTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_					,							mecab_dic='''ipadic'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップルストア''', '''で''', '''iphone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。''']					,							)






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							try:
											snake_case_						:    Any				=  MecabTokenizer(
											    do_lower_case=SCREAMING_SNAKE_CASE_					,							normalize_text=SCREAMING_SNAKE_CASE_					,							mecab_option='''-d /usr/local/lib/mecab/dic/jumandic'''    )
							except RuntimeError:
											# if dict doesn't exist in the system, previous code raises this error.
											return

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''ｱｯﾌﾟﾙストア''', '''で''', '''iPhone''', '''８''', '''が''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。''']					,							)






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


							'''simple docstring'''



							snake_case_						:    Optional[Any]				=  MecabTokenizer(normalize_text=SCREAMING_SNAKE_CASE_					,							mecab_dic='''ipadic'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''ｱｯﾌﾟﾙストア''', '''で''', '''iPhone''', '''８''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''　''', '''。''']					,							)






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   Tuple:


							'''simple docstring'''



							snake_case_						:    Any				=  self.tokenizer_class(self.vocab_file					,							word_tokenizer_type='''sudachi'''    )
							self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )

							snake_case_						:    Optional[int]				=  'こんにちは、世界。\nこんばんは、世界。'
							snake_case_						:    Optional[Any]				=  tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
							self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )					,							[3, 12, 10, 14, 4, 9, 12, 10, 14]    )

							snake_case_						:    Optional[int]				=  os.path.join(self.tmpdirname					,							'''tokenizer.bin'''    )
							with open(SCREAMING_SNAKE_CASE_					,							'''wb'''    ) as handle:
											pickle.dump(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )

							with open(SCREAMING_SNAKE_CASE_					,							'''rb'''    ) as handle:
											snake_case_						:    Dict				=  pickle.load(SCREAMING_SNAKE_CASE_    )

							snake_case_						:    Optional[int]				=  tokenizer_new.tokenize(SCREAMING_SNAKE_CASE_    )

							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							snake_case_						:    List[Any]				=  SudachiTokenizer(sudachi_dict_type='''core'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							[''' ''', '''\t''', '''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', ''' ''', '''。''', ''' ''', ''' ''']					,							)






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							snake_case_						:    Union[str, Any]				=  SudachiTokenizer(sudachi_dict_type='''core'''					,							sudachi_split_mode='''A'''    )

							self.assertListEqual(tokenizer.tokenize('''外国人参政権'''    )					,							['''外国''', '''人''', '''参政''', '''権''']    )






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							snake_case_						:    Any				=  SudachiTokenizer(sudachi_dict_type='''core'''					,							sudachi_split_mode='''B'''    )

							self.assertListEqual(tokenizer.tokenize('''外国人参政権'''    )					,							['''外国人''', '''参政権''']    )






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							snake_case_						:    List[Any]				=  SudachiTokenizer(sudachi_dict_type='''core'''					,							sudachi_split_mode='''C'''    )

							self.assertListEqual(tokenizer.tokenize('''外国人参政権'''    )					,							['''外国人参政権''']    )






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   Optional[Any]:


							'''simple docstring'''



							snake_case_						:    Optional[int]				=  SudachiTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_					,							sudachi_dict_type='''core'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							[''' ''', '''\t''', '''アップル''', '''ストア''', '''で''', '''iphone''', '''8''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', ''' ''', '''。''', ''' ''', ''' ''']					,							)






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   Optional[Any]:


							'''simple docstring'''



							snake_case_						:    str				=  SudachiTokenizer(normalize_text=SCREAMING_SNAKE_CASE_					,							sudachi_dict_type='''core'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							[''' ''', '''\t''', '''ｱｯﾌﾟﾙ''', '''ストア''', '''で''', '''iPhone''', '''８''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', '''\u3000''', '''。''', ''' ''', ''' ''']					,							)






			@require_sudachi
			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							snake_case_						:    Any				=  SudachiTokenizer(trim_whitespace=SCREAMING_SNAKE_CASE_					,							sudachi_dict_type='''core'''    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。''']					,							)






			@require_jumanpp
			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							snake_case_						:    Optional[int]				=  self.tokenizer_class(self.vocab_file					,							word_tokenizer_type='''jumanpp'''    )
							self.assertIsNotNone(SCREAMING_SNAKE_CASE_    )

							snake_case_						:    List[Any]				=  'こんにちは、世界。\nこんばんは、世界。'
							snake_case_						:    List[Any]				=  tokenizer.tokenize(SCREAMING_SNAKE_CASE_    )
							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']    )
							self.assertListEqual(tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )					,							[3, 12, 10, 14, 4, 9, 12, 10, 14]    )

							snake_case_						:    str				=  os.path.join(self.tmpdirname					,							'''tokenizer.bin'''    )
							with open(SCREAMING_SNAKE_CASE_					,							'''wb'''    ) as handle:
											pickle.dump(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )

							with open(SCREAMING_SNAKE_CASE_					,							'''rb'''    ) as handle:
											snake_case_						:    List[Any]				=  pickle.load(SCREAMING_SNAKE_CASE_    )

							snake_case_						:    Optional[int]				=  tokenizer_new.tokenize(SCREAMING_SNAKE_CASE_    )

							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )






			@require_jumanpp
			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							snake_case_						:    Dict				=  JumanppTokenizer()

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。''']					,							)






			@require_jumanpp
			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							snake_case_						:    str				=  JumanppTokenizer(do_lower_case=SCREAMING_SNAKE_CASE_    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップル''', '''ストア''', '''で''', '''iphone''', '''8''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。''']					,							)






			@require_jumanpp
			def 			lowerCamelCase  (self    )     ->   List[str]:


							'''simple docstring'''



							snake_case_						:    List[str]				=  JumanppTokenizer(normalize_text=SCREAMING_SNAKE_CASE_    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''ｱ''', '''ｯ''', '''ﾌ''', '''ﾟ''', '''ﾙ''', '''ストア''', '''で''', '''iPhone''', '''８''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。''']					,							)






			@require_jumanpp
			def 			lowerCamelCase  (self    )     ->   List[Any]:


							'''simple docstring'''



							snake_case_						:    Dict				=  JumanppTokenizer(trim_whitespace=SCREAMING_SNAKE_CASE_    )

							self.assertListEqual(
							    tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''    )					,							['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れた''', '''。''']					,							)






			@require_jumanpp
			def 			lowerCamelCase  (self    )     ->   Tuple:


							'''simple docstring'''



							snake_case_						:    Optional[Any]				=  JumanppTokenizer()

							self.assertListEqual(
							    tokenizer.tokenize('''ありがとうございますm(_ _)ｍ見つけるのが大変です。'''    )					,							['''ありがとう''', '''ございます''', '''m(_ _)m''', '''見つける''', '''の''', '''が''', '''大変です''', '''。''']					,							)






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    List[Any]				=  ['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは']

							snake_case_						:    Tuple				=  {}
							for i, token in enumerate(SCREAMING_SNAKE_CASE_    ):
											snake_case_						:    Optional[int]				=  i
							snake_case_						:    Optional[int]				=  WordpieceTokenizer(vocab=SCREAMING_SNAKE_CASE_					,							unk_token='''[UNK]'''    )

							self.assertListEqual(tokenizer.tokenize(''''''    )					,							[]    )

							self.assertListEqual(tokenizer.tokenize('''こんにちは'''    )					,							['''こんにちは''']    )

							self.assertListEqual(tokenizer.tokenize('''こんばんは'''    )					,							['''こん''', '''##ばんは''']    )

							self.assertListEqual(tokenizer.tokenize('''こんばんは こんばんにちは こんにちは'''    )					,							['''こん''', '''##ばんは''', '''[UNK]''', '''こんにちは''']    )






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    str				=  BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''    )
							snake_case_						:    Optional[Any]				=  tokenizer.subword_tokenizer

							snake_case_						:    List[str]				=  subword_tokenizer.tokenize('''国境 の 長い トンネル を 抜ける と 雪国 であった 。'''    )
							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							['''▁国境''', '''▁の''', '''▁長い''', '''▁トンネル''', '''▁を''', '''▁抜ける''', '''▁と''', '''▁雪''', '''国''', '''▁であった''', '''▁。''']    )

							snake_case_						:    str				=  subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''    )
							self.assertListEqual(SCREAMING_SNAKE_CASE_					,							['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']    )






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							snake_case_						:    Dict				=  self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''    )

							snake_case_						:    Dict				=  tokenizer.encode('''ありがとう。'''					,							add_special_tokens=SCREAMING_SNAKE_CASE_    )
							snake_case_						:    List[str]				=  tokenizer.encode('''どういたしまして。'''					,							add_special_tokens=SCREAMING_SNAKE_CASE_    )

							snake_case_						:    Union[str, Any]				=  tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_    )
							snake_case_						:    Any				=  tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )

							# 2 is for "[CLS]", 3 is for "[SEP]"
							assert encoded_sentence == [2] + text + [3]
							assert encoded_pair == [2] + text + [3] + text_a + [3]




@custom_tokenizers
class 					__lowerCAmelCase       (			_UpperCAmelCase,     unittest.TestCase     ):
			lowerCamelCase_     :     Optional[int]       			=      BertJapaneseTokenizer
			lowerCamelCase_     :     List[Any]       			=      False






			def 			lowerCamelCase  (self    )     ->   Dict:


							'''simple docstring'''



							super().setUp()

							snake_case_						:    List[Any]				=  ['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

							snake_case_						:    str				=  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]    )    )






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


							'''simple docstring'''



							return BertJapaneseTokenizer.from_pretrained(self.tmpdirname					,							subword_tokenizer_type='''character'''					,							**SCREAMING_SNAKE_CASE_    )






			def 			lowerCamelCase  (self					,							__magic_name__    )     ->   Dict:


							'''simple docstring'''



							snake_case_						:    Dict				=  'こんにちは、世界。 \nこんばんは、世界。'
							snake_case_						:    Tuple				=  'こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'
							return input_text, output_text






			def 			lowerCamelCase  (self    )     ->   Dict:


							'''simple docstring'''



							pass  # TODO add if relevant






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							pass  # TODO add if relevant






			def 			lowerCamelCase  (self    )     ->   int:


							'''simple docstring'''



							pass  # TODO add if relevant






			def 			lowerCamelCase  (self    )     ->   Any:


							'''simple docstring'''



							snake_case_						:    Any				=  self.tokenizer_class(self.vocab_file					,							subword_tokenizer_type='''character'''    )

							snake_case_						:    Tuple				=  tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。'''    )
							self.assertListEqual(
							    SCREAMING_SNAKE_CASE_					,							['''こ''', '''ん''', '''に''', '''ち''', '''は''', '''、''', '''世''', '''界''', '''。''', '''こ''', '''ん''', '''ば''', '''ん''', '''は''', '''、''', '''世''', '''界''', '''。''']    )
							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(SCREAMING_SNAKE_CASE_    )					,							[3, 4, 5, 6, 7, 11, 9, 10, 12, 3, 4, 8, 4, 7, 11, 9, 10, 12]    )






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


							'''simple docstring'''



							snake_case_						:    str				=  ['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

							snake_case_						:    Any				=  {}
							for i, token in enumerate(SCREAMING_SNAKE_CASE_    ):
											snake_case_						:    Optional[int]				=  i
							snake_case_						:    Any				=  CharacterTokenizer(vocab=SCREAMING_SNAKE_CASE_					,							unk_token='''[UNK]'''    )

							self.assertListEqual(tokenizer.tokenize(''''''    )					,							[]    )

							self.assertListEqual(tokenizer.tokenize('''こんにちは'''    )					,							['''こ''', '''ん''', '''に''', '''ち''', '''は''']    )

							self.assertListEqual(tokenizer.tokenize('''こんにちほ'''    )					,							['''こ''', '''ん''', '''に''', '''ち''', '''[UNK]''']    )






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							snake_case_						:    int				=  self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''    )

							snake_case_						:    int				=  tokenizer.encode('''ありがとう。'''					,							add_special_tokens=SCREAMING_SNAKE_CASE_    )
							snake_case_						:    str				=  tokenizer.encode('''どういたしまして。'''					,							add_special_tokens=SCREAMING_SNAKE_CASE_    )

							snake_case_						:    Optional[Any]				=  tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_    )
							snake_case_						:    Tuple				=  tokenizer.build_inputs_with_special_tokens(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )

							# 2 is for "[CLS]", 3 is for "[SEP]"
							assert encoded_sentence == [2] + text + [3]
							assert encoded_pair == [2] + text + [3] + text_a + [3]




@custom_tokenizers
class 					__lowerCAmelCase       (			unittest.TestCase     ):






			def 			lowerCamelCase  (self    )     ->   str:


							'''simple docstring'''



							snake_case_						:    List[str]				=  'cl-tohoku/bert-base-japanese'
							snake_case_						:    Tuple				=  AutoTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_    )
							self.assertIsInstance(SCREAMING_SNAKE_CASE_					,							SCREAMING_SNAKE_CASE_    )




class 					__lowerCAmelCase       (			unittest.TestCase     ):






			def 			lowerCamelCase  (self    )     ->   Union[str, Any]:


							'''simple docstring'''



							snake_case_						:    List[Any]				=  'cl-tohoku/bert-base-japanese'
							with self.assertLogs('''transformers'''					,							level='''WARNING'''    ) as cm:
											BertTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertTrue(
											    cm.records[0].message.startswith(
											        '''The tokenizer class you load from this checkpoint is not the same type as the class this function'''
											        ''' is called from.'''    )    )
							snake_case_						:    Tuple				=  'bert-base-cased'
							with self.assertLogs('''transformers'''					,							level='''WARNING'''    ) as cm:
											BertJapaneseTokenizer.from_pretrained(SCREAMING_SNAKE_CASE_    )
											self.assertTrue(
											    cm.records[0].message.startswith(
											        '''The tokenizer class you load from this checkpoint is not the same type as the class this function'''
											        ''' is called from.'''    )    )




'''simple docstring'''



import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()





class    UpperCAmelCase_  (_UpperCAmelCase					,		_UpperCAmelCase					,		unittest.TestCase  ):





    """simple docstring"""






    lowerCamelCase  :					Union[str, Any]							     =			VQModel
    lowerCamelCase  :					Union[str, Any]							     =			'sample'







    @property
    def       lowercase_				(							self			,     SCREAMING_SNAKE_CASE_=(32, 32)	)				->     Any:
         __lowerCamelCase   :	Tuple								=		4
         __lowerCamelCase   :	Union[str, Any]								=		3

         __lowerCamelCase   :	List[Any]								=		floats_tensor((batch_size, num_channels) + sizes	).to(SCREAMING_SNAKE_CASE_	)

         return {"sample": image}







    @property
    def       lowercase_				(							self	)				->     Optional[int]:
         return (3, 32, 32)







    @property
    def       lowercase_				(							self	)				->     List[Any]:
         return (3, 32, 32)







    def       lowercase_				(							self	)				->     Optional[int]:
         __lowerCamelCase   :	Optional[Any]								=		{
             'block_out_channels': [32, 64],
             'in_channels': 3,
             'out_channels': 3,
             'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
             'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
             'latent_channels': 3,
         }
         __lowerCamelCase   :	Union[str, Any]								=		self.dummy_input
         return init_dict, inputs_dict







    def       lowercase_				(							self	)				->     str:
         pass







    def       lowercase_				(							self	)				->     Optional[int]:
         pass







    def       lowercase_				(							self	)				->     Any:
         __lowerCamelCase				,       __lowerCamelCase   :	Union[str, Any]								=		VQModel.from_pretrained('fusing/vqgan-dummy'			,     output_loading_info=SCREAMING_SNAKE_CASE_	)
         self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)
         self.assertEqual(len(loading_info['missing_keys']	)			,     0	)

         model.to(SCREAMING_SNAKE_CASE_	)
         __lowerCamelCase   :	List[Any]								=		model(**self.dummy_input	)

         assert image is not None, "Make sure output is not None"







    def       lowercase_				(							self	)				->     int:
         __lowerCamelCase   :	List[Any]								=		VQModel.from_pretrained('fusing/vqgan-dummy'	)
         model.to(SCREAMING_SNAKE_CASE_	).eval()

         torch.manual_seed(0	)
         if torch.cuda.is_available():
              torch.cuda.manual_seed_all(0	)

         __lowerCamelCase   :	List[str]								=		torch.randn(1			,     model.config.in_channels			,     model.config.sample_size			,     model.config.sample_size	)
         __lowerCamelCase   :	Optional[int]								=		image.to(SCREAMING_SNAKE_CASE_	)
         with torch.no_grad():
              __lowerCamelCase   :	int								=		model(SCREAMING_SNAKE_CASE_	).sample

         __lowerCamelCase   :	List[str]								=		output[0, -1, -3:, -3:].flatten().cpu()
         # fmt: off
         __lowerCamelCase   :	Union[str, Any]								=		torch.tensor([-0.0_1_5_3, -0.4_0_4_4, -0.1_8_8_0, -0.5_1_6_1, -0.2_4_1_8, -0.4_0_7_2, -0.1_6_1_2, -0.0_6_3_3, -0.0_1_4_3]	)
         # fmt: on
         self.assertTrue(torch.allclose(SCREAMING_SNAKE_CASE_			,     SCREAMING_SNAKE_CASE_			,     atol=1E-3	)	)






