




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		):
   UpperCAmelCase__  :    Optional[Any]          =  BertJapaneseTokenizer
   UpperCAmelCase__  :    str          =  False
   UpperCAmelCase__  :    int          =  True







   def lowerCamelCase						(      self		:						Tuple):

        """simple docstring"""


        super().setUp()

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

        UpperCAmelCase_          =							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		:						Optional[int]					,						_snake_case		:						Union[str, Any]):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						Union[str, Any]					,						_snake_case		:						List[str]):

        """simple docstring"""


        UpperCAmelCase_     ,       UpperCAmelCase_          =							self.get_input_output_texts(_snake_case)
        UpperCAmelCase_          =							tokenizer.encode(_snake_case					,						add_special_tokens=_snake_case)
        UpperCAmelCase_          =							tokenizer.decode(_snake_case					,						clean_up_tokenization_spaces=_snake_case)
        return text, ids







   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        pass  # TODO add if relevant







   def lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


        pass  # TODO add if relevant







   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


        pass  # TODO add if relevant







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


        UpperCAmelCase_          =							self.tokenizer_class(self.vocab_file)

        UpperCAmelCase_          =							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 lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


        UpperCAmelCase_          =							self.tokenizer_class(self.vocab_file					,						word_tokenizer_type='''mecab''')
        self.assertIsNotNone(_snake_case)

        UpperCAmelCase_          =							'''こんにちは、世界。\nこんばんは、世界。'''
        UpperCAmelCase_          =							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])

        UpperCAmelCase_          =							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:
             UpperCAmelCase_          =							pickle.load(_snake_case)

        UpperCAmelCase_          =							tokenizer_new.tokenize(_snake_case)

        self.assertListEqual(_snake_case					,						_snake_case)







   def lowerCamelCase						(      self		:						Any):

        """simple docstring"""


        UpperCAmelCase_          =							MecabTokenizer(mecab_dic='''ipadic''')

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







   def lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


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

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







   def lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


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

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







   def lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


        UpperCAmelCase_          =							MecabTokenizer(do_lower_case=_snake_case					,						mecab_dic='''ipadic''')

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







   def lowerCamelCase						(      self		:						int):

        """simple docstring"""


        try:
             UpperCAmelCase_          =							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 lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


        UpperCAmelCase_          =							MecabTokenizer(normalize_text=_snake_case					,						mecab_dic='''ipadic''')

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







   @require_sudachi
   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        UpperCAmelCase_          =							self.tokenizer_class(self.vocab_file					,						word_tokenizer_type='''sudachi''')
        self.assertIsNotNone(_snake_case)

        UpperCAmelCase_          =							'''こんにちは、世界。\nこんばんは、世界。'''
        UpperCAmelCase_          =							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])

        UpperCAmelCase_          =							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:
             UpperCAmelCase_          =							pickle.load(_snake_case)

        UpperCAmelCase_          =							tokenizer_new.tokenize(_snake_case)

        self.assertListEqual(_snake_case					,						_snake_case)







   @require_sudachi
   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        UpperCAmelCase_          =							SudachiTokenizer(sudachi_dict_type='''core''')

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







   @require_sudachi
   def lowerCamelCase						(      self		:						Tuple):

        """simple docstring"""


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

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







   @require_sudachi
   def lowerCamelCase						(      self		:						Union[str, Any]):

        """simple docstring"""


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

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







   @require_sudachi
   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


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

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







   @require_sudachi
   def lowerCamelCase						(      self		:						Tuple):

        """simple docstring"""


        UpperCAmelCase_          =							SudachiTokenizer(do_lower_case=_snake_case					,						sudachi_dict_type='''core''')

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







   @require_sudachi
   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


        UpperCAmelCase_          =							SudachiTokenizer(normalize_text=_snake_case					,						sudachi_dict_type='''core''')

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







   @require_sudachi
   def lowerCamelCase						(      self		:						Union[str, Any]):

        """simple docstring"""


        UpperCAmelCase_          =							SudachiTokenizer(trim_whitespace=_snake_case					,						sudachi_dict_type='''core''')

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







   @require_jumanpp
   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


        UpperCAmelCase_          =							self.tokenizer_class(self.vocab_file					,						word_tokenizer_type='''jumanpp''')
        self.assertIsNotNone(_snake_case)

        UpperCAmelCase_          =							'''こんにちは、世界。\nこんばんは、世界。'''
        UpperCAmelCase_          =							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])

        UpperCAmelCase_          =							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:
             UpperCAmelCase_          =							pickle.load(_snake_case)

        UpperCAmelCase_          =							tokenizer_new.tokenize(_snake_case)

        self.assertListEqual(_snake_case					,						_snake_case)







   @require_jumanpp
   def lowerCamelCase						(      self		:						Tuple):

        """simple docstring"""


        UpperCAmelCase_          =							JumanppTokenizer()

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







   @require_jumanpp
   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


        UpperCAmelCase_          =							JumanppTokenizer(do_lower_case=_snake_case)

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







   @require_jumanpp
   def lowerCamelCase						(      self		:						Any):

        """simple docstring"""


        UpperCAmelCase_          =							JumanppTokenizer(normalize_text=_snake_case)

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







   @require_jumanpp
   def lowerCamelCase						(      self		:						Tuple):

        """simple docstring"""


        UpperCAmelCase_          =							JumanppTokenizer(trim_whitespace=_snake_case)

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







   @require_jumanpp
   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


        UpperCAmelCase_          =							JumanppTokenizer()

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







   def lowerCamelCase						(      self		:						Any):

        """simple docstring"""


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

        UpperCAmelCase_          =							{}
        for i, token in enumerate(_snake_case):
             UpperCAmelCase_          =							i
        UpperCAmelCase_          =							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 lowerCamelCase						(      self		:						Optional[int]):

        """simple docstring"""


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

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

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







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


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

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

        UpperCAmelCase_          =							tokenizer.build_inputs_with_special_tokens(_snake_case)
        UpperCAmelCase_          =							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 __snake_case			(			a ,  unittest.TestCase		):
   UpperCAmelCase__  :    Optional[int]          =  BertJapaneseTokenizer
   UpperCAmelCase__  :    Optional[int]          =  False







   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


        super().setUp()

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

        UpperCAmelCase_          =							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		:						Any					,						**_snake_case		:						Dict):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						Optional[Any]					,						_snake_case		:						Dict):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


        pass  # TODO add if relevant







   def lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


        pass  # TODO add if relevant







   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        pass  # TODO add if relevant







   def lowerCamelCase						(      self		:						Any):

        """simple docstring"""


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

        UpperCAmelCase_          =							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 lowerCamelCase						(      self		:						int):

        """simple docstring"""


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

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

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

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

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







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


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

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

        UpperCAmelCase_          =							tokenizer.build_inputs_with_special_tokens(_snake_case)
        UpperCAmelCase_          =							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 __snake_case			(			unittest.TestCase		):







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


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







