


"""simple docstring"""






import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
   import torch

if is_vision_available():
   from PIL import Image

   from transformers import LevitImageProcessor


class 			__lowerCamelCase     (    unittest.TestCase ):

     '''simple docstring'''


     def __init__(					self			, __UpperCAmelCase			, __UpperCAmelCase=7			, __UpperCAmelCase=3			, __UpperCAmelCase=18			, __UpperCAmelCase=30			, __UpperCAmelCase=400			, __UpperCAmelCase=True			, __UpperCAmelCase=None			, __UpperCAmelCase=True			, __UpperCAmelCase=None			, __UpperCAmelCase=True			, __UpperCAmelCase=[0.5, 0.5, 0.5]			, __UpperCAmelCase=[0.5, 0.5, 0.5]			, )				->							int:
          _a					= size if size is not None else {'shortest_edge': 18}
          _a					= crop_size if crop_size is not None else {'height': 18, 'width': 18}
          _a					= parent
          _a					= batch_size
          _a					= num_channels
          _a					= image_size
          _a					= min_resolution
          _a					= max_resolution
          _a					= do_resize
          _a					= size
          _a					= do_center_crop
          _a					= crop_size
          _a					= do_normalize
          _a					= image_mean
          _a					= image_std





     def 							_UpperCAmelCase					(					self							)				->							Optional[int]:
          return {
              "image_mean": self.image_mean,
              "image_std": self.image_std,
              "do_normalize": self.do_normalize,
              "do_resize": self.do_resize,
              "do_center_crop": self.do_center_crop,
              "size": self.size,
              "crop_size": self.crop_size,
          }







@require_torch
@require_vision
class 			__lowerCamelCase     (    __snake_case     ,    unittest.TestCase ):

     '''simple docstring'''
     A_				:		Optional[Any]			=						LevitImageProcessor if is_vision_available() else None


     def 							_UpperCAmelCase					(					self							)				->							List[Any]:
          _a					= LevitImageProcessingTester(self							)


     @property
     def 							_UpperCAmelCase					(					self							)				->							Tuple:
          return self.image_processor_tester.prepare_image_processor_dict()


     def 							_UpperCAmelCase					(					self							)				->							int:
          _a					= self.image_processing_class(**self.image_processor_dict							)
          self.assertTrue(hasattr(__UpperCAmelCase			, '''image_mean'''							)							)
          self.assertTrue(hasattr(__UpperCAmelCase			, '''image_std'''							)							)
          self.assertTrue(hasattr(__UpperCAmelCase			, '''do_normalize'''							)							)
          self.assertTrue(hasattr(__UpperCAmelCase			, '''do_resize'''							)							)
          self.assertTrue(hasattr(__UpperCAmelCase			, '''do_center_crop'''							)							)
          self.assertTrue(hasattr(__UpperCAmelCase			, '''size'''							)							)


     def 							_UpperCAmelCase					(					self							)				->							Any:
          _a					= self.image_processing_class.from_dict(self.image_processor_dict							)
          self.assertEqual(image_processor.size			, {'''shortest_edge''': 18}							)
          self.assertEqual(image_processor.crop_size			, {'''height''': 18, '''width''': 18}							)

          _a					= self.image_processing_class.from_dict(self.image_processor_dict			, size=42			, crop_size=84							)
          self.assertEqual(image_processor.size			, {'''shortest_edge''': 42}							)
          self.assertEqual(image_processor.crop_size			, {'''height''': 84, '''width''': 84}							)


     def 							_UpperCAmelCase					(					self							)				->							List[Any]:
          pass


     def 							_UpperCAmelCase					(					self							)				->							Tuple:
          # Initialize image_processing
          _a					= self.image_processing_class(**self.image_processor_dict							)
          # create random PIL images
          _a					= prepare_image_inputs(self.image_processor_tester			, equal_resolution=__UpperCAmelCase							)
          for image in image_inputs:
               self.assertIsInstance(__UpperCAmelCase			, Image.Image							)

          # Test not batched input
          _a					= image_processing(image_inputs[0]			, return_tensors='''pt'''							).pixel_values
          self.assertEqual(
              encoded_images.shape			, (
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )			, )

          # Test batched
          _a					= image_processing(__UpperCAmelCase			, return_tensors='''pt'''							).pixel_values
          self.assertEqual(
              encoded_images.shape			, (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )			, )


     def 							_UpperCAmelCase					(					self							)				->							List[Any]:
          # Initialize image_processing
          _a					= self.image_processing_class(**self.image_processor_dict							)
          # create random numpy tensors
          _a					= prepare_image_inputs(self.image_processor_tester			, equal_resolution=__UpperCAmelCase			, numpify=__UpperCAmelCase							)
          for image in image_inputs:
               self.assertIsInstance(__UpperCAmelCase			, np.ndarray							)

          # Test not batched input
          _a					= image_processing(image_inputs[0]			, return_tensors='''pt'''							).pixel_values
          self.assertEqual(
              encoded_images.shape			, (
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )			, )

          # Test batched
          _a					= image_processing(__UpperCAmelCase			, return_tensors='''pt'''							).pixel_values
          self.assertEqual(
              encoded_images.shape			, (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )			, )





     def 							_UpperCAmelCase					(					self							)				->							Any:
          # Initialize image_processing
          _a					= self.image_processing_class(**self.image_processor_dict							)
          # create random PyTorch tensors
          _a					= prepare_image_inputs(self.image_processor_tester			, equal_resolution=__UpperCAmelCase			, torchify=__UpperCAmelCase							)
          for image in image_inputs:
               self.assertIsInstance(__UpperCAmelCase			, torch.Tensor							)

          # Test not batched input
          _a					= image_processing(image_inputs[0]			, return_tensors='''pt'''							).pixel_values
          self.assertEqual(
              encoded_images.shape			, (
                  1,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )			, )

          # Test batched
          _a					= image_processing(__UpperCAmelCase			, return_tensors='''pt'''							).pixel_values
          self.assertEqual(
              encoded_images.shape			, (
                  self.image_processor_tester.batch_size,
                  self.image_processor_tester.num_channels,
                  self.image_processor_tester.crop_size['''height'''],
                  self.image_processor_tester.crop_size['''width'''],
              )			, )


from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


snake_case_			  = {
    '''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:
       snake_case_			  = [
           '''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

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

