

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







			'''simple docstring'''

			SCREAMING_SNAKE_CASE     :   List[str]									=				BertJapaneseTokenizer
			SCREAMING_SNAKE_CASE     :   Dict									=				False
			SCREAMING_SNAKE_CASE     :   str									=				True







			def 				snake_case__(     self :				str							)      ->Tuple:
									super().setUp()

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

									snake_case_   =	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 				snake_case__(     self :				Optional[Any]							,   _UpperCamelCase :				List[Any]							)      ->List[str]:
									snake_case_   =	'''こんにちは、世界。 \nこんばんは、世界。'''
									snake_case_   =	'''こんにちは 、 世界 。 こんばんは 、 世界 。'''
									return input_text, output_text







			def 				snake_case__(     self :				Optional[Any]							,   _UpperCamelCase :				Dict							)      ->Tuple:
									snake_case_,    snake_case_   =	self.get_input_output_texts(_UpperCamelCase							)
									snake_case_   =	tokenizer.encode(_UpperCamelCase							,   add_special_tokens=_UpperCamelCase							)
									snake_case_   =	tokenizer.decode(_UpperCamelCase							,   clean_up_tokenization_spaces=_UpperCamelCase							)
									return text, ids







			def 				snake_case__(     self :				Any							)      ->Dict:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Optional[Any]							)      ->Optional[Any]:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Optional[Any]							)      ->Any:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Optional[int]							)      ->int:
									snake_case_   =	self.tokenizer_class(self.vocab_file							)

									snake_case_   =	tokenizer.tokenize('''こんにちは、世界。\nこんばんは、世界。'''							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)







			def 				snake_case__(     self :				Dict							)      ->Any:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''mecab'''							)
									self.assertIsNotNone(_UpperCamelCase							)

									snake_case_   =	'''こんにちは、世界。\nこんばんは、世界。'''
									snake_case_   =	tokenizer.tokenize(_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)

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

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

									snake_case_   =	tokenizer_new.tokenize(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,   _UpperCamelCase							)







			def 				snake_case__(     self :				List[Any]							)      ->Tuple:
									snake_case_   =	MecabTokenizer(mecab_dic='''ipadic'''							)

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







			def 				snake_case__(     self :				int							)      ->List[Any]:
									try:
															snake_case_   =	MecabTokenizer(mecab_dic='''unidic_lite'''							)
									except ModuleNotFoundError:
															return

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







			def 				snake_case__(     self :				Union[str, Any]							)      ->str:
									try:
															snake_case_   =	MecabTokenizer(mecab_dic='''unidic'''							)
									except ModuleNotFoundError:
															return

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







			def 				snake_case__(     self :				List[str]							)      ->Dict:
									snake_case_   =	MecabTokenizer(do_lower_case=_UpperCamelCase							,   mecab_dic='''ipadic'''							)

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







			def 				snake_case__(     self :				Optional[int]							)      ->List[str]:
									try:
															snake_case_   =	MecabTokenizer(
															    do_lower_case=_UpperCamelCase							,   normalize_text=_UpperCamelCase							,   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 				snake_case__(     self :				Optional[int]							)      ->Union[str, Any]:
									snake_case_   =	MecabTokenizer(normalize_text=_UpperCamelCase							,   mecab_dic='''ipadic'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Optional[Any]							)      ->str:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''sudachi'''							)
									self.assertIsNotNone(_UpperCamelCase							)

									snake_case_   =	'''こんにちは、世界。\nこんばんは、世界。'''
									snake_case_   =	tokenizer.tokenize(_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)

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

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

									snake_case_   =	tokenizer_new.tokenize(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,   _UpperCamelCase							)







			@require_sudachi
			def 				snake_case__(     self :				Tuple							)      ->Optional[int]:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''A'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Dict							)      ->List[Any]:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''B'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Optional[int]							)      ->Tuple:
									snake_case_   =	SudachiTokenizer(sudachi_dict_type='''core'''							,   sudachi_split_mode='''C'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Optional[Any]							)      ->int:
									snake_case_   =	SudachiTokenizer(do_lower_case=_UpperCamelCase							,   sudachi_dict_type='''core'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				Dict							)      ->List[str]:
									snake_case_   =	SudachiTokenizer(normalize_text=_UpperCamelCase							,   sudachi_dict_type='''core'''							)

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







			@require_sudachi
			def 				snake_case__(     self :				List[str]							)      ->List[Any]:
									snake_case_   =	SudachiTokenizer(trim_whitespace=_UpperCamelCase							,   sudachi_dict_type='''core'''							)

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







			@require_jumanpp
			def 				snake_case__(     self :				int							)      ->Union[str, Any]:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   word_tokenizer_type='''jumanpp'''							)
									self.assertIsNotNone(_UpperCamelCase							)

									snake_case_   =	'''こんにちは、世界。\nこんばんは、世界。'''
									snake_case_   =	tokenizer.tokenize(_UpperCamelCase							)
									self.assertListEqual(_UpperCamelCase							,   ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']							)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]							)

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

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

									snake_case_   =	tokenizer_new.tokenize(_UpperCamelCase							)

									self.assertListEqual(_UpperCamelCase							,   _UpperCamelCase							)







			@require_jumanpp
			def 				snake_case__(     self :				List[str]							)      ->Dict:
									snake_case_   =	JumanppTokenizer()

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







			@require_jumanpp
			def 				snake_case__(     self :				Any							)      ->Any:
									snake_case_   =	JumanppTokenizer(do_lower_case=_UpperCamelCase							)

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







			@require_jumanpp
			def 				snake_case__(     self :				int							)      ->Dict:
									snake_case_   =	JumanppTokenizer(normalize_text=_UpperCamelCase							)

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







			@require_jumanpp
			def 				snake_case__(     self :				int							)      ->Optional[Any]:
									snake_case_   =	JumanppTokenizer(trim_whitespace=_UpperCamelCase							)

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







			@require_jumanpp
			def 				snake_case__(     self :				Any							)      ->Optional[int]:
									snake_case_   =	JumanppTokenizer()

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







			def 				snake_case__(     self :				Any							)      ->List[Any]:
									snake_case_   =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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







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

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

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







			def 				snake_case__(     self :				str							)      ->Tuple:
									snake_case_   =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''							)

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

									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							)
									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							,   _UpperCamelCase							)

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







			'''simple docstring'''

			SCREAMING_SNAKE_CASE     :   Union[str, Any]									=				BertJapaneseTokenizer
			SCREAMING_SNAKE_CASE     :   int									=				False







			def 				snake_case__(     self :				List[str]							)      ->int:
									super().setUp()

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

									snake_case_   =	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 				snake_case__(     self :				Optional[Any]							,   **_UpperCamelCase :				Union[str, Any]							)      ->int:
									return BertJapaneseTokenizer.from_pretrained(self.tmpdirname							,   subword_tokenizer_type='''character'''							,   **_UpperCamelCase							)







			def 				snake_case__(     self :				Any							,   _UpperCamelCase :				Union[str, Any]							)      ->List[Any]:
									snake_case_   =	'''こんにちは、世界。 \nこんばんは、世界。'''
									snake_case_   =	'''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
									return input_text, output_text







			def 				snake_case__(     self :				Dict							)      ->Union[str, Any]:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Any							)      ->Union[str, Any]:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				Tuple							)      ->Tuple:
									pass  # TODO add if relevant







			def 				snake_case__(     self :				List[Any]							)      ->int:
									snake_case_   =	self.tokenizer_class(self.vocab_file							,   subword_tokenizer_type='''character'''							)

									snake_case_   =	tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。'''							)
									self.assertListEqual(
									    _UpperCamelCase							,   ['''こ''', '''ん''', '''に''', '''ち''', '''は''', '''、''', '''世''', '''界''', '''。''', '''こ''', '''ん''', '''ば''', '''ん''', '''は''', '''、''', '''世''', '''界''', '''。''']							)
									self.assertListEqual(
									    tokenizer.convert_tokens_to_ids(_UpperCamelCase							)							,   [3, 4, 5, 6, 7, 1_1, 9, 1_0, 1_2, 3, 4, 8, 4, 7, 1_1, 9, 1_0, 1_2]							)







			def 				snake_case__(     self :				List[str]							)      ->List[str]:
									snake_case_   =	['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

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

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

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

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







			def 				snake_case__(     self :				Dict							)      ->Tuple:
									snake_case_   =	self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''							)

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

									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							)
									snake_case_   =	tokenizer.build_inputs_with_special_tokens(_UpperCamelCase							,   _UpperCamelCase							)

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







			'''simple docstring'''

			def 				snake_case__(     self :				str							)      ->int:
									snake_case_   =	'''cl-tohoku/bert-base-japanese'''
									snake_case_   =	AutoTokenizer.from_pretrained(_UpperCamelCase							)
									self.assertIsInstance(_UpperCamelCase							,   _UpperCamelCase							)