class __snake_case			(			unittest.TestCase		):







   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        UpperCAmelCase_          =							'''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.'''))
        UpperCAmelCase_          =							'''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.'''))













from typing import Any, Dict, List, Union

from ..utils import add_end_docstrings, is_torch_available, is_vision_available, logging, requires_backends
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_vision_available():
      from ..image_utils import load_image


if is_torch_available():
      import torch

      from ..models.auto.modeling_auto import MODEL_FOR_OBJECT_DETECTION_MAPPING, MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING

__UpperCAmelCase       :   Any				       =							logging.get_logger(__name__)


__UpperCAmelCase       :   str				       =							Dict[str, Any]
__UpperCAmelCase       :   int				       =							List[Prediction]







@add_end_docstrings(__lowerCamelCase			)
class     __snake_case       (							__lowerCamelCase			):





       '''simple docstring'''







       def __init__(  self :    int							,				*A :    Optional[int]							,				**A :    Optional[int]		):
         super().__init__(*A							,				**A		)

         if self.framework == "tf":
           raise ValueError(f'''The {self.__class__} is only available in PyTorch.'''		)

         requires_backends(self							,				"""vision"""		)
         self.check_model_type(
             dict(MODEL_FOR_OBJECT_DETECTION_MAPPING.items() + MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING.items()		)		)




       def 							UpperCAmelCase__ (  self :    List[str]							,				**A :    Tuple		):
         __snake_case:						List[str]   =						{}
         if "threshold" in kwargs:
           __snake_case:						Optional[Any]   =						kwargs["""threshold"""]
         return {}, {}, postprocess_kwargs




       def __call__(  self :    int							,				*A :    Optional[Any]							,				**A :    Tuple		):
         return super().__call__(*A							,				**A		)




       def 							UpperCAmelCase__ (  self :    Optional[int]							,				A :    str		):
         __snake_case:						Optional[Any]   =						load_image(A		)
         __snake_case:						Dict   =						torch.IntTensor([[image.height, image.width]]		)
         __snake_case:						str   =						self.image_processor(images=[image]							,				return_tensors="""pt"""		)
         if self.tokenizer is not None:
           __snake_case:						Optional[Any]   =						self.tokenizer(text=inputs["""words"""]							,				boxes=inputs["""boxes"""]							,				return_tensors="""pt"""		)
         __snake_case:						Any   =						target_size
         return inputs




       def 							UpperCAmelCase__ (  self :    Optional[int]							,				A :    Dict		):
         __snake_case:						int   =						model_inputs.pop("""target_size"""		)
         __snake_case:						int   =						self.model(**A		)
         __snake_case:						Any   =						outputs.__class__({"""target_size""": target_size, **outputs}		)
         if self.tokenizer is not None:
           __snake_case:						Optional[int]   =						model_inputs["""bbox"""]
         return model_outputs




       def 							UpperCAmelCase__ (  self :    List[Any]							,				A :    Optional[int]							,				A :    Union[str, Any]=0.9		):
         __snake_case:						Optional[Any]   =						model_outputs["""target_size"""]
         if self.tokenizer is not None:
           # This is a LayoutLMForTokenClassification variant.
           # The OCR got the boxes and the model classified the words.
           __snake_case  ,   __snake_case:						Union[str, Any]   =						target_size[0].tolist()

           def unnormalize(A :    Tuple		):
             return self._get_bounding_box(
                 torch.Tensor(
                     [
                         (width * bbox[0] / 1_000),
                         (height * bbox[1] / 1_000),
                         (width * bbox[2] / 1_000),
                         (height * bbox[3] / 1_000),
                     ]		)		)

           __snake_case  ,   __snake_case:						Optional[int]   =						model_outputs["""logits"""].squeeze(0		).softmax(dim=-1		).max(dim=-1		)
           __snake_case:						List[Any]   =						[self.model.config.idalabel[prediction] for prediction in classes.tolist()]
           __snake_case:						int   =						[unnormalize(A		) for bbox in model_outputs["""bbox"""].squeeze(0		)]
           __snake_case:						int   =						["""score""", """label""", """box"""]
           __snake_case:						List[Any]   =						[dict(zip(A							,				A		)		) for vals in zip(scores.tolist()							,				A							,				A		) if vals[0] > threshold]
         else:
           # This is a regular ForObjectDetectionModel
           __snake_case:						Tuple   =						self.image_processor.post_process_object_detection(A							,				A							,				A		)
           __snake_case:						Optional[Any]   =						raw_annotations[0]
           __snake_case:						int   =						raw_annotation["""scores"""]
           __snake_case:						int   =						raw_annotation["""labels"""]
           __snake_case:						Optional[Any]   =						raw_annotation["""boxes"""]

           __snake_case:						Union[str, Any]   =						scores.tolist()
           __snake_case:						List[str]   =						[self.model.config.idalabel[label.item()] for label in labels]
           __snake_case:						List[str]   =						[self._get_bounding_box(A		) for box in boxes]

           # {"scores": [...], ...} --> [{"score":x, ...}, ...]
           __snake_case:						List[Any]   =						["""score""", """label""", """box"""]
           __snake_case:						Dict   =						[
               dict(zip(A							,				A		)		)
               for vals in zip(raw_annotation["""scores"""]							,				raw_annotation["""labels"""]							,				raw_annotation["""boxes"""]		)
           ]

         return annotation






       def 							UpperCAmelCase__ (  self :    Optional[Any]							,				A :    "torch.Tensor"		):
         if self.framework != "pt":
           raise ValueError("""The ObjectDetectionPipeline is only available in PyTorch."""		)
         __snake_case  ,   __snake_case  ,   __snake_case  ,   __snake_case:						Union[str, Any]   =						box.int().tolist()
         __snake_case:						Optional[Any]   =						{
             """xmin""": xmin,
             """ymin""": ymin,
             """xmax""": xmax,
             """ymax""": ymax,
         }
         return bbox






