




import random
import unittest

from torch.utils.data import BatchSampler, DataLoader, IterableDataset

from accelerate import Accelerator
from accelerate.data_loader import (
    BatchSamplerShard,
    DataLoaderDispatcher,
    DataLoaderShard,
    IterableDatasetShard,
    SkipBatchSampler,
    SkipDataLoader,
    skip_first_batches,
)


class 				UpperCamelCase_    ( UpperCAmelCase__     ):

    '''simple docstring'''






    def __init__(			self      :	Dict					, UpperCAmelCase__      :	Optional[int]=0.01					, UpperCAmelCase__      :	Optional[Any]=1_000)						->Optional[int]:





           '''simple docstring'''

           A__       =    p_stop
           A__       =    max_length





    def __iter__(			self      :	List[Any])						->List[Any]:





           '''simple docstring'''

           A__       =    0
           A__       =    False
           while not stop and count < self.max_length:
                  yield count
                  count += 1
                  A__       =    random.random() < self.p_stop


class 				UpperCamelCase_    ( unittest.TestCase     ):

    '''simple docstring'''






    def        SCREAMING_SNAKE_CASE							(			self      :	List[str]					, UpperCAmelCase__      :	Dict					, UpperCAmelCase__      :	List[str]					, UpperCAmelCase__      :	List[str]=False					, UpperCAmelCase__      :	Any=True)						->Optional[Any]:





           '''simple docstring'''

           A__       =    [
               BatchSamplerShard(UpperCAmelCase__					, 2					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)
               for i in range(2)
           ]
           A__       =    [list(UpperCAmelCase__) for batch_sampler_shard in batch_sampler_shards]
           if not split_batches:
                  self.assertListEqual([len(UpperCAmelCase__) for shard in batch_sampler_shards]					, [len(UpperCAmelCase__) for e in expected])
           self.assertListEqual(UpperCAmelCase__					, UpperCAmelCase__)


    def        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Any:





           '''simple docstring'''

           A__       =    BatchSampler(range(24)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           A__       =    BatchSampler(range(24)					, batch_size=3					, drop_last=UpperCAmelCase__)
           # Expected shouldn't change
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           # Check the shards when the dataset is a round multiple of batch size but not total batch size.
           A__       =    BatchSampler(range(21)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [0, 1, 2]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           A__       =    BatchSampler(range(21)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
           # num_processes batch.
           A__       =    BatchSampler(range(22)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 0, 1]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           A__       =    BatchSampler(range(22)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
           # num_processes batch.
           A__       =    BatchSampler(range(20)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 0]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [1, 2, 3]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           A__       =    BatchSampler(range(20)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           # Check the shards when the dataset is very small.
           A__       =    BatchSampler(range(2)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [[[0, 1, 0]], [[1, 0, 1]]]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)

           A__       =    BatchSampler(range(2)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [[], []]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__)


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





           '''simple docstring'''

           A__       =    BatchSampler(range(24)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(24)					, batch_size=4					, drop_last=UpperCAmelCase__)
           # Expected shouldn't change
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size.
           A__       =    BatchSampler(range(22)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [0, 1]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(22)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size or num_processes.
           A__       =    BatchSampler(range(21)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 0]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [1, 2]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(21)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           # Check the shards when the dataset is very small.
           A__       =    BatchSampler(range(2)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [[[0, 1]], [[0, 1]]]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(2)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [[], []]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__)


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





           '''simple docstring'''

           A__       =    BatchSampler(range(24)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21, 22, 23]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(24)					, batch_size=3					, drop_last=UpperCAmelCase__)
           # Expected shouldn't change
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is a round multiple of batch size but not total batch size.
           A__       =    BatchSampler(range(21)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(21)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size but has a multiple of
           # num_processes batch.
           A__       =    BatchSampler(range(22)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19, 20]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17], [21]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(22)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size but and has not a multiple of
           # num_processes batch.
           A__       =    BatchSampler(range(20)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14], [18, 19]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(20)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1, 2], [6, 7, 8], [12, 13, 14]],
               [[3, 4, 5], [9, 10, 11], [15, 16, 17]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is very small.
           A__       =    BatchSampler(range(2)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [[[0, 1]], []]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(2)					, batch_size=3					, drop_last=UpperCAmelCase__)
           A__       =    [[], []]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, even_batches=UpperCAmelCase__)


    def        SCREAMING_SNAKE_CASE							(			self      :	Optional[Any])						->Tuple:





           '''simple docstring'''

           A__       =    BatchSampler(range(24)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19], [22, 23]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(24)					, batch_size=4					, drop_last=UpperCAmelCase__)
           # Expected shouldn't change
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size.
           A__       =    BatchSampler(range(22)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20, 21]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(22)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is not a round multiple of batch size or num_processes.
           A__       =    BatchSampler(range(21)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17], [20]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(21)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [
               [[0, 1], [4, 5], [8, 9], [12, 13], [16, 17]],
               [[2, 3], [6, 7], [10, 11], [14, 15], [18, 19]],
           ]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           # Check the shards when the dataset is very small.
           A__       =    BatchSampler(range(2)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [[[0, 1]], []]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)

           A__       =    BatchSampler(range(2)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    [[], []]
           self.check_batch_sampler_shards(UpperCAmelCase__					, UpperCAmelCase__					, split_batches=UpperCAmelCase__					, even_batches=UpperCAmelCase__)


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





           '''simple docstring'''

           A__       =    [[0, 1, 2], [3, 4], [5, 6, 7, 8], [9, 10, 11], [12, 13]]
           A__       =    [BatchSamplerShard(UpperCAmelCase__					, 2					, UpperCAmelCase__					, even_batches=UpperCAmelCase__) for i in range(2)]

           self.assertEqual(len(batch_sampler_shards[0])					, 3)
           self.assertEqual(len(batch_sampler_shards[1])					, 2)

           self.assertListEqual(list(batch_sampler_shards[0])					, [[0, 1, 2], [5, 6, 7, 8], [12, 13]])
           self.assertListEqual(list(batch_sampler_shards[1])					, [[3, 4], [9, 10, 11]])


    def        SCREAMING_SNAKE_CASE							(			self      :	int					, UpperCAmelCase__      :	List[Any]					, UpperCAmelCase__      :	Optional[int]					, UpperCAmelCase__      :	Tuple					, UpperCAmelCase__      :	Tuple=False					, UpperCAmelCase__      :	Optional[Any]=2					, UpperCAmelCase__      :	List[str]=False)						->Optional[Any]:





           '''simple docstring'''

           random.seed(UpperCAmelCase__)
           A__       =    list(UpperCAmelCase__)

           A__       =    [
               IterableDatasetShard(
                   UpperCAmelCase__					, batch_size=UpperCAmelCase__					, drop_last=UpperCAmelCase__					, num_processes=UpperCAmelCase__					, process_index=UpperCAmelCase__					, split_batches=UpperCAmelCase__					, )
               for i in range(UpperCAmelCase__)
           ]
           A__       =    []
           for iterable_dataset_shard in iterable_dataset_shards:
                  # Since our random iterable dataset will be... random... we need to use a seed to get reproducible results.
                  random.seed(UpperCAmelCase__)
                  iterable_dataset_lists.append(list(UpperCAmelCase__))

           A__       =    batch_size // num_processes if split_batches else batch_size
           # All iterable dataset shard should have the same length, a round multiple of shard_batch_size
           A__       =    iterable_dataset_lists[0]
           for l in iterable_dataset_lists[1:]:
                  self.assertEqual(len(UpperCAmelCase__)					, len(UpperCAmelCase__))
                  self.assertTrue(len(UpperCAmelCase__) % shard_batch_size == 0)

           A__       =    []
           for idx in range(0					, len(UpperCAmelCase__)					, UpperCAmelCase__):
                  for l in iterable_dataset_lists:
                         observed += l[idx : idx + shard_batch_size]

           if not drop_last:
                  while len(UpperCAmelCase__) < len(UpperCAmelCase__):
                         reference += reference
           self.assertListEqual(UpperCAmelCase__					, reference[: len(UpperCAmelCase__)])


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





           '''simple docstring'''

           A__       =    42
           A__       =    RandomIterableDataset()

           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)
           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)
           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)
           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)

           # Edge case with a very small dataset
           A__       =    RandomIterableDataset(max_length=2)

           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)
           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)
           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)
           self.check_iterable_dataset_shards(UpperCAmelCase__					, UpperCAmelCase__					, batch_size=4					, drop_last=UpperCAmelCase__					, split_batches=UpperCAmelCase__)


    def        SCREAMING_SNAKE_CASE							(			self      :	Dict)						->Optional[int]:





           '''simple docstring'''

           A__       =    BatchSampler(range(16)					, batch_size=4					, drop_last=UpperCAmelCase__)
           A__       =    SkipBatchSampler(UpperCAmelCase__					, 2)
           self.assertListEqual(list(UpperCAmelCase__)					, [[8, 9, 10, 11], [12, 13, 14, 15]])


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





           '''simple docstring'''

           A__       =    SkipDataLoader(list(range(16))					, batch_size=4					, skip_batches=2)
           self.assertListEqual([t.tolist() for t in dataloader]					, [[8, 9, 10, 11], [12, 13, 14, 15]])


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





           '''simple docstring'''

           A__       =    DataLoader(list(range(16))					, batch_size=4)
           A__       =    skip_first_batches(UpperCAmelCase__					, num_batches=2)
           self.assertListEqual([t.tolist() for t in new_dataloader]					, [[8, 9, 10, 11], [12, 13, 14, 15]])


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





           '''simple docstring'''

           A__       =    DataLoaderShard(list(range(16))					, batch_size=4)
           for idx, _ in enumerate(UpperCAmelCase__):
                  self.assertEqual(dataloader.end_of_dataloader					, idx == 3)

           # Test it also works on the second iteration
           for idx, _ in enumerate(UpperCAmelCase__):
                  self.assertEqual(dataloader.end_of_dataloader					, idx == 3)





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





           '''simple docstring'''

           Accelerator()
           A__       =    DataLoaderDispatcher(range(16)					, batch_size=4)
           for idx, _ in enumerate(UpperCAmelCase__):
                  self.assertEqual(dataloader.end_of_dataloader					, idx == 3)

           # Test it also works on the second iteration
           for idx, _ in enumerate(UpperCAmelCase__):
                  self.assertEqual(dataloader.end_of_dataloader					, idx == 3)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_tf_available,
    is_torch_available,
    is_vision_available,
)


