





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







					'''simple docstring'''




					__lowerCAmelCase					=					BertJapaneseTokenizer
					__lowerCAmelCase					=					False
					__lowerCAmelCase					=					True







					def 	_lowerCamelCase						(  self       ):
									super().setUp()

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

									__a	:  str         =					os.path.join(self.tmpdirname		,     VOCAB_FILES_NAMES['''vocab_file''']       )
									with open(self.vocab_file		,     '''w'''		,     encoding='''utf-8'''       ) as vocab_writer:
													vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]       )       )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									__a	:  Dict         =					'こんにちは、世界。 \nこんばんは、世界。'
									__a	:  Tuple         =					'こんにちは 、 世界 。 こんばんは 、 世界 。'
									return input_text, output_text







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									__a	:  Dict         =					self.get_input_output_texts(__a       )
									__a	:  List[str]         =					tokenizer.encode(__a		,     add_special_tokens=__a       )
									__a	:  int         =					tokenizer.decode(__a		,     clean_up_tokenization_spaces=__a       )
									return text, ids







					def 	_lowerCamelCase						(  self       ):
									pass  # TODO add if relevant







					def 	_lowerCamelCase						(  self       ):
									pass  # TODO add if relevant







					def 	_lowerCamelCase						(  self       ):
									pass  # TODO add if relevant







					def 	_lowerCamelCase						(  self       ):
									__a	:  str         =					self.tokenizer_class(self.vocab_file       )

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					self.tokenizer_class(self.vocab_file		,     word_tokenizer_type='''mecab'''       )
									self.assertIsNotNone(__a       )

									__a	:  Optional[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	:  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	:  Any         =					pickle.load(__a       )

									__a	:  Dict         =					tokenizer_new.tokenize(__a       )

									self.assertListEqual(__a		,     __a       )







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					MecabTokenizer(mecab_dic='''ipadic'''       )

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







					def 	_lowerCamelCase						(  self       ):
									try:
													__a	:  int         =					MecabTokenizer(mecab_dic='''unidic_lite'''       )
									except ModuleNotFoundError:
													return

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







					def 	_lowerCamelCase						(  self       ):
									try:
													__a	:  Dict         =					MecabTokenizer(mecab_dic='''unidic'''       )
									except ModuleNotFoundError:
													return

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					MecabTokenizer(do_lower_case=__a		,     mecab_dic='''ipadic'''       )

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







					def 	_lowerCamelCase						(  self       ):
									try:
													__a	:  Union[str, 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 	_lowerCamelCase						(  self       ):
									__a	:  str         =					MecabTokenizer(normalize_text=__a		,     mecab_dic='''ipadic'''       )

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







					@require_sudachi
					def 	_lowerCamelCase						(  self       ):
									__a	:  Optional[Any]         =					self.tokenizer_class(self.vocab_file		,     word_tokenizer_type='''sudachi'''       )
									self.assertIsNotNone(__a       )

									__a	:  Union[str, Any]         =					'こんにちは、世界。\nこんばんは、世界。'
									__a	:  Optional[Any]         =					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[str]         =					os.path.join(self.tmpdirname		,     '''tokenizer.bin'''       )
									with open(__a		,     '''wb'''       ) as handle:
													pickle.dump(__a		,     __a       )

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

									__a	:  int         =					tokenizer_new.tokenize(__a       )

									self.assertListEqual(__a		,     __a       )







					@require_sudachi
					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					SudachiTokenizer(sudachi_dict_type='''core'''       )

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







					@require_sudachi
					def 	_lowerCamelCase						(  self       ):
									__a	:  Optional[int]         =					SudachiTokenizer(sudachi_dict_type='''core'''		,     sudachi_split_mode='''A'''       )

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







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

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







					@require_sudachi
					def 	_lowerCamelCase						(  self       ):
									__a	:  Union[str, Any]         =					SudachiTokenizer(sudachi_dict_type='''core'''		,     sudachi_split_mode='''C'''       )

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







					@require_sudachi
					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					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       ):
									__a	:  Dict         =					SudachiTokenizer(normalize_text=__a		,     sudachi_dict_type='''core'''       )

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







					@require_sudachi
					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					SudachiTokenizer(trim_whitespace=__a		,     sudachi_dict_type='''core'''       )

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







					@require_jumanpp
					def 	_lowerCamelCase						(  self       ):
									__a	:  int         =					self.tokenizer_class(self.vocab_file		,     word_tokenizer_type='''jumanpp'''       )
									self.assertIsNotNone(__a       )

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

									__a	:  Optional[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	:  List[str]         =					pickle.load(__a       )

									__a	:  Any         =					tokenizer_new.tokenize(__a       )

									self.assertListEqual(__a		,     __a       )







					@require_jumanpp
					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					JumanppTokenizer()

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







					@require_jumanpp
					def 	_lowerCamelCase						(  self       ):
									__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 	_lowerCamelCase						(  self       ):
									__a	:  Dict         =					JumanppTokenizer(normalize_text=__a       )

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







					@require_jumanpp
					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					JumanppTokenizer(trim_whitespace=__a       )

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







					@require_jumanpp
					def 	_lowerCamelCase						(  self       ):
									__a	:  Optional[Any]         =					JumanppTokenizer()

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					['[UNK]', '[CLS]', '[SEP]', 'こんにちは', 'こん', 'にちは', 'ばんは', '##こん', '##にちは', '##ばんは']

									__a	:  Any         =					{}
									for i, token in enumerate(__a       ):
													__a	:  str         =					i
									__a	:  List[Any]         =					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       ):
									__a	:  int         =					BertJapaneseTokenizer.from_pretrained('''nlp-waseda/roberta-base-japanese-with-auto-jumanpp'''       )
									__a	:  Dict         =					tokenizer.subword_tokenizer

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

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







					def 	_lowerCamelCase						(  self       ):
									__a	:  List[Any]         =					self.tokenizer_class.from_pretrained('''cl-tohoku/bert-base-japanese'''       )

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

									__a	:  Optional[int]         =					tokenizer.build_inputs_with_special_tokens(__a       )
									__a	:  Dict         =					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     (     SCREAMING_SNAKE_CASE_				, unittest.TestCase							):







					'''simple docstring'''




					__lowerCAmelCase					=					BertJapaneseTokenizer
					__lowerCAmelCase					=					False







					def 	_lowerCamelCase						(  self       ):
									super().setUp()

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

									__a	:  int         =					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		,     **_UpperCAmelCase       ):
									return BertJapaneseTokenizer.from_pretrained(self.tmpdirname		,     subword_tokenizer_type='''character'''		,     **__a       )







					def 	_lowerCamelCase						(  self		,     _UpperCAmelCase       ):
									__a	:  Dict         =					'こんにちは、世界。 \nこんばんは、世界。'
									__a	:  str         =					'こ ん に ち は 、 世 界 。 こ ん ば ん は 、 世 界 。'
									return input_text, output_text







					def 	_lowerCamelCase						(  self       ):
									pass  # TODO add if relevant







					def 	_lowerCamelCase						(  self       ):
									pass  # TODO add if relevant







					def 	_lowerCamelCase						(  self       ):
									pass  # TODO add if relevant







					def 	_lowerCamelCase						(  self       ):
									__a	:  Any         =					self.tokenizer_class(self.vocab_file		,     subword_tokenizer_type='''character'''       )

									__a	:  Any         =					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 	_lowerCamelCase						(  self       ):
									__a	:  Tuple         =					['[UNK]', '[CLS]', '[SEP]', 'こ', 'ん', 'に', 'ち', 'は', 'ば', '世', '界', '、', '。']

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

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

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

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







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

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

									__a	:  Union[str, Any]         =					tokenizer.build_inputs_with_special_tokens(__a       )
									__a	:  int         =					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       ):
									__a	:  Dict         =					'cl-tohoku/bert-base-japanese'
									__a	:  List[str]         =					AutoTokenizer.from_pretrained(__a       )
									self.assertIsInstance(__a		,     __a       )






