

from typing import TYPE_CHECKING

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


_UpperCamelCase			       =			{
    '''auto_factory''': ['''get_values'''],
    '''configuration_auto''': ['''ALL_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''CONFIG_MAPPING''', '''MODEL_NAMES_MAPPING''', '''AutoConfig'''],
    '''feature_extraction_auto''': ['''FEATURE_EXTRACTOR_MAPPING''', '''AutoFeatureExtractor'''],
    '''image_processing_auto''': ['''IMAGE_PROCESSOR_MAPPING''', '''AutoImageProcessor'''],
    '''processing_auto''': ['''PROCESSOR_MAPPING''', '''AutoProcessor'''],
    '''tokenization_auto''': ['''TOKENIZER_MAPPING''', '''AutoTokenizer'''],
}

try:
 if not is_torch_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _UpperCamelCase			       =			[
     '''MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_AUDIO_XVECTOR_MAPPING''',
     '''MODEL_FOR_BACKBONE_MAPPING''',
     '''MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING''',
     '''MODEL_FOR_CAUSAL_LM_MAPPING''',
     '''MODEL_FOR_CTC_MAPPING''',
     '''MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING''',
     '''MODEL_FOR_DEPTH_ESTIMATION_MAPPING''',
     '''MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_IMAGE_SEGMENTATION_MAPPING''',
     '''MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING''',
     '''MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING''',
     '''MODEL_FOR_MASKED_LM_MAPPING''',
     '''MODEL_FOR_MASK_GENERATION_MAPPING''',
     '''MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
     '''MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
     '''MODEL_FOR_OBJECT_DETECTION_MAPPING''',
     '''MODEL_FOR_PRETRAINING_MAPPING''',
     '''MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
     '''MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING''',
     '''MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
     '''MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
     '''MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING''',
     '''MODEL_FOR_TEXT_ENCODING_MAPPING''',
     '''MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING''',
     '''MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_VISION_2_SEQ_MAPPING''',
     '''MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING''',
     '''MODEL_MAPPING''',
     '''MODEL_WITH_LM_HEAD_MAPPING''',
     '''MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING''',
     '''MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING''',
     '''AutoModel''',
     '''AutoBackbone''',
     '''AutoModelForAudioClassification''',
     '''AutoModelForAudioFrameClassification''',
     '''AutoModelForAudioXVector''',
     '''AutoModelForCausalLM''',
     '''AutoModelForCTC''',
     '''AutoModelForDepthEstimation''',
     '''AutoModelForImageClassification''',
     '''AutoModelForImageSegmentation''',
     '''AutoModelForInstanceSegmentation''',
     '''AutoModelForMaskGeneration''',
     '''AutoModelForTextEncoding''',
     '''AutoModelForMaskedImageModeling''',
     '''AutoModelForMaskedLM''',
     '''AutoModelForMultipleChoice''',
     '''AutoModelForNextSentencePrediction''',
     '''AutoModelForObjectDetection''',
     '''AutoModelForPreTraining''',
     '''AutoModelForQuestionAnswering''',
     '''AutoModelForSemanticSegmentation''',
     '''AutoModelForSeq2SeqLM''',
     '''AutoModelForSequenceClassification''',
     '''AutoModelForSpeechSeq2Seq''',
     '''AutoModelForTableQuestionAnswering''',
     '''AutoModelForTokenClassification''',
     '''AutoModelForUniversalSegmentation''',
     '''AutoModelForVideoClassification''',
     '''AutoModelForVision2Seq''',
     '''AutoModelForVisualQuestionAnswering''',
     '''AutoModelForDocumentQuestionAnswering''',
     '''AutoModelWithLMHead''',
     '''AutoModelForZeroShotImageClassification''',
     '''AutoModelForZeroShotObjectDetection''',
 ]

try:
 if not is_tf_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _UpperCamelCase			       =			[
     '''TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
     '''TF_MODEL_FOR_CAUSAL_LM_MAPPING''',
     '''TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
     '''TF_MODEL_FOR_MASK_GENERATION_MAPPING''',
     '''TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING''',
     '''TF_MODEL_FOR_MASKED_LM_MAPPING''',
     '''TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
     '''TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
     '''TF_MODEL_FOR_PRETRAINING_MAPPING''',
     '''TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
     '''TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING''',
     '''TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING''',
     '''TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
     '''TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
     '''TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
     '''TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING''',
     '''TF_MODEL_FOR_TEXT_ENCODING_MAPPING''',
     '''TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
     '''TF_MODEL_FOR_VISION_2_SEQ_MAPPING''',
     '''TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING''',
     '''TF_MODEL_MAPPING''',
     '''TF_MODEL_WITH_LM_HEAD_MAPPING''',
     '''TFAutoModel''',
     '''TFAutoModelForAudioClassification''',
     '''TFAutoModelForCausalLM''',
     '''TFAutoModelForImageClassification''',
     '''TFAutoModelForMaskedImageModeling''',
     '''TFAutoModelForMaskedLM''',
     '''TFAutoModelForMaskGeneration''',
     '''TFAutoModelForMultipleChoice''',
     '''TFAutoModelForNextSentencePrediction''',
     '''TFAutoModelForPreTraining''',
     '''TFAutoModelForDocumentQuestionAnswering''',
     '''TFAutoModelForQuestionAnswering''',
     '''TFAutoModelForSemanticSegmentation''',
     '''TFAutoModelForSeq2SeqLM''',
     '''TFAutoModelForSequenceClassification''',
     '''TFAutoModelForSpeechSeq2Seq''',
     '''TFAutoModelForTableQuestionAnswering''',
     '''TFAutoModelForTextEncoding''',
     '''TFAutoModelForTokenClassification''',
     '''TFAutoModelForVision2Seq''',
     '''TFAutoModelForZeroShotImageClassification''',
     '''TFAutoModelWithLMHead''',
 ]

