
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__  (	__lowerCamelCase   ,unittest.TestCase   ):
   _SCREAMING_SNAKE_CASE				:							List[Any]     	=				BertJapaneseTokenizer
   _SCREAMING_SNAKE_CASE				:							Any     	=				False
   _SCREAMING_SNAKE_CASE				:							Optional[int]     	=				True
   def 				lowerCAmelCase      (self			: List[Any]       ):
    super().setUp()

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

    __a			:  Union[str, 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 				lowerCAmelCase      (self			: Union[str, Any] ,    snake_case_			: List[str]       ):
    __a			:  Any		    =  '''こんにちは、世界。 \nこんばんは、世界。'''
    __a			:  Optional[int]		    =  '''こんにちは 、 世界 。 こんばんは 、 世界 。'''
    return input_text, output_text
   def 				lowerCAmelCase      (self			: List[str] ,    snake_case_			: Optional[Any]       ):
    __a			:  Union[str, Any]		    =  self.get_input_output_texts(__lowercase       )
    __a			:  List[Any]		    =  tokenizer.encode(__lowercase ,    add_special_tokens=__lowercase       )
    __a			:  List[str]		    =  tokenizer.decode(__lowercase ,    clean_up_tokenization_spaces=__lowercase       )
    return text, ids
   def 				lowerCAmelCase      (self			: Tuple       ):
    pass  # TODO add if relevant
   def 				lowerCAmelCase      (self			: Dict       ):
    pass  # TODO add if relevant
   def 				lowerCAmelCase      (self			: Union[str, Any]       ):
    pass  # TODO add if relevant
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  List[Any]		    =  self.tokenizer_class(self.vocab_file       )

    __a			:  Any		    =  tokenizer.tokenize('''こんにちは、世界。\nこんばんは、世界。'''       )
    self.assertListEqual(__lowercase ,    ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']       )
    self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowercase       ) ,    [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]       )
   def 				lowerCAmelCase      (self			: List[str]       ):
    __a			:  str		    =  self.tokenizer_class(self.vocab_file ,    word_tokenizer_type='''mecab'''       )
    self.assertIsNotNone(__lowercase       )

    __a			:  Union[str, Any]		    =  '''こんにちは、世界。\nこんばんは、世界。'''
    __a			:  Optional[int]		    =  tokenizer.tokenize(__lowercase       )
    self.assertListEqual(__lowercase ,    ['''こんにちは''', '''、''', '''世界''', '''。''', '''こん''', '''##ばんは''', '''、''', '''世界''', '''。''']       )
    self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowercase       ) ,    [3, 1_2, 1_0, 1_4, 4, 9, 1_2, 1_0, 1_4]       )

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

    with open(__lowercase ,    '''rb'''       ) as handle:
     __a			:  Union[str, Any]		    =  pickle.load(__lowercase       )

    __a			:  Dict		    =  tokenizer_new.tokenize(__lowercase       )

    self.assertListEqual(__lowercase ,    __lowercase       )
   def 				lowerCAmelCase      (self			: Any       ):
    __a			:  str		    =  MecabTokenizer(mecab_dic='''ipadic'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップルストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''] ,    )
   def 				lowerCAmelCase      (self			: Any       ):
    try:
     __a			:  List[Any]		    =  MecabTokenizer(mecab_dic='''unidic_lite'''       )
    except ModuleNotFoundError:
     return

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''] ,    )
   def 				lowerCAmelCase      (self			: Optional[Any]       ):
    try:
     __a			:  Any		    =  MecabTokenizer(mecab_dic='''unidic'''       )
    except ModuleNotFoundError:
     return

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''] ,    )
   def 				lowerCAmelCase      (self			: Any       ):
    __a			:  Dict		    =  MecabTokenizer(do_lower_case=__lowercase ,    mecab_dic='''ipadic'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップルストア''', '''で''', '''iphone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''] ,    )
   def 				lowerCAmelCase      (self			: List[str]       ):
    try:
     __a			:  Union[str, Any]		    =  MecabTokenizer(
         do_lower_case=__lowercase ,    normalize_text=__lowercase ,    mecab_option='''-d /usr/local/lib/mecab/dic/jumandic'''       )
    except RuntimeError:
     # if dict doesn't exist in the system, previous code raises this error.
     return

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''ｱｯﾌﾟﾙストア''', '''で''', '''iPhone''', '''８''', '''が''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''] ,    )
   def 				lowerCAmelCase      (self			: str       ):
    __a			:  List[str]		    =  MecabTokenizer(normalize_text=__lowercase ,    mecab_dic='''ipadic'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''ｱｯﾌﾟﾙストア''', '''で''', '''iPhone''', '''８''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''　''', '''。'''] ,    )
   @require_sudachi
   def 				lowerCAmelCase      (self			: Any       ):
    __a			:  Union[str, Any]		    =  self.tokenizer_class(self.vocab_file ,    word_tokenizer_type='''sudachi'''       )
    self.assertIsNotNone(__lowercase       )

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

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

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

    __a			:  Dict		    =  tokenizer_new.tokenize(__lowercase       )

    self.assertListEqual(__lowercase ,    __lowercase       )
   @require_sudachi
   def 				lowerCAmelCase      (self			: List[Any]       ):
    __a			:  List[str]		    =  SudachiTokenizer(sudachi_dict_type='''core'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    [''' ''', '''\t''', '''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', ''' ''', '''。''', ''' ''', ''' '''] ,    )
   @require_sudachi
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  Any		    =  SudachiTokenizer(sudachi_dict_type='''core''' ,    sudachi_split_mode='''A'''       )

    self.assertListEqual(tokenizer.tokenize('''外国人参政権'''       ) ,    ['''外国''', '''人''', '''参政''', '''権''']       )
   @require_sudachi
   def 				lowerCAmelCase      (self			: Union[str, Any]       ):
    __a			:  Any		    =  SudachiTokenizer(sudachi_dict_type='''core''' ,    sudachi_split_mode='''B'''       )

    self.assertListEqual(tokenizer.tokenize('''外国人参政権'''       ) ,    ['''外国人''', '''参政権''']       )
   @require_sudachi
   def 				lowerCAmelCase      (self			: Optional[Any]       ):
    __a			:  int		    =  SudachiTokenizer(sudachi_dict_type='''core''' ,    sudachi_split_mode='''C'''       )

    self.assertListEqual(tokenizer.tokenize('''外国人参政権'''       ) ,    ['''外国人参政権''']       )
   @require_sudachi
   def 				lowerCAmelCase      (self			: List[Any]       ):
    __a			:  List[Any]		    =  SudachiTokenizer(do_lower_case=__lowercase ,    sudachi_dict_type='''core'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    [''' ''', '''\t''', '''アップル''', '''ストア''', '''で''', '''iphone''', '''8''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', ''' ''', '''。''', ''' ''', ''' '''] ,    )
   @require_sudachi
   def 				lowerCAmelCase      (self			: str       ):
    __a			:  str		    =  SudachiTokenizer(normalize_text=__lowercase ,    sudachi_dict_type='''core'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    [''' ''', '''\t''', '''ｱｯﾌﾟﾙ''', '''ストア''', '''で''', '''iPhone''', '''８''', ''' ''', '''が''', ''' ''', ''' ''', '''\n ''', '''発売''', '''さ''', '''れ''', '''た''', '''\u3000''', '''。''', ''' ''', ''' '''] ,    )
   @require_sudachi
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  List[str]		    =  SudachiTokenizer(trim_whitespace=__lowercase ,    sudachi_dict_type='''core'''       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れ''', '''た''', '''。'''] ,    )
   @require_jumanpp
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  Optional[int]		    =  self.tokenizer_class(self.vocab_file ,    word_tokenizer_type='''jumanpp'''       )
    self.assertIsNotNone(__lowercase       )

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

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

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

    __a			:  Any		    =  tokenizer_new.tokenize(__lowercase       )

    self.assertListEqual(__lowercase ,    __lowercase       )
   @require_jumanpp
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  Union[str, Any]		    =  JumanppTokenizer()

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''] ,    )
   @require_jumanpp
   def 				lowerCAmelCase      (self			: Tuple       ):
    __a			:  List[str]		    =  JumanppTokenizer(do_lower_case=__lowercase       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップル''', '''ストア''', '''で''', '''iphone''', '''8''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''] ,    )
   @require_jumanpp
   def 				lowerCAmelCase      (self			: List[str]       ):
    __a			:  Union[str, Any]		    =  JumanppTokenizer(normalize_text=__lowercase       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''ｱ''', '''ｯ''', '''ﾌ''', '''ﾟ''', '''ﾙ''', '''ストア''', '''で''', '''iPhone''', '''８''', '''\u3000''', '''が''', '''\u3000''', '''\u3000''', '''\u3000''', '''発売''', '''さ''', '''れた''', '''\u3000''', '''。'''] ,    )
   @require_jumanpp
   def 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  Union[str, Any]		    =  JumanppTokenizer(trim_whitespace=__lowercase       )

    self.assertListEqual(
        tokenizer.tokenize(''' \tｱｯﾌﾟﾙストアでiPhone８ が  \n 発売された　。  '''       ) ,    ['''アップル''', '''ストア''', '''で''', '''iPhone''', '''8''', '''が''', '''発売''', '''さ''', '''れた''', '''。'''] ,    )
   @require_jumanpp
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  Tuple		    =  JumanppTokenizer()

    self.assertListEqual(
        tokenizer.tokenize('''ありがとうございますm(_ _)ｍ見つけるのが大変です。'''       ) ,    ['''ありがとう''', '''ございます''', '''m(_ _)m''', '''見つける''', '''の''', '''が''', '''大変です''', '''。'''] ,    )
   def 				lowerCAmelCase      (self			: List[Any]       ):
    __a			:  Optional[Any]		    =  ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

    self.assertListEqual(tokenizer.tokenize('''こんばんは こんばんにちは こんにちは'''       ) ,    ['''こん''', '''##ばんは''', '''[UNK]''', '''こんにちは''']       )
   def 				lowerCAmelCase      (self			: List[str]       ):
    __a			:  Optional[int]		    =  BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''       )
    __a			:  Union[str, Any]		    =  tokenizer.subword_tokenizer

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

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







   def 				lowerCAmelCase      (self			: Any       ):
    __a			:  Dict		    =  self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''       )

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

    __a			:  Any		    =  tokenizer.build_inputs_with_special_tokens(__lowercase       )
    __a			:  List[Any]		    =  tokenizer.build_inputs_with_special_tokens(__lowercase ,    __lowercase       )

    # 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__  (	__lowerCamelCase   ,unittest.TestCase   ):
   _SCREAMING_SNAKE_CASE				:							Optional[int]     	=				BertJapaneseTokenizer
   _SCREAMING_SNAKE_CASE				:							Dict     	=				False
   def 				lowerCAmelCase      (self			: Union[str, Any]       ):
    super().setUp()

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

    __a			:  str		    =  os.path.join(self.tmpdirname ,    VOCAB_FILES_NAMES['''vocab_file''']       )
    with open(self.vocab_file ,    '''w''' ,    encoding='''utf-8'''       ) as vocab_writer:
     vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )
   def 				lowerCAmelCase      (self			: str ,    **snake_case_			: int       ):
    return BertJapaneseTokenizer.from_pretrained(self.tmpdirname ,    subword_tokenizer_type='''character''' ,    **__lowercase       )
   def 				lowerCAmelCase      (self			: List[str] ,    snake_case_			: Any       ):
    __a			:  Optional[int]		    =  '''こんにちは、世界。 \nこんばんは、世界。'''
    __a			:  List[Any]		    =  '''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
    return input_text, output_text
   def 				lowerCAmelCase      (self			: Tuple       ):
    pass  # TODO add if relevant
   def 				lowerCAmelCase      (self			: Optional[Any]       ):
    pass  # TODO add if relevant
   def 				lowerCAmelCase      (self			: Union[str, Any]       ):
    pass  # TODO add if relevant
   def 				lowerCAmelCase      (self			: List[str]       ):
    __a			:  int		    =  self.tokenizer_class(self.vocab_file ,    subword_tokenizer_type='''character'''       )

    __a			:  List[Any]		    =  tokenizer.tokenize('''こんにちは、世界。 \nこんばんは、世界。'''       )
    self.assertListEqual(
        __lowercase ,    ['''こ''', '''ん''', '''に''', '''ち''', '''は''', '''、''', '''世''', '''界''', '''。''', '''こ''', '''ん''', '''ば''', '''ん''', '''は''', '''、''', '''世''', '''界''', '''。''']       )
    self.assertListEqual(
        tokenizer.convert_tokens_to_ids(__lowercase       ) ,    [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 				lowerCAmelCase      (self			: Optional[int]       ):
    __a			:  int		    =  ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こ''', '''ん''', '''に''', '''ち''', '''は''', '''ば''', '''世''', '''界''', '''、''', '''。''']

    __a			:  List[str]		    =  {}
    for i, token in enumerate(__lowercase       ):
     __a			:  Dict		    =  i
    __a			:  Union[str, Any]		    =  CharacterTokenizer(vocab=__lowercase ,    unk_token='''[UNK]'''       )

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

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

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







   def 				lowerCAmelCase      (self			: List[str]       ):
    __a			:  Dict		    =  self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''       )

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

    __a			:  Any		    =  tokenizer.build_inputs_with_special_tokens(__lowercase       )
    __a			:  List[str]		    =  tokenizer.build_inputs_with_special_tokens(__lowercase ,    __lowercase       )

    # 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   ):
   def 				lowerCAmelCase      (self			: int       ):
    __a			:  Any		    =  '''cl-tohoku/bert-base-japanese'''
    __a			:  Dict		    =  AutoTokenizer.from_pretrained(__lowercase       )
    self.assertIsInstance(__lowercase ,    __lowercase       )





