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   _UpperCamelCase (		_UpperCAmelCase		,unittest.TestCase					):


			"""simple docstring"""






			__a    :					List[Any]     					=		BertJapaneseTokenizer
			__a    :					List[str]     					=		False
			__a    :					int     					=		True





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							super().setUp()

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

							__lowercase					     =				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 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				'''こんにちは、世界。 \nこんばんは、世界。'''
							__lowercase					     =				'''こんにちは 、 世界 。 こんばんは 、 世界 。'''
							return input_text, output_text





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__		)	->   str:

							'''simple docstring'''


							__lowercase     ,	__lowercase					     =				self.get_input_output_texts(lowerCAmelCase__		)
							__lowercase					     =				tokenizer.encode(lowerCAmelCase__ ,  add_special_tokens=lowerCAmelCase__		)
							__lowercase					     =				tokenizer.decode(lowerCAmelCase__ ,  clean_up_tokenization_spaces=lowerCAmelCase__		)
							return text, ids





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							pass  # TODO add if relevant





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

							'''simple docstring'''


							pass  # TODO add if relevant





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

							'''simple docstring'''


							pass  # TODO add if relevant





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				self.tokenizer_class(self.vocab_file		)

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				self.tokenizer_class(self.vocab_file ,  word_tokenizer_type='''mecab'''		)
							self.assertIsNotNone(lowerCAmelCase__		)

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

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

							with open(lowerCAmelCase__ ,  '''rb'''		) as handle:
											__lowercase					     =				pickle.load(lowerCAmelCase__		)

							__lowercase					     =				tokenizer_new.tokenize(lowerCAmelCase__		)

							self.assertListEqual(lowerCAmelCase__ ,  lowerCAmelCase__		)





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

							'''simple docstring'''


							__lowercase					     =				MecabTokenizer(mecab_dic='''ipadic'''		)

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


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

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





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

							'''simple docstring'''


							try:
											__lowercase					     =				MecabTokenizer(mecab_dic='''unidic'''		)
							except ModuleNotFoundError:
											return

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





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

							'''simple docstring'''


							__lowercase					     =				MecabTokenizer(do_lower_case=lowerCAmelCase__ ,  mecab_dic='''ipadic'''		)

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							try:
											__lowercase					     =				MecabTokenizer(
											    do_lower_case=lowerCAmelCase__ ,  normalize_text=lowerCAmelCase__ ,  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 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				MecabTokenizer(normalize_text=lowerCAmelCase__ ,  mecab_dic='''ipadic'''		)

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





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

							'''simple docstring'''


							__lowercase					     =				self.tokenizer_class(self.vocab_file ,  word_tokenizer_type='''sudachi'''		)
							self.assertIsNotNone(lowerCAmelCase__		)

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

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

							with open(lowerCAmelCase__ ,  '''rb'''		) as handle:
											__lowercase					     =				pickle.load(lowerCAmelCase__		)

							__lowercase					     =				tokenizer_new.tokenize(lowerCAmelCase__		)

							self.assertListEqual(lowerCAmelCase__ ,  lowerCAmelCase__		)





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

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(sudachi_dict_type='''core'''		)

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





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

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(sudachi_dict_type='''core''' ,  sudachi_split_mode='''A'''		)

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





			@require_sudachi
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(sudachi_dict_type='''core''' ,  sudachi_split_mode='''B'''		)

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





			@require_sudachi
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(sudachi_dict_type='''core''' ,  sudachi_split_mode='''C'''		)

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





			@require_sudachi
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(do_lower_case=lowerCAmelCase__ ,  sudachi_dict_type='''core'''		)

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





			@require_sudachi
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(normalize_text=lowerCAmelCase__ ,  sudachi_dict_type='''core'''		)

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





			@require_sudachi
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							__lowercase					     =				SudachiTokenizer(trim_whitespace=lowerCAmelCase__ ,  sudachi_dict_type='''core'''		)

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





			@require_jumanpp
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				self.tokenizer_class(self.vocab_file ,  word_tokenizer_type='''jumanpp'''		)
							self.assertIsNotNone(lowerCAmelCase__		)

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

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

							with open(lowerCAmelCase__ ,  '''rb'''		) as handle:
											__lowercase					     =				pickle.load(lowerCAmelCase__		)

							__lowercase					     =				tokenizer_new.tokenize(lowerCAmelCase__		)

							self.assertListEqual(lowerCAmelCase__ ,  lowerCAmelCase__		)





			@require_jumanpp
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				JumanppTokenizer()

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





			@require_jumanpp
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				JumanppTokenizer(do_lower_case=lowerCAmelCase__		)

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





			@require_jumanpp
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				JumanppTokenizer(normalize_text=lowerCAmelCase__		)

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





			@require_jumanpp
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				JumanppTokenizer(trim_whitespace=lowerCAmelCase__		)

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





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

							'''simple docstring'''


							__lowercase					     =				JumanppTokenizer()

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

							__lowercase					     =				{}
							for i, token in enumerate(lowerCAmelCase__		):
											__lowercase					     =				i
							__lowercase					     =				WordpieceTokenizer(vocab=lowerCAmelCase__ ,  unk_token='''[UNK]'''		)

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

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

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

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Dict:

							'''simple docstring'''


							__lowercase					     =				BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''		)
							__lowercase					     =				tokenizer.subword_tokenizer

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

							__lowercase					     =				subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''		)
							self.assertListEqual(lowerCAmelCase__ ,  ['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']		)





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


							__lowercase					     =				self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''		)

							__lowercase					     =				tokenizer.encode('''ありがとう。''' ,  add_special_tokens=lowerCAmelCase__		)
							__lowercase					     =				tokenizer.encode('''どういたしまして。''' ,  add_special_tokens=lowerCAmelCase__		)

							__lowercase					     =				tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__		)
							__lowercase					     =				tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__ ,  lowerCAmelCase__		)

							# 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   _UpperCamelCase (		_UpperCAmelCase		,unittest.TestCase					):


			"""simple docstring"""






			__a    :					List[str]     					=		BertJapaneseTokenizer
			__a    :					Union[str, Any]     					=		False





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							super().setUp()

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

							__lowercase					     =				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 			_SCREAMING_SNAKE_CASE     (  self ,  **lowerCAmelCase__		)	->   List[Any]:

							'''simple docstring'''


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





			def 			_SCREAMING_SNAKE_CASE     (  self ,  lowerCAmelCase__		)	->   int:

							'''simple docstring'''


							__lowercase					     =				'''こんにちは、世界。 \nこんばんは、世界。'''
							__lowercase					     =				'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
							return input_text, output_text





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

							'''simple docstring'''


							pass  # TODO add if relevant





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

							'''simple docstring'''


							pass  # TODO add if relevant





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


							pass  # TODO add if relevant





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

							'''simple docstring'''


							__lowercase					     =				self.tokenizer_class(self.vocab_file ,  subword_tokenizer_type='''character'''		)

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Tuple:

							'''simple docstring'''


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

							__lowercase					     =				{}
							for i, token in enumerate(lowerCAmelCase__		):
											__lowercase					     =				i
							__lowercase					     =				CharacterTokenizer(vocab=lowerCAmelCase__ ,  unk_token='''[UNK]'''		)

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

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

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





			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   Any:

							'''simple docstring'''


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

							__lowercase					     =				tokenizer.encode('''ありがとう。''' ,  add_special_tokens=lowerCAmelCase__		)
							__lowercase					     =				tokenizer.encode('''どういたしまして。''' ,  add_special_tokens=lowerCAmelCase__		)

							__lowercase					     =				tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__		)
							__lowercase					     =				tokenizer.build_inputs_with_special_tokens(lowerCAmelCase__ ,  lowerCAmelCase__		)

							# 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   _UpperCamelCase (		unittest.TestCase					):


			"""simple docstring"""






			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   str:

							'''simple docstring'''


							__lowercase					     =				'''cl-tohoku/bert-base-japanese'''
							__lowercase					     =				AutoTokenizer.from_pretrained(lowerCAmelCase__		)
							self.assertIsInstance(lowerCAmelCase__ ,  lowerCAmelCase__		)