_lowerCamelCase	:		int							       =   {
    """configuration_blip""": [
        """BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """BlipConfig""",
        """BlipTextConfig""",
        """BlipVisionConfig""",
    ],
    """processing_blip""": ["""BlipProcessor"""],
}

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase	:		Tuple							       =   ["""BlipImageProcessor"""]


try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase	:		List[Any]							       =   [
      """BLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """BlipModel""",
      """BlipPreTrainedModel""",
      """BlipForConditionalGeneration""",
      """BlipForQuestionAnswering""",
      """BlipVisionModel""",
      """BlipTextModel""",
      """BlipForImageTextRetrieval""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  _lowerCamelCase	:		Optional[Any]							       =   [
      """TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFBlipModel""",
      """TFBlipPreTrainedModel""",
      """TFBlipForConditionalGeneration""",
      """TFBlipForQuestionAnswering""",
      """TFBlipVisionModel""",
      """TFBlipTextModel""",
      """TFBlipForImageTextRetrieval""",
  ]

if TYPE_CHECKING:
  from .configuration_blip import BLIP_PRETRAINED_CONFIG_ARCHIVE_MAP, BlipConfig, BlipTextConfig, BlipVisionConfig
  from .processing_blip import BlipProcessor

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_blip import BlipImageProcessor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_blip import (
        BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
        BlipForConditionalGeneration,
        BlipForImageTextRetrieval,
        BlipForQuestionAnswering,
        BlipModel,
        BlipPreTrainedModel,
        BlipTextModel,
        BlipVisionModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_blip import (
        TF_BLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFBlipForConditionalGeneration,
        TFBlipForImageTextRetrieval,
        TFBlipForQuestionAnswering,
        TFBlipModel,
        TFBlipPreTrainedModel,
        TFBlipTextModel,
        TFBlipVisionModel,
    )

else:
  import sys

  _lowerCamelCase	:		List[Any]							       =   _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


