






import os
import shutil
import sys
import tempfile
import unittest
from pathlib import Path

import pytest

import transformers
from transformers import (
    BERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
    GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP,
    AutoTokenizer,
    BertConfig,
    BertTokenizer,
    BertTokenizerFast,
    CTRLTokenizer,
    GPTaTokenizer,
    GPTaTokenizerFast,
    PreTrainedTokenizerFast,
    RobertaTokenizer,
    RobertaTokenizerFast,
    is_tokenizers_available,
)
from transformers.models.auto.configuration_auto import CONFIG_MAPPING, AutoConfig
from transformers.models.auto.tokenization_auto import (
    TOKENIZER_MAPPING,
    get_tokenizer_config,
    tokenizer_class_from_name,
)
from transformers.models.roberta.configuration_roberta import RobertaConfig
from transformers.testing_utils import (
    DUMMY_DIFF_TOKENIZER_IDENTIFIER,
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tokenizers,
    slow,
)


sys.path.append(str(Path(__file__).parent.parent.parent.parent / "utils"))

from test_module.custom_configuration import CustomConfig  # noqa E402
from test_module.custom_tokenization import CustomTokenizer  # noqa E402


if is_tokenizers_available():
       from test_module.custom_tokenization_fast import CustomTokenizerFast
class     a    ( unittest.TestCase   ):



      """simple docstring"""


      def 	UpperCAmelCase      (      self					:			List[str]					)							->      Optional[Any]:
        __UpperCAmelCase							:	Tuple           =  0
      @slow
      def 	UpperCAmelCase      (      self					:			List[Any]					)							->      Dict:
        for model_name in (x for x in BERT_PRETRAINED_CONFIG_ARCHIVE_MAP.keys() if "japanese" not in x):
          __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(A_					)
          self.assertIsNotNone(A_					)
          self.assertIsInstance(A_		,      (BertTokenizer, BertTokenizerFast)					)
          self.assertGreater(len(A_					)		,      0					)

        for model_name in GPT2_PRETRAINED_CONFIG_ARCHIVE_MAP.keys():
          __UpperCAmelCase							:	int           =  AutoTokenizer.from_pretrained(A_					)
          self.assertIsNotNone(A_					)
          self.assertIsInstance(A_		,      (GPTaTokenizer, GPTaTokenizerFast)					)
          self.assertGreater(len(A_					)		,      0					)
      def 	UpperCAmelCase      (      self					:			Any					)							->      Optional[Any]:
        __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(A_					)
        self.assertIsInstance(A_		,      (BertTokenizer, BertTokenizerFast)					)
        self.assertEqual(tokenizer.vocab_size		,      12					)
      def 	UpperCAmelCase      (      self					:			Optional[Any]					)							->      Optional[int]:
        __UpperCAmelCase							:	str           =  AutoTokenizer.from_pretrained(A_					)
        self.assertIsInstance(A_		,      (RobertaTokenizer, RobertaTokenizerFast)					)
        self.assertEqual(tokenizer.vocab_size		,      20					)
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      List[Any]:
        __UpperCAmelCase							:	Optional[int]           =  AutoConfig.from_pretrained(A_					)
        self.assertIsInstance(A_		,      A_					)
        # Check that tokenizer_type ≠ model_type
        __UpperCAmelCase							:	str           =  AutoTokenizer.from_pretrained(A_		,      config=A_					)
        self.assertIsInstance(A_		,      (BertTokenizer, BertTokenizerFast)					)
        self.assertEqual(tokenizer.vocab_size		,      12					)
      def 	UpperCAmelCase      (      self					:			Dict					)							->      str:
        with tempfile.TemporaryDirectory() as tmp_dir:
          shutil.copy("""./tests/fixtures/vocab.txt"""		,      os.path.join(A_		,      """vocab.txt"""					)					)

          __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(A_		,      tokenizer_type="""bert"""		,      use_fast=A_					)
          self.assertIsInstance(A_		,      A_					)

        with tempfile.TemporaryDirectory() as tmp_dir:
          shutil.copy("""./tests/fixtures/vocab.json"""		,      os.path.join(A_		,      """vocab.json"""					)					)
          shutil.copy("""./tests/fixtures/merges.txt"""		,      os.path.join(A_		,      """merges.txt"""					)					)

          __UpperCAmelCase							:	List[str]           =  AutoTokenizer.from_pretrained(A_		,      tokenizer_type="""gpt2"""		,      use_fast=A_					)
          self.assertIsInstance(A_		,      A_					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			Tuple					)							->      Optional[int]:
        with tempfile.TemporaryDirectory() as tmp_dir:
          shutil.copy("""./tests/fixtures/vocab.txt"""		,      os.path.join(A_		,      """vocab.txt"""					)					)

          __UpperCAmelCase							:	List[str]           =  AutoTokenizer.from_pretrained(A_		,      tokenizer_type="""bert"""					)
          self.assertIsInstance(A_		,      A_					)

        with tempfile.TemporaryDirectory() as tmp_dir:
          shutil.copy("""./tests/fixtures/vocab.json"""		,      os.path.join(A_		,      """vocab.json"""					)					)
          shutil.copy("""./tests/fixtures/merges.txt"""		,      os.path.join(A_		,      """merges.txt"""					)					)

          __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(A_		,      tokenizer_type="""gpt2"""					)
          self.assertIsInstance(A_		,      A_					)
      def 	UpperCAmelCase      (      self					:			Any					)							->      str:
        with pytest.raises(A_					):
          AutoTokenizer.from_pretrained("""./"""		,      tokenizer_type="""xxx"""					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			int					)							->      str:
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
          __UpperCAmelCase							:	str           =  tokenizer_class.from_pretrained("""wietsedv/bert-base-dutch-cased"""					)
          self.assertIsInstance(A_		,      (BertTokenizer, BertTokenizerFast)					)

          if isinstance(A_		,      A_					):
            self.assertEqual(tokenizer.basic_tokenizer.do_lower_case		,      A_					)
          else:
            self.assertEqual(tokenizer.do_lower_case		,      A_					)

          self.assertEqual(tokenizer.model_max_length		,      512					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			Optional[Any]					)							->      Any:
        for tokenizer_class in [BertTokenizer, BertTokenizerFast, AutoTokenizer]:
          with self.assertRaisesRegex(
              A_		,      """julien-c/herlolip-not-exists is not a local folder and is not a valid model identifier"""		,      ):
            __UpperCAmelCase							:	Any           =  tokenizer_class.from_pretrained("""julien-c/herlolip-not-exists"""					)
      def 	UpperCAmelCase      (      self					:			int					)							->      List[str]:
        __UpperCAmelCase							:	Union[str, Any]           =  TOKENIZER_MAPPING.values()
        __UpperCAmelCase							:	Union[str, Any]           =  []

        for slow_tok, fast_tok in tokenizers:
          if slow_tok is not None:
            tokenizer_names.append(slow_tok.__name__					)

          if fast_tok is not None:
            tokenizer_names.append(fast_tok.__name__					)

        for tokenizer_name in tokenizer_names:
          # must find the right class
          tokenizer_class_from_name(A_					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			Tuple					)							->      List[str]:
        self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""		,      use_fast=A_					)		,      A_					)
        self.assertIsInstance(AutoTokenizer.from_pretrained("""bert-base-cased"""					)		,      A_					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			int					)							->      Any:
        __UpperCAmelCase							:	List[str]           =  AutoTokenizer.from_pretrained("""distilbert-base-uncased"""		,      do_lower_case=A_					)
        __UpperCAmelCase							:	Tuple           =  """Hello, world. How are you?"""
        __UpperCAmelCase							:	str           =  tokenizer.tokenize(A_					)
        self.assertEqual("""[UNK]"""		,      tokens[0]					)

        __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained("""microsoft/mpnet-base"""		,      do_lower_case=A_					)
        __UpperCAmelCase							:	Any           =  tokenizer.tokenize(A_					)
        self.assertEqual("""[UNK]"""		,      tokens[0]					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			Tuple					)							->      List[Any]:
        __UpperCAmelCase							:	Tuple           =  AutoTokenizer.from_pretrained("""robot-test/dummy-tokenizer-fast-with-model-config"""					)
        self.assertEqual(type(A_					)		,      A_					)
        self.assertEqual(tokenizer.model_max_length		,      512					)
        self.assertEqual(tokenizer.vocab_size		,      30000					)
        self.assertEqual(tokenizer.unk_token		,      """[UNK]"""					)
        self.assertEqual(tokenizer.padding_side		,      """right"""					)
        self.assertEqual(tokenizer.truncation_side		,      """right"""					)
      def 	UpperCAmelCase      (      self					:			List[str]					)							->      Optional[Any]:
        __UpperCAmelCase							:	Tuple           =  AutoTokenizer.from_pretrained(A_					)
        self.assertIsInstance(A_		,      (BertTokenizer, BertTokenizerFast)					)
        with tempfile.TemporaryDirectory() as tmp_dir:
          tokenizer.save_pretrained(A_					)
          __UpperCAmelCase							:	str           =  AutoTokenizer.from_pretrained(A_					)

        self.assertIsInstance(A_		,      tokenizer.__class__					)
        self.assertEqual(tokenizera.vocab_size		,      12					)
      def 	UpperCAmelCase      (      self					:			Optional[int]					)							->      int:
        __UpperCAmelCase							:	Union[str, Any]           =  AutoTokenizer.from_pretrained("""ctrl"""					)
        # There is no fast CTRL so this always gives us a slow tokenizer.
        self.assertIsInstance(A_		,      A_					)
      def 	UpperCAmelCase      (      self					:			str					)							->      str:
        __UpperCAmelCase							:	int           =  get_tokenizer_config("""bert-base-cased"""					)
        __UpperCAmelCase							:	Optional[int]           =  config.pop("""_commit_hash"""		,      A_					)
        # If we ever update bert-base-cased tokenizer config, this dict here will need to be updated.
        self.assertEqual(A_		,      {"""do_lower_case""": False}					)

        # This model does not have a tokenizer_config so we get back an empty dict.
        __UpperCAmelCase							:	str           =  get_tokenizer_config(A_					)
        self.assertDictEqual(A_		,      {}					)

        # A tokenizer saved with `save_pretrained` always creates a tokenizer config.
        __UpperCAmelCase							:	Union[str, Any]           =  AutoTokenizer.from_pretrained(A_					)
        with tempfile.TemporaryDirectory() as tmp_dir:
          tokenizer.save_pretrained(A_					)
          __UpperCAmelCase							:	List[str]           =  get_tokenizer_config(A_					)

        # Check the class of the tokenizer was properly saved (note that it always saves the slow class).
        self.assertEqual(config["""tokenizer_class"""]		,      """BertTokenizer"""					)
      def 	UpperCAmelCase      (      self					:			Any					)							->      List[Any]:
        try:
          AutoConfig.register("""custom"""		,      A_					)

          AutoTokenizer.register(A_		,      slow_tokenizer_class=A_					)
          # Trying to register something existing in the Transformers library will raise an error
          with self.assertRaises(A_					):
            AutoTokenizer.register(A_		,      slow_tokenizer_class=A_					)

          __UpperCAmelCase							:	List[Any]           =  CustomTokenizer.from_pretrained(A_					)
          with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(A_					)

            __UpperCAmelCase							:	str           =  AutoTokenizer.from_pretrained(A_					)
            self.assertIsInstance(A_		,      A_					)

        finally:
          if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
          if CustomConfig in TOKENIZER_MAPPING._extra_content:
            del TOKENIZER_MAPPING._extra_content[CustomConfig]
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			Union[str, Any]					)							->      int:
        try:
          AutoConfig.register("""custom"""		,      A_					)

          # Can register in two steps
          AutoTokenizer.register(A_		,      slow_tokenizer_class=A_					)
          self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,      (CustomTokenizer, None)					)
          AutoTokenizer.register(A_		,      fast_tokenizer_class=A_					)
          self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,      (CustomTokenizer, CustomTokenizerFast)					)

          del TOKENIZER_MAPPING._extra_content[CustomConfig]
          # Can register in one step
          AutoTokenizer.register(
              A_		,      slow_tokenizer_class=A_		,      fast_tokenizer_class=A_					)
          self.assertEqual(TOKENIZER_MAPPING[CustomConfig]		,      (CustomTokenizer, CustomTokenizerFast)					)

          # Trying to register something existing in the Transformers library will raise an error
          with self.assertRaises(A_					):
            AutoTokenizer.register(A_		,      fast_tokenizer_class=A_					)

          # We pass through a bert tokenizer fast cause there is no converter slow to fast for our new toknizer
          # and that model does not have a tokenizer.json
          with tempfile.TemporaryDirectory() as tmp_dir:
            __UpperCAmelCase							:	int           =  BertTokenizerFast.from_pretrained(A_					)
            bert_tokenizer.save_pretrained(A_					)
            __UpperCAmelCase							:	int           =  CustomTokenizerFast.from_pretrained(A_					)

          with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(A_					)

            __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(A_					)
            self.assertIsInstance(A_		,      A_					)

            __UpperCAmelCase							:	int           =  AutoTokenizer.from_pretrained(A_		,      use_fast=A_					)
            self.assertIsInstance(A_		,      A_					)

        finally:
          if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
          if CustomConfig in TOKENIZER_MAPPING._extra_content:
            del TOKENIZER_MAPPING._extra_content[CustomConfig]
      def 	UpperCAmelCase      (      self					:			Optional[int]					)							->      str:
        # If remote code is not set, we will time out when asking whether to load the model.
        with self.assertRaises(A_					):
          __UpperCAmelCase							:	int           =  AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""					)
        # If remote code is disabled, we can't load this config.
        with self.assertRaises(A_					):
          __UpperCAmelCase							:	Optional[Any]           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_					)

        __UpperCAmelCase							:	Optional[Any]           =  AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_					)
        self.assertTrue(tokenizer.special_attribute_present					)
        # Test tokenizer can be reloaded.
        with tempfile.TemporaryDirectory() as tmp_dir:
          tokenizer.save_pretrained(A_					)
          __UpperCAmelCase							:	List[str]           =  AutoTokenizer.from_pretrained(A_		,      trust_remote_code=A_					)
        self.assertTrue(reloaded_tokenizer.special_attribute_present					)

        if is_tokenizers_available():
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizerFast"""					)
          self.assertEqual(reloaded_tokenizer.__class__.__name__		,      """NewTokenizerFast"""					)

          # Test we can also load the slow version
          __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_		,      use_fast=A_					)
          self.assertTrue(tokenizer.special_attribute_present					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
          # Test tokenizer can be reloaded.
          with tempfile.TemporaryDirectory() as tmp_dir:
            tokenizer.save_pretrained(A_					)
            __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(A_		,      trust_remote_code=A_		,      use_fast=A_					)
          self.assertEqual(reloaded_tokenizer.__class__.__name__		,      """NewTokenizer"""					)
          self.assertTrue(reloaded_tokenizer.special_attribute_present					)
        else:
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
          self.assertEqual(reloaded_tokenizer.__class__.__name__		,      """NewTokenizer"""					)
      @require_tokenizers
      def 	UpperCAmelCase      (      self					:			int					)							->      int:
        class     a    ( _SCREAMING_SNAKE_CASE   ):



              """simple docstring"""


              a  : List[str]							       =	False


        class     a    ( _SCREAMING_SNAKE_CASE   ):



              """simple docstring"""


              a  : int							       =	NewTokenizer
              a  : Optional[Any]							       =	False

        try:
          AutoConfig.register("""custom"""		,      A_					)
          AutoTokenizer.register(A_		,      slow_tokenizer_class=A_					)
          AutoTokenizer.register(A_		,      fast_tokenizer_class=A_					)
          # If remote code is not set, the default is to use local
          __UpperCAmelCase							:	str           =  AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizerFast"""					)
          self.assertFalse(tokenizer.special_attribute_present					)
          __UpperCAmelCase							:	Tuple           =  AutoTokenizer.from_pretrained("""hf-internal-testing/test_dynamic_tokenizer"""		,      use_fast=A_					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
          self.assertFalse(tokenizer.special_attribute_present					)

          # If remote code is disabled, we load the local one.
          __UpperCAmelCase							:	List[str]           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizerFast"""					)
          self.assertFalse(tokenizer.special_attribute_present					)
          __UpperCAmelCase							:	List[str]           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_		,      use_fast=A_					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
          self.assertFalse(tokenizer.special_attribute_present					)

          # If remote is enabled, we load from the Hub
          __UpperCAmelCase							:	Optional[int]           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizerFast"""					)
          self.assertTrue(tokenizer.special_attribute_present					)
          __UpperCAmelCase							:	List[Any]           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer"""		,      trust_remote_code=A_		,      use_fast=A_					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
          self.assertTrue(tokenizer.special_attribute_present					)

        finally:
          if "custom" in CONFIG_MAPPING._extra_content:
            del CONFIG_MAPPING._extra_content["custom"]
          if CustomConfig in TOKENIZER_MAPPING._extra_content:
            del TOKENIZER_MAPPING._extra_content[CustomConfig]
      def 	UpperCAmelCase      (      self					:			str					)							->      Tuple:
        __UpperCAmelCase							:	int           =  AutoTokenizer.from_pretrained(
            """hf-internal-testing/test_dynamic_tokenizer_legacy"""		,      trust_remote_code=A_					)
        self.assertTrue(tokenizer.special_attribute_present					)
        if is_tokenizers_available():
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizerFast"""					)

          # Test we can also load the slow version
          __UpperCAmelCase							:	Dict           =  AutoTokenizer.from_pretrained(
              """hf-internal-testing/test_dynamic_tokenizer_legacy"""		,      trust_remote_code=A_		,      use_fast=A_					)
          self.assertTrue(tokenizer.special_attribute_present					)
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
        else:
          self.assertEqual(tokenizer.__class__.__name__		,      """NewTokenizer"""					)
      def 	UpperCAmelCase      (      self					:			Any					)							->      Optional[Any]:
        with self.assertRaisesRegex(
            A_		,      """bert-base is not a local folder and is not a valid model identifier"""					):
          __UpperCAmelCase							:	Any           =  AutoTokenizer.from_pretrained("""bert-base"""					)
      def 	UpperCAmelCase      (      self					:			Dict					)							->      List[Any]:
        with self.assertRaisesRegex(
            A_		,      r"""aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)"""					):
          __UpperCAmelCase							:	Optional[Any]           =  AutoTokenizer.from_pretrained(A_		,      revision="""aaaaaa"""					)




      def 	UpperCAmelCase      (      self					:			Dict					)							->      Any:
        __UpperCAmelCase							:	Union[str, Any]           =  AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""					)
        with RequestCounter() as counter:
          __UpperCAmelCase							:	List[Any]           =  AutoTokenizer.from_pretrained("""hf-internal-testing/tiny-random-bert"""					)
          self.assertEqual(counter.get_request_count		,      0					)
          self.assertEqual(counter.head_request_count		,      1					)
          self.assertEqual(counter.other_request_count		,      0					)




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


_UpperCAmelCase					: Union[str, Any]      =       {
    "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:
					_UpperCAmelCase					: List[Any]      =       [
					    "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

					_UpperCAmelCase					: Union[str, Any]      =       _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