class   _UpperCamelCase (		unittest.TestCase					):


			"""simple docstring"""






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

							'''simple docstring'''


							__lowercase					     =				'''cl-tohoku/bert-base-japanese'''
							with self.assertLogs('''transformers''' ,  level='''WARNING'''		) as cm:
											BertTokenizer.from_pretrained(lowerCAmelCase__		)
											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.'''		)		)
							__lowercase					     =				'''bert-base-cased'''
							with self.assertLogs('''transformers''' ,  level='''WARNING'''		) as cm:
											BertJapaneseTokenizer.from_pretrained(lowerCAmelCase__		)
											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.'''		)		)
from argparse import ArgumentParser

from .env import EnvironmentCommand





def 							UpperCAmelCase		(       ):







				"""simple docstring"""



				__lowercase					     =				ArgumentParser('''Diffusers CLI tool'''				,     usage='''diffusers-cli <command> [<args>]'''				)
				__lowercase					     =				parser.add_subparsers(help='''diffusers-cli command helpers'''				)

				# Register commands
				EnvironmentCommand.register_subcommand(lowercase				)

				# Let's go
				__lowercase					     =				parser.parse_args()

				if not hasattr(lowercase				,     '''func'''				):
								parser.print_help()
								exit(1				)

				# Run
				__lowercase					     =				args.func(lowercase				)
				service.run()


if __name__ == "__main__":
		main()