try:
 if not is_flax_available():
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 pass
else:
 _UpperCamelCase			       =			[
     '''FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING''',
     '''FLAX_MODEL_FOR_CAUSAL_LM_MAPPING''',
     '''FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING''',
     '''FLAX_MODEL_FOR_MASKED_LM_MAPPING''',
     '''FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING''',
     '''FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING''',
     '''FLAX_MODEL_FOR_PRETRAINING_MAPPING''',
     '''FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING''',
     '''FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING''',
     '''FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING''',
     '''FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING''',
     '''FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING''',
     '''FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING''',
     '''FLAX_MODEL_MAPPING''',
     '''FlaxAutoModel''',
     '''FlaxAutoModelForCausalLM''',
     '''FlaxAutoModelForImageClassification''',
     '''FlaxAutoModelForMaskedLM''',
     '''FlaxAutoModelForMultipleChoice''',
     '''FlaxAutoModelForNextSentencePrediction''',
     '''FlaxAutoModelForPreTraining''',
     '''FlaxAutoModelForQuestionAnswering''',
     '''FlaxAutoModelForSeq2SeqLM''',
     '''FlaxAutoModelForSequenceClassification''',
     '''FlaxAutoModelForSpeechSeq2Seq''',
     '''FlaxAutoModelForTokenClassification''',
     '''FlaxAutoModelForVision2Seq''',
 ]


