


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 					lowerCAmelCase_ (       _a			,unittest.TestCase):
						lowerCamelCase_         =     BertJapaneseTokenizer
						lowerCamelCase_         =     False
						lowerCamelCase_         =     True




						def  _snake_case					(	self						:   Optional[int]						)      ->str:






									"""simple docstring"""






									super().setUp()

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

									a__ :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  _snake_case					(	self						:   List[Any]   ,     __A						:   Optional[int]						)      ->List[Any]:






									"""simple docstring"""






									a__ :Any						  =    "こんにちは、世界。 \nこんばんは、世界。"
									a__ :List[str]						  =    "こんにちは 、 世界 。 こんばんは 、 世界 。"
									return input_text, output_text




						def  _snake_case					(	self						:   int   ,     __A						:   Any						)      ->List[Any]:






									"""simple docstring"""






									a__  ,  a__ :List[str]						  =    self.get_input_output_texts(__A						)
									a__ :List[Any]						  =    tokenizer.encode(__A   ,     add_special_tokens=__A						)
									a__ :Union[str, Any]						  =    tokenizer.decode(__A   ,     clean_up_tokenization_spaces=__A						)
									return text, ids




						def  _snake_case					(	self						:   List[str]						)      ->Optional[Any]:






									"""simple docstring"""






									pass  # TODO add if relevant




						def  _snake_case					(	self						:   List[str]						)      ->str:






									"""simple docstring"""






									pass  # TODO add if relevant




						def  _snake_case					(	self						:   Dict						)      ->int:






									"""simple docstring"""






									pass  # TODO add if relevant




						def  _snake_case					(	self						:   Tuple						)      ->List[str]:






									"""simple docstring"""






									a__ :Union[str, Any]						  =    self.tokenizer_class(self.vocab_file						)

									a__ :Optional[int]						  =    tokenizer.tokenize("こんにちは、世界。\nこんばんは、世界。"						)
									self.assertListEqual(__A   ,     ["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]						)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A						)   ,     [3, 12, 10, 14, 4, 9, 12, 10, 14]						)




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






									"""simple docstring"""






									a__ :Dict						  =    self.tokenizer_class(self.vocab_file   ,     word_tokenizer_type="mecab"						)
									self.assertIsNotNone(__A						)

									a__ :Union[str, Any]						  =    "こんにちは、世界。\nこんばんは、世界。"
									a__ :str						  =    tokenizer.tokenize(__A						)
									self.assertListEqual(__A   ,     ["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]						)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A						)   ,     [3, 12, 10, 14, 4, 9, 12, 10, 14]						)

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

									with open(__A   ,     "rb"						) as handle:
												a__ :Optional[Any]						  =    pickle.load(__A						)

									a__ :Optional[int]						  =    tokenizer_new.tokenize(__A						)

									self.assertListEqual(__A   ,     __A						)




						def  _snake_case					(	self						:   List[Any]						)      ->int:






									"""simple docstring"""






									a__ :Any						  =    MecabTokenizer(mecab_dic="ipadic"						)

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




						def  _snake_case					(	self						:   Any						)      ->Optional[int]:






									"""simple docstring"""






									try:
												a__ :List[Any]						  =    MecabTokenizer(mecab_dic="unidic_lite"						)
									except ModuleNotFoundError:
												return

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




						def  _snake_case					(	self						:   Tuple						)      ->Dict:






									"""simple docstring"""






									try:
												a__ :Union[str, Any]						  =    MecabTokenizer(mecab_dic="unidic"						)
									except ModuleNotFoundError:
												return

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




						def  _snake_case					(	self						:   int						)      ->Tuple:






									"""simple docstring"""






									a__ :str						  =    MecabTokenizer(do_lower_case=__A   ,     mecab_dic="ipadic"						)

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




						def  _snake_case					(	self						:   List[str]						)      ->List[Any]:






									"""simple docstring"""






									try:
												a__ :Any						  =    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  _snake_case					(	self						:   Optional[int]						)      ->int:






									"""simple docstring"""






									a__ :int						  =    MecabTokenizer(normalize_text=__A   ,     mecab_dic="ipadic"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   Dict						)      ->str:






									"""simple docstring"""






									a__ :int						  =    self.tokenizer_class(self.vocab_file   ,     word_tokenizer_type="sudachi"						)
									self.assertIsNotNone(__A						)

									a__ :List[Any]						  =    "こんにちは、世界。\nこんばんは、世界。"
									a__ :List[str]						  =    tokenizer.tokenize(__A						)
									self.assertListEqual(__A   ,     ["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]						)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A						)   ,     [3, 12, 10, 14, 4, 9, 12, 10, 14]						)

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

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

									a__ :Any						  =    tokenizer_new.tokenize(__A						)

									self.assertListEqual(__A   ,     __A						)




						@require_sudachi
						def  _snake_case					(	self						:   Union[str, Any]						)      ->Any:






									"""simple docstring"""






									a__ :Dict						  =    SudachiTokenizer(sudachi_dict_type="core"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   Optional[int]						)      ->Tuple:






									"""simple docstring"""






									a__ :Union[str, Any]						  =    SudachiTokenizer(sudachi_dict_type="core"   ,     sudachi_split_mode="A"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   Union[str, Any]						)      ->Tuple:






									"""simple docstring"""






									a__ :Dict						  =    SudachiTokenizer(sudachi_dict_type="core"   ,     sudachi_split_mode="B"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   Any						)      ->Optional[int]:






									"""simple docstring"""






									a__ :List[str]						  =    SudachiTokenizer(sudachi_dict_type="core"   ,     sudachi_split_mode="C"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   Tuple						)      ->Optional[int]:






									"""simple docstring"""






									a__ :Tuple						  =    SudachiTokenizer(do_lower_case=__A   ,     sudachi_dict_type="core"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   int						)      ->Optional[int]:






									"""simple docstring"""






									a__ :Tuple						  =    SudachiTokenizer(normalize_text=__A   ,     sudachi_dict_type="core"						)

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




						@require_sudachi
						def  _snake_case					(	self						:   Union[str, Any]						)      ->List[Any]:






									"""simple docstring"""






									a__ :int						  =    SudachiTokenizer(trim_whitespace=__A   ,     sudachi_dict_type="core"						)

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




						@require_jumanpp
						def  _snake_case					(	self						:   Tuple						)      ->List[str]:






									"""simple docstring"""






									a__ :Tuple						  =    self.tokenizer_class(self.vocab_file   ,     word_tokenizer_type="jumanpp"						)
									self.assertIsNotNone(__A						)

									a__ :Optional[int]						  =    "こんにちは、世界。\nこんばんは、世界。"
									a__ :str						  =    tokenizer.tokenize(__A						)
									self.assertListEqual(__A   ,     ["こんにちは", "、", "世界", "。", "こん", "##ばんは", "、", "世界", "。"]						)
									self.assertListEqual(tokenizer.convert_tokens_to_ids(__A						)   ,     [3, 12, 10, 14, 4, 9, 12, 10, 14]						)

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

									with open(__A   ,     "rb"						) as handle:
												a__ :Optional[Any]						  =    pickle.load(__A						)

									a__ :str						  =    tokenizer_new.tokenize(__A						)

									self.assertListEqual(__A   ,     __A						)




						@require_jumanpp
						def  _snake_case					(	self						:   Optional[int]						)      ->List[str]:






									"""simple docstring"""






									a__ :Tuple						  =    JumanppTokenizer()

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




						@require_jumanpp
						def  _snake_case					(	self						:   Any						)      ->Optional[int]:






									"""simple docstring"""






									a__ :Union[str, Any]						  =    JumanppTokenizer(do_lower_case=__A						)

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




						@require_jumanpp
						def  _snake_case					(	self						:   str						)      ->List[str]:






									"""simple docstring"""






									a__ :Dict						  =    JumanppTokenizer(normalize_text=__A						)

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




						@require_jumanpp
						def  _snake_case					(	self						:   Optional[int]						)      ->int:






									"""simple docstring"""






									a__ :Optional[int]						  =    JumanppTokenizer(trim_whitespace=__A						)

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




						@require_jumanpp
						def  _snake_case					(	self						:   Optional[int]						)      ->Any:






									"""simple docstring"""






									a__ :List[str]						  =    JumanppTokenizer()

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




						def  _snake_case					(	self						:   Tuple						)      ->List[Any]:






									"""simple docstring"""






									a__ :str						  =    ["[UNK]", "[CLS]", "[SEP]", "こんにちは", "こん", "にちは", "ばんは", "##こん", "##にちは", "##ばんは"]

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

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

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

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

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




						def  _snake_case					(	self						:   Dict						)      ->Any:






									"""simple docstring"""






									a__ :Optional[Any]						  =    BertJapaneseTokenizer.from_pretrained("nlp-waseda/roberta-base-japanese-with-auto-jumanpp"						)
									a__ :Dict						  =    tokenizer.subword_tokenizer

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

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






						def  _snake_case					(	self						:   Optional[int]						)      ->List[str]:






									"""simple docstring"""






									a__ :Tuple						  =    self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese"						)

									a__ :Union[str, Any]						  =    tokenizer.encode("ありがとう。"   ,     add_special_tokens=__A						)
									a__ :Optional[int]						  =    tokenizer.encode("どういたしまして。"   ,     add_special_tokens=__A						)

									a__ :Optional[Any]						  =    tokenizer.build_inputs_with_special_tokens(__A						)
									a__ :List[Any]						  =    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 					lowerCAmelCase_ (       _a			,unittest.TestCase):
						lowerCamelCase_         =     BertJapaneseTokenizer
						lowerCamelCase_         =     False




						def  _snake_case					(	self						:   Tuple						)      ->str:






									"""simple docstring"""






									super().setUp()

									a__ :Optional[int]						  =    ["[UNK]", "[CLS]", "[SEP]", "こ", "ん", "に", "ち", "は", "ば", "世", "界", "、", "。"]

									a__ :List[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  _snake_case					(	self						:   Optional[Any]   ,     **__A						:   Any						)      ->List[str]:






									"""simple docstring"""






									return BertJapaneseTokenizer.from_pretrained(self.tmpdirname   ,     subword_tokenizer_type="character"   ,     **__A						)




						def  _snake_case					(	self						:   Optional[Any]   ,     __A						:   Optional[int]						)      ->Tuple:






									"""simple docstring"""






									a__ :List[Any]						  =    "こんにちは、世界。 \nこんばんは、世界。"
									a__ :Union[str, Any]						  =    "こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。"
									return input_text, output_text




						def  _snake_case					(	self						:   Optional[Any]						)      ->Any:






									"""simple docstring"""






									pass  # TODO add if relevant




						def  _snake_case					(	self						:   Optional[int]						)      ->List[str]:






									"""simple docstring"""






									pass  # TODO add if relevant




						def  _snake_case					(	self						:   Dict						)      ->List[str]:






									"""simple docstring"""






									pass  # TODO add if relevant




						def  _snake_case					(	self						:   Union[str, Any]						)      ->int:






									"""simple docstring"""






									a__ :Dict						  =    self.tokenizer_class(self.vocab_file   ,     subword_tokenizer_type="character"						)

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




						def  _snake_case					(	self						:   Optional[int]						)      ->int:






									"""simple docstring"""






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

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

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

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

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






						def  _snake_case					(	self						:   Any						)      ->List[str]:






									"""simple docstring"""






									a__ :Dict						  =    self.tokenizer_class.from_pretrained("cl-tohoku/bert-base-japanese-char"						)

									a__ :int						  =    tokenizer.encode("ありがとう。"   ,     add_special_tokens=__A						)
									a__ :Optional[int]						  =    tokenizer.encode("どういたしまして。"   ,     add_special_tokens=__A						)

									a__ :Union[str, Any]						  =    tokenizer.build_inputs_with_special_tokens(__A						)
									a__ :Tuple						  =    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 					lowerCAmelCase_ (       unittest.TestCase):




						def  _snake_case					(	self						:   str						)      ->Union[str, Any]:






									"""simple docstring"""






									a__ :Any						  =    "cl-tohoku/bert-base-japanese"
									a__ :Dict						  =    AutoTokenizer.from_pretrained(__A						)
									self.assertIsInstance(__A   ,     __A						)






class 					lowerCAmelCase_ (       unittest.TestCase):




						def  _snake_case					(	self						:   List[Any]						)      ->int:






									"""simple docstring"""






									a__ :List[Any]						  =    "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."						)						)
									a__ :Any						  =    "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."						)						)






# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case__			 =						{
    '''configuration_mgp_str''': ['''MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''MgpstrConfig'''],
    '''processing_mgp_str''': ['''MgpstrProcessor'''],
    '''tokenization_mgp_str''': ['''MgpstrTokenizer'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		snake_case__			 =						[
		    '''MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''MgpstrModel''',
		    '''MgpstrPreTrainedModel''',
		    '''MgpstrForSceneTextRecognition''',
		]

if TYPE_CHECKING:
		from .configuration_mgp_str import MGP_STR_PRETRAINED_CONFIG_ARCHIVE_MAP, MgpstrConfig
		from .processing_mgp_str import MgpstrProcessor
		from .tokenization_mgp_str import MgpstrTokenizer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_mgp_str import (
				    MGP_STR_PRETRAINED_MODEL_ARCHIVE_LIST,
				    MgpstrForSceneTextRecognition,
				    MgpstrModel,
				    MgpstrPreTrainedModel,
				)
else:
		import sys

		snake_case__			 =						_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)


