




'''simple docstring'''



import os
import pickle
import unittest

from transformers import AutoTokenizer
from transformers.models.bert.tokenization_bert import BertTokenizer
from transformers.models.bert_japanese.tokenization_bert_japanese import (
    VOCAB_FILES_NAMES,
    BertJapaneseTokenizer,
    CharacterTokenizer,
    JumanppTokenizer,
    MecabTokenizer,
    SudachiTokenizer,
    WordpieceTokenizer,
)
from transformers.testing_utils import custom_tokenizers, require_jumanpp, require_sudachi

from ...test_tokenization_common import TokenizerTesterMixin







@custom_tokenizers
class 		lowercase_   (			lowerCAmelCase__					,  unittest.TestCase       ):


   """simple docstring"""

   lowerCamelCase_      =						BertJapaneseTokenizer
   lowerCamelCase_      =						False
   lowerCamelCase_      =						True



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      super().setUp()

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

      _SCREAMING_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 							lowerCAmelCase_      (   self :     str  ,				__lowerCamelCase :     int   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				"こんにちは、世界。 \nこんばんは、世界。"
      _SCREAMING_SNAKE_CASE	=				"こんにちは 、 世界 。 こんばんは 、 世界 。"
      return input_text, output_text



   def 							lowerCAmelCase_      (   self :     Optional[int]  ,				__lowerCamelCase :     Union[str, Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE,	_SCREAMING_SNAKE_CASE	=				self.get_input_output_texts(a__   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.encode(a__  ,				add_special_tokens=a__   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.decode(a__  ,				clean_up_tokenization_spaces=a__   )
      return text, ids



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      pass  # TODO add if relevant



   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

      """simple docstring"""
      pass  # TODO add if relevant



   def 							lowerCAmelCase_      (   self :     int   ):

      """simple docstring"""
      pass  # TODO add if relevant



   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class(self.vocab_file   )

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



   def 							lowerCAmelCase_      (   self :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class(self.vocab_file  ,				word_tokenizer_type="mecab"   )
      self.assertIsNotNone(a__   )

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

      _SCREAMING_SNAKE_CASE	=				os.path.join(self.tmpdirname  ,				"tokenizer.bin"   )
      with open(a__  ,				"wb"   ) as handle:
         pickle.dump(a__  ,				a__   )

      with open(a__  ,				"rb"   ) as handle:
         _SCREAMING_SNAKE_CASE	=				pickle.load(a__   )

      _SCREAMING_SNAKE_CASE	=				tokenizer_new.tokenize(a__   )

      self.assertListEqual(a__  ,				a__   )



   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				MecabTokenizer(mecab_dic="ipadic"   )

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



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      try:
         _SCREAMING_SNAKE_CASE	=				MecabTokenizer(mecab_dic="unidic_lite"   )
      except ModuleNotFoundError:
         return

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



   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""
      try:
         _SCREAMING_SNAKE_CASE	=				MecabTokenizer(mecab_dic="unidic"   )
      except ModuleNotFoundError:
         return

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



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				MecabTokenizer(do_lower_case=a__  ,				mecab_dic="ipadic"   )

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



   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      try:
         _SCREAMING_SNAKE_CASE	=				MecabTokenizer(
             do_lower_case=a__  ,				normalize_text=a__  ,				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"""
      _SCREAMING_SNAKE_CASE	=				MecabTokenizer(normalize_text=a__  ,				mecab_dic="ipadic"   )

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



   @require_sudachi
   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class(self.vocab_file  ,				word_tokenizer_type="sudachi"   )
      self.assertIsNotNone(a__   )

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

      _SCREAMING_SNAKE_CASE	=				os.path.join(self.tmpdirname  ,				"tokenizer.bin"   )
      with open(a__  ,				"wb"   ) as handle:
         pickle.dump(a__  ,				a__   )

      with open(a__  ,				"rb"   ) as handle:
         _SCREAMING_SNAKE_CASE	=				pickle.load(a__   )

      _SCREAMING_SNAKE_CASE	=				tokenizer_new.tokenize(a__   )

      self.assertListEqual(a__  ,				a__   )



   @require_sudachi
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(sudachi_dict_type="core"   )

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



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(sudachi_dict_type="core"  ,				sudachi_split_mode="A"   )

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



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(sudachi_dict_type="core"  ,				sudachi_split_mode="B"   )

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



   @require_sudachi
   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(sudachi_dict_type="core"  ,				sudachi_split_mode="C"   )

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



   @require_sudachi
   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(do_lower_case=a__  ,				sudachi_dict_type="core"   )

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



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(normalize_text=a__  ,				sudachi_dict_type="core"   )

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



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				SudachiTokenizer(trim_whitespace=a__  ,				sudachi_dict_type="core"   )

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



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class(self.vocab_file  ,				word_tokenizer_type="jumanpp"   )
      self.assertIsNotNone(a__   )

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

      _SCREAMING_SNAKE_CASE	=				os.path.join(self.tmpdirname  ,				"tokenizer.bin"   )
      with open(a__  ,				"wb"   ) as handle:
         pickle.dump(a__  ,				a__   )

      with open(a__  ,				"rb"   ) as handle:
         _SCREAMING_SNAKE_CASE	=				pickle.load(a__   )

      _SCREAMING_SNAKE_CASE	=				tokenizer_new.tokenize(a__   )

      self.assertListEqual(a__  ,				a__   )



   @require_jumanpp
   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				JumanppTokenizer()

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



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

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				JumanppTokenizer(do_lower_case=a__   )

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



   @require_jumanpp
   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				JumanppTokenizer(normalize_text=a__   )

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



   @require_jumanpp
   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				JumanppTokenizer(trim_whitespace=a__   )

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



   @require_jumanpp
   def 							lowerCAmelCase_      (   self :     Any   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				JumanppTokenizer()

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



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

      _SCREAMING_SNAKE_CASE	=				{}
      for i, token in enumerate(a__   ):
         _SCREAMING_SNAKE_CASE	=				i
      _SCREAMING_SNAKE_CASE	=				WordpieceTokenizer(vocab=a__  ,				unk_token="[UNK]"   )

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

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

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

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



   def 							lowerCAmelCase_      (   self :     Union[str, Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				BertJapaneseTokenizer.from_pretrained("nlp-waseda/roberta-base-japanese-with-auto-jumanpp"   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.subword_tokenizer

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

      _SCREAMING_SNAKE_CASE	=				subword_tokenizer.tokenize("こんばんは こんばん にち は こんにちは"   )
      self.assertListEqual(a__  ,				["▁こん", "ばん", "は", "▁こん", "ばん", "▁に", "ち", "▁は", "▁こんにちは"]   )



   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese"   )

      _SCREAMING_SNAKE_CASE	=				tokenizer.encode("ありがとう。"  ,				add_special_tokens=a__   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.encode("どういたしまして。"  ,				add_special_tokens=a__   )

      _SCREAMING_SNAKE_CASE	=				tokenizer.build_inputs_with_special_tokens(a__   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.build_inputs_with_special_tokens(a__  ,				a__   )

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


   """simple docstring"""

   lowerCamelCase_      =						BertJapaneseTokenizer
   lowerCamelCase_      =						False



   def 							lowerCAmelCase_      (   self :     str   ):

      """simple docstring"""
      super().setUp()

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

      _SCREAMING_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 							lowerCAmelCase_      (   self :     Any  ,				**__lowerCamelCase :     int   ):

      """simple docstring"""
      return BertJapaneseTokenizer.from_pretrained(self.tmpdirname  ,				subword_tokenizer_type="character"  ,				**a__   )



   def 							lowerCAmelCase_      (   self :     Tuple  ,				__lowerCamelCase :     Union[str, Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				"こんにちは、世界。 \nこんばんは、世界。"
      _SCREAMING_SNAKE_CASE	=				"こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
      return input_text, output_text



   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      pass  # TODO add if relevant



   def 							lowerCAmelCase_      (   self :     Dict   ):

      """simple docstring"""
      pass  # TODO add if relevant



   def 							lowerCAmelCase_      (   self :     Optional[Any]   ):

      """simple docstring"""
      pass  # TODO add if relevant



   def 							lowerCAmelCase_      (   self :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class(self.vocab_file  ,				subword_tokenizer_type="character"   )

      _SCREAMING_SNAKE_CASE	=				tokenizer.tokenize("こんにちは、世界。 \nこんばんは、世界。"   )
      self.assertListEqual(
          a__  ,				["こ", "ん", "に", "ち", "は", "、", "世", "界", "。", "こ", "ん", "ば", "ん", "は", "、", "世", "界", "。"]   )
      self.assertListEqual(
          tokenizer.convert_tokens_to_ids(a__   )  ,				[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 :     List[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

      _SCREAMING_SNAKE_CASE	=				{}
      for i, token in enumerate(a__   ):
         _SCREAMING_SNAKE_CASE	=				i
      _SCREAMING_SNAKE_CASE	=				CharacterTokenizer(vocab=a__  ,				unk_token="[UNK]"   )

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

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

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



   def 							lowerCAmelCase_      (   self :     Optional[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese-char"   )

      _SCREAMING_SNAKE_CASE	=				tokenizer.encode("ありがとう。"  ,				add_special_tokens=a__   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.encode("どういたしまして。"  ,				add_special_tokens=a__   )

      _SCREAMING_SNAKE_CASE	=				tokenizer.build_inputs_with_special_tokens(a__   )
      _SCREAMING_SNAKE_CASE	=				tokenizer.build_inputs_with_special_tokens(a__  ,				a__   )

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


   """simple docstring"""

   def 							lowerCAmelCase_      (   self :     Optional[Any]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				"cl-tohoku/bert-base-japanese"
      _SCREAMING_SNAKE_CASE	=				AutoTokenizer.from_pretrained(a__   )
      self.assertIsInstance(a__  ,				a__   )







class 		lowercase_   (			unittest.TestCase       ):


   """simple docstring"""

   def 							lowerCAmelCase_      (   self :     Tuple   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				"cl-tohoku/bert-base-japanese"
      with self.assertLogs("transformers"  ,				level="WARNING"   ) as cm:
         BertTokenizer.from_pretrained(a__   )
         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."   )   )
      _SCREAMING_SNAKE_CASE	=				"bert-base-cased"
      with self.assertLogs("transformers"  ,				level="WARNING"   ) as cm:
         BertJapaneseTokenizer.from_pretrained(a__   )
         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'''



lowerCamelCase_			=						'Tobias Carryer'

from time import time







class 		lowercase_   :


   """simple docstring"""

   def __init__(   self :     Tuple  ,				__lowerCamelCase :     int  ,				__lowerCamelCase :     List[Any]  ,				__lowerCamelCase :     Optional[int]  ,				__lowerCamelCase :     Dict=int(time()   )   ):  # noqa: B008

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				multiplier
      _SCREAMING_SNAKE_CASE	=				increment
      _SCREAMING_SNAKE_CASE	=				modulo
      _SCREAMING_SNAKE_CASE	=				seed



   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				(self.multiplier * self.seed + self.increment) % self.modulo
      return self.seed


if __name__ == "__main__":
 # Show the LCG in action.
 lowerCamelCase_			=						LinearCongruentialGenerator(1_66_45_25, 10_13_90_42_23, 2 << 31)
 while True:
  print(lcg.next_number())