if TYPE_CHECKING:
 from .auto_factory import get_values
 from .configuration_auto import ALL_PRETRAINED_CONFIG_ARCHIVE_MAP, CONFIG_MAPPING, MODEL_NAMES_MAPPING, AutoConfig
 from .feature_extraction_auto import FEATURE_EXTRACTOR_MAPPING, AutoFeatureExtractor
 from .image_processing_auto import IMAGE_PROCESSOR_MAPPING, AutoImageProcessor
 from .processing_auto import PROCESSOR_MAPPING, AutoProcessor
 from .tokenization_auto import TOKENIZER_MAPPING, AutoTokenizer

 try:
  if not is_torch_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_auto import (
      MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      MODEL_FOR_AUDIO_FRAME_CLASSIFICATION_MAPPING,
      MODEL_FOR_AUDIO_XVECTOR_MAPPING,
      MODEL_FOR_BACKBONE_MAPPING,
      MODEL_FOR_CAUSAL_IMAGE_MODELING_MAPPING,
      MODEL_FOR_CAUSAL_LM_MAPPING,
      MODEL_FOR_CTC_MAPPING,
      MODEL_FOR_DEPTH_ESTIMATION_MAPPING,
      MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_IMAGE_SEGMENTATION_MAPPING,
      MODEL_FOR_INSTANCE_SEGMENTATION_MAPPING,
      MODEL_FOR_MASK_GENERATION_MAPPING,
      MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
      MODEL_FOR_MASKED_LM_MAPPING,
      MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      MODEL_FOR_OBJECT_DETECTION_MAPPING,
      MODEL_FOR_PRETRAINING_MAPPING,
      MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
      MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_TEXT_ENCODING_MAPPING,
      MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      MODEL_FOR_UNIVERSAL_SEGMENTATION_MAPPING,
      MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING,
      MODEL_FOR_VISION_2_SEQ_MAPPING,
      MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING,
      MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
      MODEL_FOR_ZERO_SHOT_OBJECT_DETECTION_MAPPING,
      MODEL_MAPPING,
      MODEL_WITH_LM_HEAD_MAPPING,
      AutoBackbone,
      AutoModel,
      AutoModelForAudioClassification,
      AutoModelForAudioFrameClassification,
      AutoModelForAudioXVector,
      AutoModelForCausalLM,
      AutoModelForCTC,
      AutoModelForDepthEstimation,
      AutoModelForDocumentQuestionAnswering,
      AutoModelForImageClassification,
      AutoModelForImageSegmentation,
      AutoModelForInstanceSegmentation,
      AutoModelForMaskedImageModeling,
      AutoModelForMaskedLM,
      AutoModelForMaskGeneration,
      AutoModelForMultipleChoice,
      AutoModelForNextSentencePrediction,
      AutoModelForObjectDetection,
      AutoModelForPreTraining,
      AutoModelForQuestionAnswering,
      AutoModelForSemanticSegmentation,
      AutoModelForSeqaSeqLM,
      AutoModelForSequenceClassification,
      AutoModelForSpeechSeqaSeq,
      AutoModelForTableQuestionAnswering,
      AutoModelForTextEncoding,
      AutoModelForTokenClassification,
      AutoModelForUniversalSegmentation,
      AutoModelForVideoClassification,
      AutoModelForVisionaSeq,
      AutoModelForVisualQuestionAnswering,
      AutoModelForZeroShotImageClassification,
      AutoModelForZeroShotObjectDetection,
      AutoModelWithLMHead,
  )

 try:
  if not is_tf_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_tf_auto import (
      TF_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_DOCUMENT_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_MASK_GENERATION_MAPPING,
      TF_MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING,
      TF_MODEL_FOR_MASKED_LM_MAPPING,
      TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      TF_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      TF_MODEL_FOR_PRETRAINING_MAPPING,
      TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_SEMANTIC_SEGMENTATION_MAPPING,
      TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      TF_MODEL_FOR_TABLE_QUESTION_ANSWERING_MAPPING,
      TF_MODEL_FOR_TEXT_ENCODING_MAPPING,
      TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      TF_MODEL_FOR_VISION_2_SEQ_MAPPING,
      TF_MODEL_FOR_ZERO_SHOT_IMAGE_CLASSIFICATION_MAPPING,
      TF_MODEL_MAPPING,
      TF_MODEL_WITH_LM_HEAD_MAPPING,
      TFAutoModel,
      TFAutoModelForAudioClassification,
      TFAutoModelForCausalLM,
      TFAutoModelForDocumentQuestionAnswering,
      TFAutoModelForImageClassification,
      TFAutoModelForMaskedImageModeling,
      TFAutoModelForMaskedLM,
      TFAutoModelForMaskGeneration,
      TFAutoModelForMultipleChoice,
      TFAutoModelForNextSentencePrediction,
      TFAutoModelForPreTraining,
      TFAutoModelForQuestionAnswering,
      TFAutoModelForSemanticSegmentation,
      TFAutoModelForSeqaSeqLM,
      TFAutoModelForSequenceClassification,
      TFAutoModelForSpeechSeqaSeq,
      TFAutoModelForTableQuestionAnswering,
      TFAutoModelForTextEncoding,
      TFAutoModelForTokenClassification,
      TFAutoModelForVisionaSeq,
      TFAutoModelForZeroShotImageClassification,
      TFAutoModelWithLMHead,
  )

 try:
  if not is_flax_available():
   raise OptionalDependencyNotAvailable()
 except OptionalDependencyNotAvailable:
  pass
 else:
  from .modeling_flax_auto import (
      FLAX_MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_CAUSAL_LM_MAPPING,
      FLAX_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_MASKED_LM_MAPPING,
      FLAX_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
      FLAX_MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING,
      FLAX_MODEL_FOR_PRETRAINING_MAPPING,
      FLAX_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
      FLAX_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
      FLAX_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING,
      FLAX_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
      FLAX_MODEL_FOR_VISION_2_SEQ_MAPPING,
      FLAX_MODEL_MAPPING,
      FlaxAutoModel,
      FlaxAutoModelForCausalLM,
      FlaxAutoModelForImageClassification,
      FlaxAutoModelForMaskedLM,
      FlaxAutoModelForMultipleChoice,
      FlaxAutoModelForNextSentencePrediction,
      FlaxAutoModelForPreTraining,
      FlaxAutoModelForQuestionAnswering,
      FlaxAutoModelForSeqaSeqLM,
      FlaxAutoModelForSequenceClassification,
      FlaxAutoModelForSpeechSeqaSeq,
      FlaxAutoModelForTokenClassification,
      FlaxAutoModelForVisionaSeq,
  )