class 			__lowercase     (     unittest.TestCase							):







					'''simple docstring'''




					def 	_lowerCamelCase						(  self       ):
									__a	:  Optional[int]         =					'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	:  str         =					'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"""






from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


A	     =					{
    '''configuration_instructblip''': [
        '''INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP''',
        '''InstructBlipConfig''',
        '''InstructBlipQFormerConfig''',
        '''InstructBlipVisionConfig''',
    ],
    '''processing_instructblip''': ['''InstructBlipProcessor'''],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		A	     =					[
		    '''INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST''',
		    '''InstructBlipQFormerModel''',
		    '''InstructBlipPreTrainedModel''',
		    '''InstructBlipForConditionalGeneration''',
		    '''InstructBlipVisionModel''',
		]

if TYPE_CHECKING:
		from .configuration_instructblip import (
		    INSTRUCTBLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
		    InstructBlipConfig,
		    InstructBlipQFormerConfig,
		    InstructBlipVisionConfig,
		)
		from .processing_instructblip import InstructBlipProcessor

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .modeling_instructblip import (
				    INSTRUCTBLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
				    InstructBlipForConditionalGeneration,
				    InstructBlipPreTrainedModel,
				    InstructBlipQFormerModel,
				    InstructBlipVisionModel,
				)

else:
		import sys

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