class 	snake_case_   (		unittest.TestCase					):







			'''simple docstring'''

			def 				snake_case__(     self :				Optional[int]							)      ->Dict:
									snake_case_   =	'''cl-tohoku/bert-base-japanese'''
									with self.assertLogs('''transformers'''							,   level='''WARNING'''							) as cm:
															BertTokenizer.from_pretrained(_UpperCamelCase							)
															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_   =	'''bert-base-cased'''
									with self.assertLogs('''transformers'''							,   level='''WARNING'''							) as cm:
															BertJapaneseTokenizer.from_pretrained(_UpperCamelCase							)
															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 os
from dataclasses import dataclass, field
from io import BytesIO
from typing import TYPE_CHECKING, Any, ClassVar, Dict, Optional, Union

import numpy as np
import pyarrow as pa

from .. import config
from ..download.streaming_download_manager import xopen, xsplitext
from ..table import array_cast
from ..utils.py_utils import no_op_if_value_is_null, string_to_dict


if TYPE_CHECKING:
       from .features import FeatureType


SCREAMING_SNAKE_CASE__,      SCREAMING_SNAKE_CASE__,      SCREAMING_SNAKE_CASE__					=   False, False, False

@dataclass
class 		lowercase					:
      _SCREAMING_SNAKE_CASE					=      None
      _SCREAMING_SNAKE_CASE					=      True
      _SCREAMING_SNAKE_CASE					=      True
      _SCREAMING_SNAKE_CASE					=      None
      # Automatically constructed
      _SCREAMING_SNAKE_CASE					=      "dict"
      _SCREAMING_SNAKE_CASE					=      pa.struct({'bytes': pa.binary(), 'path': pa.string()}					)
      _SCREAMING_SNAKE_CASE					=      field(default='Audio'     ,  init=_UpperCAmelCase     ,  repr=_UpperCAmelCase					)





      def __call__(       self )		->     Union[str, Any]:
            return self.pa_type





      def     _snake_case			(       self      ,						lowercase )		->     dict:
            try:
                  import soundfile as sf  # soundfile is a dependency of librosa, needed to decode audio files.
            except ImportError as err:
                  raise ImportError("""To support encoding audio data, please install 'soundfile'.""" ) from err
            if isinstance(lowercase      ,						lowercase ):
                  return {"bytes": None, "path": value}
            elif isinstance(lowercase      ,						lowercase ):
                  return {"bytes": value, "path": None}
            elif "array" in value:
                  # convert the audio array to wav bytes
                  lowerCAmelCase  						=       BytesIO()
                  sf.write(lowercase      ,						value["""array"""]      ,						value["""sampling_rate"""]      ,						format="""wav""" )
                  return {"bytes": buffer.getvalue(), "path": None}
            elif value.get("""path""" ) is not None and os.path.isfile(value["""path"""] ):
                  # we set "bytes": None to not duplicate the data if they're already available locally
                  if value["path"].endswith("""pcm""" ):
                        # "PCM" only has raw audio bytes
                        if value.get("""sampling_rate""" ) is None:
                              # At least, If you want to convert "PCM-byte" to "WAV-byte", you have to know sampling rate
                              raise KeyError("""To use PCM files, please specify a 'sampling_rate' in Audio object""" )
                        if value.get("""bytes""" ):
                              # If we already had PCM-byte, we don`t have to make "read file, make bytes" (just use it!)
                              lowerCAmelCase  						=       np.frombuffer(value["""bytes"""]      ,						dtype=np.intaa ).astype(np.floataa ) / 32_767
                        else:
                              lowerCAmelCase  						=       np.memmap(value["""path"""]      ,						dtype="""h"""      ,						mode="""r""" ).astype(np.floataa ) / 32_767

                        lowerCAmelCase  						=       BytesIO(bytes() )
                        sf.write(lowercase      ,						lowercase      ,						value["""sampling_rate"""]      ,						format="""wav""" )
                        return {"bytes": buffer.getvalue(), "path": None}
                  else:
                        return {"bytes": None, "path": value.get("""path""" )}
            elif value.get("""bytes""" ) is not None or value.get("""path""" ) is not None:
                  # store the audio bytes, and path is used to infer the audio format using the file extension
                  return {"bytes": value.get("""bytes""" ), "path": value.get("""path""" )}
            else:
                  raise ValueError(
                      f'An audio sample should have one of \'path\' or \'bytes\' but they are missing or None in {value}.' )





      def     _snake_case			(       self      ,						lowercase      ,						lowercase = None )		->     dict:
            if not self.decode:
                  raise RuntimeError("""Decoding is disabled for this feature. Please use Audio(decode=True) instead.""" )

            lowerCAmelCase						,		lowerCAmelCase  						=       (value["""path"""], BytesIO(value["""bytes"""] )) if value["""bytes"""] is not None else (value["""path"""], None)
            if path is None and file is None:
                  raise ValueError(f'An audio sample should have one of \'path\' or \'bytes\' but both are None in {value}.' )

            try:
                  import librosa
                  import soundfile as sf
            except ImportError as err:
                  raise ImportError("""To support decoding audio files, please install 'librosa' and 'soundfile'.""" ) from err

            lowerCAmelCase  						=       xsplitext(lowercase )[1][1:].lower() if path is not None else None
            if not config.IS_OPUS_SUPPORTED and audio_format == "opus":
                  raise RuntimeError(
                      """Decoding 'opus' files requires system library 'libsndfile'>=1.0.31, """
                      """You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. """ )
            elif not config.IS_MP3_SUPPORTED and audio_format == "mp3":
                  raise RuntimeError(
                      """Decoding 'mp3' files requires system library 'libsndfile'>=1.1.0, """
                      """You can try to update `soundfile` python library: `pip install \"soundfile>=0.12.1\"`. """ )

            if file is None:
                  lowerCAmelCase  						=       token_per_repo_id or {}
                  lowerCAmelCase  						=       path.split("""::""" )[-1]
                  try:
                        lowerCAmelCase  						=       string_to_dict(lowercase      ,						config.HUB_DATASETS_URL )["""repo_id"""]
                        lowerCAmelCase  						=       token_per_repo_id[repo_id]
                  except (ValueError, KeyError):
                        lowerCAmelCase  						=       None

                  with xopen(lowercase      ,						"""rb"""      ,						use_auth_token=lowercase ) as f:
                        lowerCAmelCase						,		lowerCAmelCase  						=       sf.read(lowercase )

            else:
                  lowerCAmelCase						,		lowerCAmelCase  						=       sf.read(lowercase )

            lowerCAmelCase  						=       array.T
            if self.mono:
                  lowerCAmelCase  						=       librosa.to_mono(lowercase )
            if self.sampling_rate and self.sampling_rate != sampling_rate:
                  lowerCAmelCase  						=       librosa.resample(lowercase      ,						orig_sr=lowercase      ,						target_sr=self.sampling_rate )
                  lowerCAmelCase  						=       self.sampling_rate

            return {"path": path, "array": array, "sampling_rate": sampling_rate}





      def     _snake_case			(       self )		->     Union["FeatureType", Dict[str, "FeatureType"]]:
            from .features import Value

            if self.decode:
                  raise ValueError("""Cannot flatten a decoded Audio feature.""" )
            return {
                "bytes": Value("""binary""" ),
                "path": Value("""string""" ),
            }





      def     _snake_case			(       self      ,						lowercase )		->     pa.StructArray:
            if pa.types.is_string(storage.type ):
                  lowerCAmelCase  						=       pa.array([None] * len(lowercase )      ,						type=pa.binary() )
                  lowerCAmelCase  						=       pa.StructArray.from_arrays([bytes_array, storage]      ,						["""bytes""", """path"""]      ,						mask=storage.is_null() )
            elif pa.types.is_binary(storage.type ):
                  lowerCAmelCase  						=       pa.array([None] * len(lowercase )      ,						type=pa.string() )
                  lowerCAmelCase  						=       pa.StructArray.from_arrays([storage, path_array]      ,						["""bytes""", """path"""]      ,						mask=storage.is_null() )
            elif pa.types.is_struct(storage.type ) and storage.type.get_all_field_indices("""array""" ):
                  lowerCAmelCase  						=       pa.array([Audio().encode_example(lowercase ) if x is not None else None for x in storage.to_pylist()] )
            elif pa.types.is_struct(storage.type ):
                  if storage.type.get_field_index("""bytes""" ) >= 0:
                        lowerCAmelCase  						=       storage.field("""bytes""" )
                  else:
                        lowerCAmelCase  						=       pa.array([None] * len(lowercase )      ,						type=pa.binary() )
                  if storage.type.get_field_index("""path""" ) >= 0:
                        lowerCAmelCase  						=       storage.field("""path""" )
                  else:
                        lowerCAmelCase  						=       pa.array([None] * len(lowercase )      ,						type=pa.string() )
                  lowerCAmelCase  						=       pa.StructArray.from_arrays([bytes_array, path_array]      ,						["""bytes""", """path"""]      ,						mask=storage.is_null() )
            return array_cast(lowercase      ,						self.pa_type )





      def     _snake_case			(       self      ,						lowercase )		->     pa.StructArray:

            @no_op_if_value_is_null
            def path_to_bytes(lowercase ):
                  with xopen(lowercase      ,						"""rb""" ) as f:
                        lowerCAmelCase  						=       f.read()
                  return bytes_

            lowerCAmelCase  						=       pa.array(
                [
                    (path_to_bytes(x["""path"""] ) if x["""bytes"""] is None else x["""bytes"""]) if x is not None else None
                    for x in storage.to_pylist()
                ]      ,						type=pa.binary()      ,						)
            lowerCAmelCase  						=       pa.array(
                [os.path.basename(lowercase ) if path is not None else None for path in storage.field("""path""" ).to_pylist()]      ,						type=pa.string()      ,						)
            lowerCAmelCase  						=       pa.StructArray.from_arrays([bytes_array, path_array]      ,						["""bytes""", """path"""]      ,						mask=bytes_array.is_null() )
            return array_cast(lowercase      ,						self.pa_type )