else:
 import sys

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






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


if is_torch_available():
 import torch

if is_vision_available():
 from PIL import Image

 from transformers import CLIPImageProcessor



class     lowercase						(       unittest.TestCase					):



 '''simple docstring'''


 def __init__(self       ,       __a       ,       __a=7       ,       __a=3       ,       __a=18       ,       __a=30       ,       __a=400       ,       __a=True       ,       __a=None       ,       __a=True       ,       __a=None       ,       __a=True       ,       __a=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73]       ,       __a=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11]       ,       __a=True       ,       ) ->					Optional[int]:






  """simple docstring"""





  UpperCAmelCase__							=				size if size is not None else {'shortest_edge': 20}
  UpperCAmelCase__							=				crop_size if crop_size is not None else {'height': 18, 'width': 18}
  UpperCAmelCase__							=				parent
  UpperCAmelCase__							=				batch_size
  UpperCAmelCase__							=				num_channels
  UpperCAmelCase__							=				image_size
  UpperCAmelCase__							=				min_resolution
  UpperCAmelCase__							=				max_resolution
  UpperCAmelCase__							=				do_resize
  UpperCAmelCase__							=				size
  UpperCAmelCase__							=				do_center_crop
  UpperCAmelCase__							=				crop_size
  UpperCAmelCase__							=				do_normalize
  UpperCAmelCase__							=				image_mean
  UpperCAmelCase__							=				image_std
  UpperCAmelCase__							=				do_convert_rgb




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






  """simple docstring"""





  return {
      "do_resize": self.do_resize,
      "size": self.size,
      "do_center_crop": self.do_center_crop,
      "crop_size": self.crop_size,
      "do_normalize": self.do_normalize,
      "image_mean": self.image_mean,
      "image_std": self.image_std,
      "do_convert_rgb": self.do_convert_rgb,
  }




 def   UpperCamelCase__							(self       ,       __a=False       ,       __a=False       ,       __a=False ) ->					Union[str, Any]:






  """simple docstring"""





  assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"

  if equal_resolution:
   UpperCAmelCase__							=				[]
   for i in range(self.batch_size ):
    image_inputs.append(
        np.random.randint(
            255       ,       size=(self.num_channels, self.max_resolution, self.max_resolution)       ,       dtype=np.uinta ) )
  else:
   UpperCAmelCase__							=				[]
   for i in range(self.batch_size ):
    UpperCAmelCase__				,    UpperCAmelCase__							=				np.random.choice(np.arange(self.min_resolution       ,       self.max_resolution )       ,       2 )
    image_inputs.append(np.random.randint(255       ,       size=(self.num_channels, width, height)       ,       dtype=np.uinta ) )

  if not numpify and not torchify:
   # PIL expects the channel dimension as last dimension
   UpperCAmelCase__							=				[Image.fromarray(np.moveaxis(__a       ,       0       ,       -1 ) ) for x in image_inputs]

  if torchify:
   UpperCAmelCase__							=				[torch.from_numpy(__a ) for x in image_inputs]

  return image_inputs