class 		UpperCamelCase__  (	unittest.TestCase   ):
   def 				lowerCAmelCase      (self			: List[Any]       ):
    __a			:  List[str]		    =  '''cl-tohoku/bert-base-japanese'''
    with self.assertLogs('''transformers''' ,    level='''WARNING'''       ) as cm:
     BertTokenizer.from_pretrained(__lowercase       )
     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.'''       )       )
    __a			:  Union[str, Any]		    =  '''bert-base-cased'''
    with self.assertLogs('''transformers''' ,    level='''WARNING'''       ) as cm:
     BertJapaneseTokenizer.from_pretrained(__lowercase       )
     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.'''       )       )


import unicodedata
from dataclasses import dataclass
from typing import Optional, Union

import numpy as np

from transformers.data.data_collator import DataCollatorMixin
from transformers.file_utils import PaddingStrategy
from transformers.tokenization_utils_base import PreTrainedTokenizerBase




def        __UpperCamelCase					(    lowerCAmelCase__							:    Union[str, Any]  ,       lowerCAmelCase__							:    int  ,       lowerCAmelCase__							:    List[str]  ,       lowerCAmelCase__							:    Any  ):
 if isinstance(lowerCAmelCase__  ,       lowerCAmelCase__  ):
  __a			:  Union[str, Any]		    =  np.full((len(lowerCAmelCase__  ), sequence_length, 2)  ,       lowerCAmelCase__  )
 else:
  __a			:  str		    =  np.full((len(lowerCAmelCase__  ), sequence_length)  ,       lowerCAmelCase__  )

 for i, tensor in enumerate(lowerCAmelCase__  ):
  if padding_side == "right":
   if isinstance(lowerCAmelCase__  ,       lowerCAmelCase__  ):
    __a			:  Any		    =  tensor[:sequence_length]
   else:
    __a			:  List[Any]		    =  tensor[:sequence_length]
  else:
   if isinstance(lowerCAmelCase__  ,       lowerCAmelCase__  ):
    __a			:  Dict		    =  tensor[:sequence_length]
   else:
    __a			:  int		    =  tensor[:sequence_length]

 return out_tensor.tolist()




