


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 		__magic_name__						(lowercase_   ,unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							Tuple	   =       BertJapaneseTokenizer
     __lowercase				:							List[str]	   =       False
     __lowercase				:							Union[str, Any]	   =       True

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

     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]     ,		_a:List[str]   ):
       snake_case__				,				snake_case__						= self.get_input_output_texts(_lowercase   )
       snake_case__						= tokenizer.encode(_lowercase     ,		add_special_tokens=_lowercase   )
       snake_case__						= tokenizer.decode(_lowercase     ,		clean_up_tokenization_spaces=_lowercase   )
       return text, ids

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       pass  # TODO add if relevant

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       pass  # TODO add if relevant

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       pass  # TODO add if relevant

     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       snake_case__						= self.tokenizer_class(self.vocab_file   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= self.tokenizer_class(self.vocab_file     ,		word_tokenizer_type='''mecab'''   )
       self.assertIsNotNone(_lowercase   )

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

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

       with open(_lowercase     ,		'''rb'''   ) as handle:
         snake_case__						= pickle.load(_lowercase   )

       snake_case__						= tokenizer_new.tokenize(_lowercase   )

       self.assertListEqual(_lowercase     ,		_lowercase   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       snake_case__						= MecabTokenizer(mecab_dic='''ipadic'''   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       try:
         snake_case__						= MecabTokenizer(mecab_dic='''unidic_lite'''   )
       except ModuleNotFoundError:
         return

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

     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       try:
         snake_case__						= MecabTokenizer(mecab_dic='''unidic'''   )
       except ModuleNotFoundError:
         return

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

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       snake_case__						= MecabTokenizer(do_lower_case=_lowercase     ,		mecab_dic='''ipadic'''   )

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

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       try:
         snake_case__						= 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 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       snake_case__						= MecabTokenizer(normalize_text=_lowercase     ,		mecab_dic='''ipadic'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       snake_case__						= self.tokenizer_class(self.vocab_file     ,		word_tokenizer_type='''sudachi'''   )
       self.assertIsNotNone(_lowercase   )

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

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

       with open(_lowercase     ,		'''rb'''   ) as handle:
         snake_case__						= pickle.load(_lowercase   )

       snake_case__						= tokenizer_new.tokenize(_lowercase   )

       self.assertListEqual(_lowercase     ,		_lowercase   )

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= SudachiTokenizer(sudachi_dict_type='''core'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       snake_case__						= SudachiTokenizer(sudachi_dict_type='''core'''     ,		sudachi_split_mode='''A'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= SudachiTokenizer(sudachi_dict_type='''core'''     ,		sudachi_split_mode='''B'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= SudachiTokenizer(sudachi_dict_type='''core'''     ,		sudachi_split_mode='''C'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= SudachiTokenizer(do_lower_case=_lowercase     ,		sudachi_dict_type='''core'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       snake_case__						= SudachiTokenizer(normalize_text=_lowercase     ,		sudachi_dict_type='''core'''   )

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

     @require_sudachi
     def 	SCREAMING_SNAKE_CASE__						(					self:List[str]   ):
       snake_case__						= SudachiTokenizer(trim_whitespace=_lowercase     ,		sudachi_dict_type='''core'''   )

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

     @require_jumanpp
     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       snake_case__						= self.tokenizer_class(self.vocab_file     ,		word_tokenizer_type='''jumanpp'''   )
       self.assertIsNotNone(_lowercase   )

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

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

       with open(_lowercase     ,		'''rb'''   ) as handle:
         snake_case__						= pickle.load(_lowercase   )

       snake_case__						= tokenizer_new.tokenize(_lowercase   )

       self.assertListEqual(_lowercase     ,		_lowercase   )

     @require_jumanpp
     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       snake_case__						= JumanppTokenizer()

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

     @require_jumanpp
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= JumanppTokenizer(do_lower_case=_lowercase   )

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

     @require_jumanpp
     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[int]   ):
       snake_case__						= JumanppTokenizer(normalize_text=_lowercase   )

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

     @require_jumanpp
     def 	SCREAMING_SNAKE_CASE__						(					self:Tuple   ):
       snake_case__						= JumanppTokenizer(trim_whitespace=_lowercase   )

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

     @require_jumanpp
     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       snake_case__						= JumanppTokenizer()

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

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       snake_case__						= ['''[UNK]''', '''[CLS]''', '''[SEP]''', '''こんにちは''', '''こん''', '''にちは''', '''ばんは''', '''##こん''', '''##にちは''', '''##ばんは''']

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

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

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

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

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

     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       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(_lowercase     ,		['''▁国境''', '''▁の''', '''▁長い''', '''▁トンネル''', '''▁を''', '''▁抜ける''', '''▁と''', '''▁雪''', '''国''', '''▁であった''', '''▁。''']   )

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







     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       snake_case__						= self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''   )

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

       snake_case__						= tokenizer.build_inputs_with_special_tokens(_lowercase   )
       snake_case__						= 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 		__magic_name__						(lowercase_   ,unittest.TestCase				):





     '''simple docstring'''



     __lowercase				:							Optional[Any]	   =       BertJapaneseTokenizer
     __lowercase				:							Optional[int]	   =       False

     def 	SCREAMING_SNAKE_CASE__						(					self:Union[str, Any]   ):
       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 	SCREAMING_SNAKE_CASE__						(					self:List[str]     ,		**_a:Any   ):
       return BertJapaneseTokenizer.from_pretrained(self.tmpdirname     ,		subword_tokenizer_type='''character'''     ,		**_lowercase   )

     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]     ,		_a:List[Any]   ):
       snake_case__						= '''こんにちは、世界。 \nこんばんは、世界。'''
       snake_case__						= '''こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'''
       return input_text, output_text

     def 	SCREAMING_SNAKE_CASE__						(					self:Any   ):
       pass  # TODO add if relevant

     def 	SCREAMING_SNAKE_CASE__						(					self:str   ):
       pass  # TODO add if relevant

     def 	SCREAMING_SNAKE_CASE__						(					self:int   ):
       pass  # TODO add if relevant

     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       snake_case__						= self.tokenizer_class(self.vocab_file     ,		subword_tokenizer_type='''character'''   )

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

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

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

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

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

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







     def 	SCREAMING_SNAKE_CASE__						(					self:Optional[Any]   ):
       snake_case__						= self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese-char'''   )

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

       snake_case__						= tokenizer.build_inputs_with_special_tokens(_lowercase   )
       snake_case__						= 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 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     def 	SCREAMING_SNAKE_CASE__						(					self:Dict   ):
       snake_case__						= '''cl-tohoku/bert-base-japanese'''
       snake_case__						= AutoTokenizer.from_pretrained(_lowercase   )
       self.assertIsInstance(_lowercase     ,		_lowercase   )




class 		__magic_name__						(unittest.TestCase				):





     '''simple docstring'''



     def 	SCREAMING_SNAKE_CASE__						(					self:List[Any]   ):
       snake_case__						= '''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.'''   )   )
       snake_case__						= '''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.'''   )   )




'''simple docstring'''

import importlib.util
import json
import os
import warnings
from dataclasses import dataclass, field

import torch

from ..training_args import TrainingArguments
from ..utils import cached_property, is_sagemaker_dp_enabled, logging


SCREAMING_SNAKE_CASE							:				Optional[Any]     	=			logging.get_logger(__name__)




def 							_UpperCamelCase				(   )      -> List[Any]:
							# Get the sagemaker specific mp parameters from smp_options variable.
							SCREAMING_SNAKE_CASE_				=				os.getenv('SM_HP_MP_PARAMETERS'		,'{}'   )
							try:
														# Parse it and check the field "partitions" is included, it is required for model parallel.
														SCREAMING_SNAKE_CASE_				=				json.loads(lowerCAmelCase__   )
														if "partitions" not in smp_options:
																					return False
							except json.JSONDecodeError:
														return False

							# Get the sagemaker specific framework parameters from mpi_options variable.
							SCREAMING_SNAKE_CASE_				=				os.getenv('SM_FRAMEWORK_PARAMS'		,'{}'   )
							try:
														# Parse it and check the field "sagemaker_distributed_dataparallel_enabled".
														SCREAMING_SNAKE_CASE_				=				json.loads(lowerCAmelCase__   )
														if not mpi_options.get('sagemaker_mpi_enabled'		,lowerCAmelCase__   ):
																					return False
							except json.JSONDecodeError:
														return False
							# Lastly, check if the `smdistributed` module is present.
							return importlib.util.find_spec('smdistributed'   ) is not None


if is_sagemaker_model_parallel_available():
							import smdistributed.modelparallel.torch as smp

							smp.init()






@dataclass
class    snake_case     (      lowercase_		):






				"""simple docstring"""
				_a    	=     field(
				    default="""""",						metadata={"""help""": """Used by the SageMaker launcher to send mp-specific args. Ignored in SageMakerTrainer"""},						)



				def   a__					(    self       )     ->							Union[str, Any]:
											super().__post_init__()
											warnings.warn(
											    '`SageMakerTrainingArguments` is deprecated and will be removed in v5 of Transformers. You can use '
											    '`TrainingArguments` instead.',     _lowercase,     )



				@cached_property
				def   a__					(    self       )     ->							"torch.device":
											logger.info('PyTorch: setting up devices'       )
											if torch.distributed.is_available() and torch.distributed.is_initialized() and self.local_rank == -1:
																		logger.warning(
																		    'torch.distributed process group is initialized, but local_rank == -1. '
																		    'In order to use Torch DDP, launch your script with `python -m torch.distributed.launch'       )
											if self.no_cuda:
																		SCREAMING_SNAKE_CASE_				=				torch.device('cpu'       )
																		SCREAMING_SNAKE_CASE_				=				0
											elif is_sagemaker_model_parallel_available():
																		SCREAMING_SNAKE_CASE_				=				smp.local_rank()
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda',     _lowercase       )
																		SCREAMING_SNAKE_CASE_				=				1
											elif is_sagemaker_dp_enabled():
																		import smdistributed.dataparallel.torch.torch_smddp  # noqa: F401

																		torch.distributed.init_process_group(backend='smddp',     timeout=self.ddp_timeout_delta       )
																		SCREAMING_SNAKE_CASE_				=				int(os.getenv('SMDATAPARALLEL_LOCAL_RANK'       )       )
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda',     self.local_rank       )
																		SCREAMING_SNAKE_CASE_				=				1
											elif self.local_rank == -1:
																		# if n_gpu is > 1 we'll use nn.DataParallel.
																		# If you only want to use a specific subset of GPUs use `CUDA_VISIBLE_DEVICES=0`
																		# Explicitly set CUDA to the first (index 0) CUDA device, otherwise `set_device` will
																		# trigger an error that a device index is missing. Index 0 takes into account the
																		# GPUs available in the environment, so `CUDA_VISIBLE_DEVICES=1,2` with `cuda:0`
																		# will use the first GPU in that env, i.e. GPU#1
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda:0' if torch.cuda.is_available() else 'cpu'       )
																		# Sometimes the line in the postinit has not been run before we end up here, so just checking we're not at
																		# the default value.
																		SCREAMING_SNAKE_CASE_				=				torch.cuda.device_count()
											else:
																		# Here, we'll use torch.distributed.
																		# Initializes the distributed backend which will take care of synchronizing nodes/GPUs
																		if not torch.distributed.is_initialized():
																									torch.distributed.init_process_group(backend='nccl',     timeout=self.ddp_timeout_delta       )
																		SCREAMING_SNAKE_CASE_				=				torch.device('cuda',     self.local_rank       )
																		SCREAMING_SNAKE_CASE_				=				1

											if device.type == "cuda":
																		torch.cuda.set_device(_lowercase       )

											return device



				@property
				def   a__					(    self       )     ->							Optional[Any]:
											if is_sagemaker_model_parallel_available():
																		return smp.dp_size()

											return super().world_size



				@property
				def   a__					(    self       )     ->							Optional[Any]:
											return not is_sagemaker_model_parallel_available()





				@property
				def   a__					(    self       )     ->							Tuple:
											return False