@require_torch
@require_vision
class     lowercase						(       _UpperCamelCase ,				unittest.TestCase					):



 '''simple docstring'''


 __SCREAMING_SNAKE_CASE												=				CLIPImageProcessor if is_vision_available() else None




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






  """simple docstring"""





  UpperCAmelCase__							=				CLIPImageProcessingTester(self )




 @property
 def   UpperCamelCase__							(self ) ->					List[str]:






  """simple docstring"""





  return self.image_processor_tester.prepare_image_processor_dict()




 def   UpperCamelCase__							(self ) ->					Any:






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class(**self.image_processor_dict )
  self.assertTrue(hasattr(__a       ,       'do_resize' ) )
  self.assertTrue(hasattr(__a       ,       'size' ) )
  self.assertTrue(hasattr(__a       ,       'do_center_crop' ) )
  self.assertTrue(hasattr(__a       ,       'center_crop' ) )
  self.assertTrue(hasattr(__a       ,       'do_normalize' ) )
  self.assertTrue(hasattr(__a       ,       'image_mean' ) )
  self.assertTrue(hasattr(__a       ,       'image_std' ) )
  self.assertTrue(hasattr(__a       ,       'do_convert_rgb' ) )




 def   UpperCamelCase__							(self ) ->					str:






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class.from_dict(self.image_processor_dict )
  self.assertEqual(image_processor.size       ,       {'shortest_edge': 20} )
  self.assertEqual(image_processor.crop_size       ,       {'height': 18, 'width': 18} )

  UpperCAmelCase__							=				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]:






  """simple docstring"""





  pass




 def   UpperCamelCase__							(self ) ->					Dict:






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class(**self.image_processor_dict )
  # create random PIL images
  UpperCAmelCase__							=				self.image_processor_tester.prepare_inputs(equal_resolution=__a )
  for image in image_inputs:
   self.assertIsInstance(__a       ,       Image.Image )

  # Test not batched input
  UpperCAmelCase__							=				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
  UpperCAmelCase__							=				image_processing(__a       ,       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 ) ->					Optional[Any]:






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class(**self.image_processor_dict )
  # create random numpy tensors
  UpperCAmelCase__							=				self.image_processor_tester.prepare_inputs(equal_resolution=__a       ,       numpify=__a )
  for image in image_inputs:
   self.assertIsInstance(__a       ,       np.ndarray )

  # Test not batched input
  UpperCAmelCase__							=				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
  UpperCAmelCase__							=				image_processing(__a       ,       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 ) ->					Tuple:






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class(**self.image_processor_dict )
  # create random PyTorch tensors
  UpperCAmelCase__							=				self.image_processor_tester.prepare_inputs(equal_resolution=__a       ,       torchify=__a )
  for image in image_inputs:
   self.assertIsInstance(__a       ,       torch.Tensor )

  # Test not batched input
  UpperCAmelCase__							=				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
  UpperCAmelCase__							=				image_processing(__a       ,       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'],
      )       ,       )







@require_torch
@require_vision
class     lowercase						(       _UpperCamelCase ,				unittest.TestCase					):



 '''simple docstring'''


 __SCREAMING_SNAKE_CASE												=				CLIPImageProcessor if is_vision_available() else None




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






  """simple docstring"""





  UpperCAmelCase__							=				CLIPImageProcessingTester(self       ,       num_channels=4 )
  UpperCAmelCase__							=				3




 @property
 def   UpperCamelCase__							(self ) ->					Optional[int]:






  """simple docstring"""





  return self.image_processor_tester.prepare_image_processor_dict()




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






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class(**self.image_processor_dict )
  self.assertTrue(hasattr(__a       ,       'do_resize' ) )
  self.assertTrue(hasattr(__a       ,       'size' ) )
  self.assertTrue(hasattr(__a       ,       'do_center_crop' ) )
  self.assertTrue(hasattr(__a       ,       'center_crop' ) )
  self.assertTrue(hasattr(__a       ,       'do_normalize' ) )
  self.assertTrue(hasattr(__a       ,       'image_mean' ) )
  self.assertTrue(hasattr(__a       ,       'image_std' ) )
  self.assertTrue(hasattr(__a       ,       'do_convert_rgb' ) )




 def   UpperCamelCase__							(self ) ->					Tuple:






  """simple docstring"""





  pass




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






  """simple docstring"""





  UpperCAmelCase__							=				self.image_processing_class(**self.image_processor_dict )
  # create random PIL images
  UpperCAmelCase__							=				self.image_processor_tester.prepare_inputs(equal_resolution=__a )
  for image in image_inputs:
   self.assertIsInstance(__a       ,       Image.Image )

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

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



