



"""simple docstring"""







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        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					int   	=				BertJapaneseTokenizer
		lowerCAmelCase			:					Dict   	=				False
		lowerCAmelCase			:					str   	=				True







		def 					UpperCAmelCase    (	self						:  str						)					->		str:






				"""simple docstring"""



				super().setUp()

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

				lowercase__   :    Dict				=			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 					UpperCAmelCase    (	self						:  Optional[Any]			,_snake_case						:  Dict						)					->		str:






				"""simple docstring"""



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







		def 					UpperCAmelCase    (	self						:  Optional[int]			,_snake_case						:  str						)					->		Any:






				"""simple docstring"""



				lowercase__		,			lowercase__   :    List[Any]				=			self.get_input_output_texts(_snake_case						)
				lowercase__   :    int				=			tokenizer.encode(_snake_case			,add_special_tokens=_snake_case						)
				lowercase__   :    Optional[Any]				=			tokenizer.decode(_snake_case			,clean_up_tokenization_spaces=_snake_case						)
				return text, ids







		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		int:






				"""simple docstring"""



				pass  # TODO add if relevant







		def 					UpperCAmelCase    (	self						:  Dict						)					->		str:






				"""simple docstring"""



				pass  # TODO add if relevant







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		List[str]:






				"""simple docstring"""



				pass  # TODO add if relevant







		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Tuple				=			self.tokenizer_class(self.vocab_file						)

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







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






				"""simple docstring"""



				lowercase__   :    List[str]				=			self.tokenizer_class(self.vocab_file			,word_tokenizer_type='''mecab'''						)
				self.assertIsNotNone(_snake_case						)

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

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

				with open(_snake_case			,'''rb'''						) as handle:
						lowercase__   :    int				=			pickle.load(_snake_case						)

				lowercase__   :    Optional[Any]				=			tokenizer_new.tokenize(_snake_case						)

				self.assertListEqual(_snake_case			,_snake_case						)







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






				"""simple docstring"""



				lowercase__   :    Tuple				=			MecabTokenizer(mecab_dic='''ipadic'''						)

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







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Tuple:






				"""simple docstring"""



				try:
						lowercase__   :    Optional[Any]				=			MecabTokenizer(mecab_dic='''unidic_lite'''						)
				except ModuleNotFoundError:
						return

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







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



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

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







		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__   :    int				=			MecabTokenizer(do_lower_case=_snake_case			,mecab_dic='''ipadic'''						)

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







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






				"""simple docstring"""



				try:
						lowercase__   :    Tuple				=			MecabTokenizer(
						    do_lower_case=_snake_case			,normalize_text=_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 					UpperCAmelCase    (	self						:  List[str]						)					->		int:






				"""simple docstring"""



				lowercase__   :    str				=			MecabTokenizer(normalize_text=_snake_case			,mecab_dic='''ipadic'''						)

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







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






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			self.tokenizer_class(self.vocab_file			,word_tokenizer_type='''sudachi'''						)
				self.assertIsNotNone(_snake_case						)

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

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

				with open(_snake_case			,'''rb'''						) as handle:
						lowercase__   :    Optional[int]				=			pickle.load(_snake_case						)

				lowercase__   :    Dict				=			tokenizer_new.tokenize(_snake_case						)

				self.assertListEqual(_snake_case			,_snake_case						)







		@require_sudachi
		def 					UpperCAmelCase    (	self						:  str						)					->		str:






				"""simple docstring"""



				lowercase__   :    int				=			SudachiTokenizer(sudachi_dict_type='''core'''						)

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







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






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			SudachiTokenizer(sudachi_dict_type='''core'''			,sudachi_split_mode='''A'''						)

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







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






				"""simple docstring"""



				lowercase__   :    int				=			SudachiTokenizer(sudachi_dict_type='''core'''			,sudachi_split_mode='''B'''						)

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







		@require_sudachi
		def 					UpperCAmelCase    (	self						:  str						)					->		int:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			SudachiTokenizer(sudachi_dict_type='''core'''			,sudachi_split_mode='''C'''						)

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







		@require_sudachi
		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__   :    Dict				=			SudachiTokenizer(do_lower_case=_snake_case			,sudachi_dict_type='''core'''						)

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







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






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			SudachiTokenizer(normalize_text=_snake_case			,sudachi_dict_type='''core'''						)

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







		@require_sudachi
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			SudachiTokenizer(trim_whitespace=_snake_case			,sudachi_dict_type='''core'''						)

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







		@require_jumanpp
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		str:






				"""simple docstring"""



				lowercase__   :    str				=			self.tokenizer_class(self.vocab_file			,word_tokenizer_type='''jumanpp'''						)
				self.assertIsNotNone(_snake_case						)

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

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

				with open(_snake_case			,'''rb'''						) as handle:
						lowercase__   :    Optional[int]				=			pickle.load(_snake_case						)

				lowercase__   :    Tuple				=			tokenizer_new.tokenize(_snake_case						)

				self.assertListEqual(_snake_case			,_snake_case						)







		@require_jumanpp
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    List[str]				=			JumanppTokenizer()

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







		@require_jumanpp
		def 					UpperCAmelCase    (	self						:  Any						)					->		Any:






				"""simple docstring"""



				lowercase__   :    List[str]				=			JumanppTokenizer(do_lower_case=_snake_case						)

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







		@require_jumanpp
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Any				=			JumanppTokenizer(normalize_text=_snake_case						)

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







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






				"""simple docstring"""



				lowercase__   :    int				=			JumanppTokenizer(trim_whitespace=_snake_case						)

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







		@require_jumanpp
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Optional[int]:






				"""simple docstring"""



				lowercase__   :    int				=			JumanppTokenizer()

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







		def 					UpperCAmelCase    (	self						:  int						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

				lowercase__   :    Dict				=			{}
				for i, token in enumerate(_snake_case						):
						lowercase__   :    Any				=			i
				lowercase__   :    Any				=			WordpieceTokenizer(vocab=_snake_case			,unk_token='''[UNK]'''						)

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

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

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

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







		def 					UpperCAmelCase    (	self						:  List[str]						)					->		List[Any]:






				"""simple docstring"""



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

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

				lowercase__   :    List[Any]				=			subword_tokenizer.tokenize('''こんばんは こんばん にち は こんにちは'''						)
				self.assertListEqual(_snake_case			,['''▁こん''', '''ばん''', '''は''', '''▁こん''', '''ばん''', '''▁に''', '''ち''', '''▁は''', '''▁こんにちは''']						)







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






				"""simple docstring"""



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

				lowercase__   :    List[Any]				=			tokenizer.encode('''ありがとう。'''			,add_special_tokens=_snake_case						)
				lowercase__   :    Optional[Any]				=			tokenizer.encode('''どういたしまして。'''			,add_special_tokens=_snake_case						)

				lowercase__   :    List[Any]				=			tokenizer.build_inputs_with_special_tokens(_snake_case						)
				lowercase__   :    str				=			tokenizer.build_inputs_with_special_tokens(_snake_case			,_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        __A       (	A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[Any]   	=				BertJapaneseTokenizer
		lowerCAmelCase			:					Tuple   	=				False







		def 					UpperCAmelCase    (	self						:  str						)					->		Tuple:






				"""simple docstring"""



				super().setUp()

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

				lowercase__   :    List[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]						)						)







		def 					UpperCAmelCase    (	self						:  Optional[Any]			,**_snake_case						:  int						)					->		Optional[Any]:






				"""simple docstring"""



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







		def 					UpperCAmelCase    (	self						:  Any			,_snake_case						:  List[Any]						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    Union[str, Any]				=			'''こんにちは、世界。 \nこんばんは、世界。'''
				lowercase__   :    Optional[int]				=			'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
				return input_text, output_text







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






				"""simple docstring"""



				pass  # TODO add if relevant







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Dict:






				"""simple docstring"""



				pass  # TODO add if relevant







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		Optional[int]:






				"""simple docstring"""



				pass  # TODO add if relevant







		def 					UpperCAmelCase    (	self						:  Any						)					->		str:






				"""simple docstring"""



				lowercase__   :    int				=			self.tokenizer_class(self.vocab_file			,subword_tokenizer_type='''character'''						)

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







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






				"""simple docstring"""



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

				lowercase__   :    Optional[Any]				=			{}
				for i, token in enumerate(_snake_case						):
						lowercase__   :    List[str]				=			i
				lowercase__   :    Optional[Any]				=			CharacterTokenizer(vocab=_snake_case			,unk_token='''[UNK]'''						)

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

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

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







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



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

				lowercase__   :    Dict				=			tokenizer.encode('''ありがとう。'''			,add_special_tokens=_snake_case						)
				lowercase__   :    Union[str, Any]				=			tokenizer.encode('''どういたしまして。'''			,add_special_tokens=_snake_case						)

				lowercase__   :    str				=			tokenizer.build_inputs_with_special_tokens(_snake_case						)
				lowercase__   :    Optional[int]				=			tokenizer.build_inputs_with_special_tokens(_snake_case			,_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        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		def 					UpperCAmelCase    (	self						:  Any						)					->		List[str]:






				"""simple docstring"""



				lowercase__   :    Dict				=			'''cl-tohoku/bert-base-japanese'''
				lowercase__   :    List[str]				=			AutoTokenizer.from_pretrained(_snake_case						)
				self.assertIsInstance(_snake_case			,_snake_case						)





class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		def 					UpperCAmelCase    (	self						:  List[str]						)					->		int:






				"""simple docstring"""



				lowercase__   :    List[str]				=			'''cl-tohoku/bert-base-japanese'''
				with self.assertLogs('''transformers'''			,level='''WARNING'''						) as cm:
						BertTokenizer.from_pretrained(_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.'''						)						)
				lowercase__   :    List[str]				=			'''bert-base-cased'''
				with self.assertLogs('''transformers'''			,level='''WARNING'''						) as cm:
						BertJapaneseTokenizer.from_pretrained(_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"""







from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
							import tensorflow as tf

							from transformers import TFResNetForImageClassification, TFResNetModel
							from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor
class        __A       :







		'''simple docstring'''





		def __init__(	self						:  str			,_snake_case						:  List[Any]			,_snake_case						:  Optional[int]=3			,_snake_case						:  Optional[int]=32			,_snake_case						:  Union[str, Any]=3			,_snake_case						:  int=10			,_snake_case						:  List[str]=[10, 20, 30, 40]			,_snake_case						:  Any=[1, 1, 2, 1]			,_snake_case						:  int=True			,_snake_case						:  Optional[Any]=True			,_snake_case						:  Union[str, Any]="relu"			,_snake_case						:  Dict=3			,_snake_case						:  Any=None			,)					->		str:






				"""simple docstring"""



				lowercase__   :    int				=			parent
				lowercase__   :    Optional[Any]				=			batch_size
				lowercase__   :    Optional[Any]				=			image_size
				lowercase__   :    Optional[Any]				=			num_channels
				lowercase__   :    Optional[Any]				=			embeddings_size
				lowercase__   :    Optional[Any]				=			hidden_sizes
				lowercase__   :    str				=			depths
				lowercase__   :    Tuple				=			is_training
				lowercase__   :    List[Any]				=			use_labels
				lowercase__   :    Union[str, Any]				=			hidden_act
				lowercase__   :    Union[str, Any]				=			num_labels
				lowercase__   :    Tuple				=			scope
				lowercase__   :    Optional[Any]				=			len(_snake_case						)







		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    List[Any]				=			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

				lowercase__   :    Tuple				=			None
				if self.use_labels:
						lowercase__   :    Dict				=			ids_tensor([self.batch_size]			,self.num_labels						)

				lowercase__   :    int				=			self.get_config()

				return config, pixel_values, labels







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				return ResNetConfig(
				    num_channels=self.num_channels			,embeddings_size=self.embeddings_size			,hidden_sizes=self.hidden_sizes			,depths=self.depths			,hidden_act=self.hidden_act			,num_labels=self.num_labels			,image_size=self.image_size			,)







		def 					UpperCAmelCase    (	self						:  List[str]			,_snake_case						:  Optional[int]			,_snake_case						:  int			,_snake_case						:  Tuple						)					->		List[Any]:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			TFResNetModel(config=_snake_case						)
				lowercase__   :    List[str]				=			model(_snake_case						)
				# expected last hidden states: B, C, H // 32, W // 32
				self.parent.assertEqual(
				    result.last_hidden_state.shape			,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)			,)







		def 					UpperCAmelCase    (	self						:  Optional[int]			,_snake_case						:  Optional[Any]			,_snake_case						:  int			,_snake_case						:  Any						)					->		Tuple:






				"""simple docstring"""



				lowercase__   :    Tuple				=			self.num_labels
				lowercase__   :    Union[str, Any]				=			TFResNetForImageClassification(_snake_case						)
				lowercase__   :    List[str]				=			model(_snake_case			,labels=_snake_case						)
				self.parent.assertEqual(result.logits.shape			,(self.batch_size, self.num_labels)						)







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		str:






				"""simple docstring"""



				lowercase__   :    Dict				=			self.prepare_config_and_inputs()
				lowercase__		,			lowercase__		,			lowercase__   :    Union[str, Any]				=			config_and_inputs
				lowercase__   :    Dict				=			{'''pixel_values''': pixel_values}
				return config, inputs_dict





@require_tf
class        __A       (	A_     ,A_     ,unittest.TestCase    ):







		'''simple docstring'''





		lowerCAmelCase			:					Optional[int]   	=				(TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
		lowerCAmelCase			:					Any   	=				(
		    {"feature-extraction": TFResNetModel, "image-classification": TFResNetForImageClassification}
		    if is_tf_available()
		    else {}
		)

		lowerCAmelCase			:					List[Any]   	=				False
		lowerCAmelCase			:					List[Any]   	=				False
		lowerCAmelCase			:					int   	=				False
		lowerCAmelCase			:					Union[str, Any]   	=				False
		lowerCAmelCase			:					List[str]   	=				False







		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Union[str, Any]:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			TFResNetModelTester(self						)
				lowercase__   :    int				=			ConfigTester(self			,config_class=_snake_case			,has_text_modality=_snake_case						)







		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		str:






				"""simple docstring"""



				self.create_and_test_config_common_properties()
				self.config_tester.create_and_test_config_to_json_string()
				self.config_tester.create_and_test_config_to_json_file()
				self.config_tester.create_and_test_config_from_and_save_pretrained()
				self.config_tester.create_and_test_config_with_num_labels()
				self.config_tester.check_config_can_be_init_without_params()
				self.config_tester.check_config_arguments_init()







		def 					UpperCAmelCase    (	self						:  List[Any]						)					->		List[str]:






				"""simple docstring"""



				return







		@unittest.skip(reason='''ResNet does not use inputs_embeds'''						)
		def 					UpperCAmelCase    (	self						:  Optional[int]						)					->		Dict:






				"""simple docstring"""



				pass







		@unittest.skip(reason='''ResNet does not support input and output embeddings'''						)
		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Optional[Any]:






				"""simple docstring"""



				pass







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






				"""simple docstring"""



				lowercase__		,			lowercase__   :    Dict				=			self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
						lowercase__   :    str				=			model_class(_snake_case						)
						lowercase__   :    Dict				=			inspect.signature(model.call						)
						# signature.parameters is an OrderedDict => so arg_names order is deterministic
						lowercase__   :    Optional[int]				=			[*signature.parameters.keys()]

						lowercase__   :    Any				=			['''pixel_values''']
						self.assertListEqual(arg_names[:1]			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Tuple						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[int]				=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*_snake_case						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		List[str]:






				"""simple docstring"""



				def check_hidden_states_output(_snake_case						:  Optional[int]			,_snake_case						:  List[str]			,_snake_case						:  Optional[Any]						):
						lowercase__   :    str				=			model_class(_snake_case						)
						lowercase__   :    Union[str, Any]				=			model(**self._prepare_for_class(_snake_case			,_snake_case						)						)

						lowercase__   :    List[Any]				=			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

						lowercase__   :    Tuple				=			self.model_tester.num_stages
						self.assertEqual(len(_snake_case						)			,expected_num_stages + 1						)

						# ResNet's feature maps are of shape (batch_size, num_channels, height, width)
						self.assertListEqual(
						    list(hidden_states[0].shape[-2:]						)			,[self.model_tester.image_size // 4, self.model_tester.image_size // 4]			,)

				lowercase__		,			lowercase__   :    int				=			self.model_tester.prepare_config_and_inputs_for_common()
				lowercase__   :    List[Any]				=			['''basic''', '''bottleneck''']
				for model_class in self.all_model_classes:
						for layer_type in layers_type:
								lowercase__   :    List[Any]				=			layer_type
								lowercase__   :    Dict				=			True
								check_hidden_states_output(_snake_case			,_snake_case			,_snake_case						)

								# check that output_hidden_states also work using config
								del inputs_dict["output_hidden_states"]
								lowercase__   :    Dict				=			True

								check_hidden_states_output(_snake_case			,_snake_case			,_snake_case						)







		def 					UpperCAmelCase    (	self						:  Dict						)					->		Any:






				"""simple docstring"""



				lowercase__   :    Optional[Any]				=			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*_snake_case						)







		@slow
		def 					UpperCAmelCase    (	self						:  Optional[Any]						)					->		int:






				"""simple docstring"""



				for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						lowercase__   :    Optional[Any]				=			TFResNetModel.from_pretrained(_snake_case						)
						self.assertIsNotNone(_snake_case						)





def      __UpperCAmelCase      (    )							->      Dict:
		lowercase__   :    List[str]				=			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
		return image





@require_tf
@require_vision
class        __A       (	unittest.TestCase    ):







		'''simple docstring'''





		@cached_property
		def 					UpperCAmelCase    (	self						:  str						)					->		Any:






				"""simple docstring"""



				return (
				    AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)
				    if is_vision_available()
				    else None
				)







		@slow
		def 					UpperCAmelCase    (	self						:  Union[str, Any]						)					->		Dict:






				"""simple docstring"""



				lowercase__   :    Tuple				=			TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]						)

				lowercase__   :    Any				=			self.default_image_processor
				lowercase__   :    int				=			prepare_img()
				lowercase__   :    Tuple				=			image_processor(images=_snake_case			,return_tensors='''tf'''						)

				# forward pass
				lowercase__   :    Dict				=			model(**_snake_case						)

				# verify the logits
				lowercase__   :    List[str]				=			tf.TensorShape((1, 1_000)						)
				self.assertEqual(outputs.logits.shape			,_snake_case						)

				lowercase__   :    Any				=			tf.constant([-11.1069, -9.7877, -8.3777]						)

				self.assertTrue(np.allclose(outputs.logits[0, :3].numpy()			,_snake_case			,atol=1e-4						)						)