def        __UpperCamelCase					(    lowerCAmelCase__							:    Optional[Any]  ):
 __a			:  str		    =  ord(lowerCAmelCase__  )
 if (cp >= 3_3 and cp <= 4_7) or (cp >= 5_8 and cp <= 6_4) or (cp >= 9_1 and cp <= 9_6) or (cp >= 1_2_3 and cp <= 1_2_6):
  return True
 __a			:  List[str]		    =  unicodedata.category(lowerCAmelCase__  )
 if cat.startswith('''P'''  ):
  return True
 return False



@dataclass
class 		UpperCamelCase__  (	__lowercase   ):
   _SCREAMING_SNAKE_CASE				:							PreTrainedTokenizerBase
   _SCREAMING_SNAKE_CASE				:							Union[bool, str, PaddingStrategy]     	=				True
   _SCREAMING_SNAKE_CASE				:							Optional[int]     	=				None
   _SCREAMING_SNAKE_CASE				:							Optional[int]     	=				None
   _SCREAMING_SNAKE_CASE				:							int     	=				-100
   _SCREAMING_SNAKE_CASE				:							str     	=				"pt"
   def 				lowerCAmelCase      (self			: str ,    snake_case_			: Tuple       ):
    import torch

    __a			:  Union[str, Any]		    =  '''label''' if '''label''' in features[0].keys() else '''labels'''
    __a			:  Tuple		    =  [feature[label_name] for feature in features] if label_name in features[0].keys() else None
    __a			:  Union[str, Any]		    =  self.tokenizer.pad(
        snake_case_ ,    padding=self.padding ,    max_length=self.max_length ,    pad_to_multiple_of=self.pad_to_multiple_of ,    return_tensors='''pt''' if labels is None else None ,    )

    if labels is None:
     return batch

    __a			:  List[str]		    =  torch.tensor(batch['''entity_ids''']       ).shape[1]
    __a			:  Tuple		    =  self.tokenizer.padding_side
    if padding_side == "right":
     __a			:  Union[str, Any]		    =  [
         list(snake_case_       ) + [self.label_pad_token_id] * (sequence_length - len(snake_case_       )) for label in labels
     ]
    else:
     __a			:  Dict		    =  [
         [self.label_pad_token_id] * (sequence_length - len(snake_case_       )) + list(snake_case_       ) for label in labels
     ]

    __a			:  Dict		    =  [feature['''ner_tags'''] for feature in features]
    __a			:  Optional[Any]		    =  padding_tensor(snake_case_ ,    -1 ,    snake_case_ ,    snake_case_       )
    __a			:  Union[str, Any]		    =  [feature['''original_entity_spans'''] for feature in features]
    __a			:  Optional[int]		    =  padding_tensor(snake_case_ ,    (-1, -1) ,    snake_case_ ,    snake_case_       )
    __a			:  List[str]		    =  {k: torch.tensor(snake_case_ ,    dtype=torch.intaa       ) for k, v in batch.items()}

    return batch
