

'''simple docstring'''




from typing import TYPE_CHECKING

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


_a				: Any 							=						{
    '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:
  _a				: List[str] 							=						[
      '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:
  _a				: Optional[Any] 							=						[
      '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:
  _a				: Dict 							=						[
      '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

  _a				: int 							=						_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)





'''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 MobileNetVaImageProcessor



class        lowercase_	(		unittest.TestCase ):

  '''simple docstring'''





  def __init__(     self   , a_   , a_=7   , a_=3   , a_=1_8   , a_=3_0   , a_=4_0_0   , a_=True   , a_=None   , a_=True   , a_=None   , )							->				List[str]:


    """simple docstring"""
    UpperCAmelCase													=	size if size is not None else {'shortest_edge': 2_0}
    UpperCAmelCase													=	crop_size if crop_size is not None else {'height': 1_8, 'width': 1_8}
    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





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


    """simple docstring"""
    return {
        "do_resize": self.do_resize,
        "size": self.size,
        "do_center_crop": self.do_center_crop,
        "crop_size": self.crop_size,
    }




@require_torch
@require_vision
class        lowercase_	(		a ,       unittest.TestCase ):

  '''simple docstring'''





  __lowerCAmelCase					: Union[str, Any]      =   MobileNetVaImageProcessor if is_vision_available() else None
  def 						snake_case_			(     self     )							->				Dict:


    """simple docstring"""
    UpperCAmelCase													=	MobileNetVaImageProcessingTester(self     )
  @property
  def 						snake_case_			(     self     )							->				List[str]:


    """simple docstring"""
    return self.image_processor_tester.prepare_image_processor_dict()
  def 						snake_case_			(     self     )							->				Optional[int]:


    """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'     )     )
  def 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    UpperCAmelCase													=	self.image_processing_class.from_dict(self.image_processor_dict     )
    self.assertEqual(image_processor.size   , {'shortest_edge': 2_0}     )
    self.assertEqual(image_processor.crop_size   , {'height': 1_8, 'width': 1_8}     )

    UpperCAmelCase													=	self.image_processing_class.from_dict(self.image_processor_dict   , size=4_2   , crop_size=8_4     )
    self.assertEqual(image_processor.size   , {'shortest_edge': 4_2}     )
    self.assertEqual(image_processor.crop_size   , {'height': 8_4, 'width': 8_4}     )
  def 						snake_case_			(     self     )							->				List[str]:


    """simple docstring"""
    pass
  def 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    # Initialize image_processing
    UpperCAmelCase													=	self.image_processing_class(**self.image_processor_dict     )
    # create random PIL images
    UpperCAmelCase													=	prepare_image_inputs(self.image_processor_tester   , 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 						snake_case_			(     self     )							->				str:


    """simple docstring"""
    # Initialize image_processing
    UpperCAmelCase													=	self.image_processing_class(**self.image_processor_dict     )
    # create random numpy tensors
    UpperCAmelCase													=	prepare_image_inputs(self.image_processor_tester   , 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 						snake_case_			(     self     )							->				List[Any]:


    """simple docstring"""
    # Initialize image_processing
    UpperCAmelCase													=	self.image_processing_class(**self.image_processor_dict     )
    # create random PyTorch tensors
    UpperCAmelCase													=	prepare_image_inputs(self.image_processor_tester   , 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'],
        )   , )


