code: 
  
  
  
  
  
  
  """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 ViltImageProcessor
  
  
  
  class 					UpperCamelCase__   (							unittest.TestCase):
  
  
  
  
  
  
  
      """simple docstring"""
  
  
  
  
  
  
  
      def __init__(		self   :  Optional[int]							,						UpperCamelCase_   :  List[str]							,						UpperCamelCase_   :  str=7							,						UpperCamelCase_   :  int=3							,						UpperCamelCase_   :  str=1_8							,						UpperCamelCase_   :  List[str]=3_0							,						UpperCamelCase_   :  Tuple=4_0_0							,						UpperCamelCase_   :  str=True							,						UpperCamelCase_   :  str=None							,						UpperCamelCase_   :  Tuple=2							,						UpperCamelCase_   :  Optional[Any]=True							,						UpperCamelCase_   :  int=[0.5, 0.5, 0.5]							,						UpperCamelCase_   :  str=[0.5, 0.5, 0.5]							,						):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						size if size is not None else {'shortest_edge': 3_0}
             __magic_name__										=						parent
             __magic_name__										=						batch_size
             __magic_name__										=						num_channels
             __magic_name__										=						image_size
             __magic_name__										=						min_resolution
             __magic_name__										=						max_resolution
             __magic_name__										=						do_resize
             __magic_name__										=						size
             __magic_name__										=						size_divisor
             __magic_name__										=						do_normalize
             __magic_name__										=						image_mean
             __magic_name__										=						image_std
  
  
  
  
  
  
  
      def 							a__ (		self   :  Dict   ):
  
  
  
  
  
             '''simple docstring'''
  
             return {
                 "image_mean": self.image_mean,
                 "image_std": self.image_std,
                 "do_normalize": self.do_normalize,
                 "do_resize": self.do_resize,
                 "size": self.size,
                 "size_divisor": self.size_divisor,
             }
  
  
  
  
  
  
  
      def 							a__ (		self   :  Tuple							,						UpperCamelCase_   :  str							,						UpperCamelCase_   :  int=False   ):
  
  
  
  
  
             '''simple docstring'''
  
             if not batched:
                    __magic_name__										=						self.size['shortest_edge']
                    __magic_name__										=						image_inputs[0]
                    if isinstance(UpperCamelCase_							,						Image.Image   ):
                           __magic_name__							,     __magic_name__										=						image.size
                    else:
                           __magic_name__							,     __magic_name__										=						image.shape[1], image.shape[2]
                    __magic_name__										=						size / min(UpperCamelCase_							,						UpperCamelCase_   )
                    if h < w:
                           __magic_name__							,     __magic_name__										=						size, scale * w
                    else:
                           __magic_name__							,     __magic_name__										=						scale * h, size
  
                    __magic_name__										=						int((1_3_3_3 / 8_0_0) * size   )
                    if max(UpperCamelCase_							,						UpperCamelCase_   ) > max_size:
                           __magic_name__										=						max_size / max(UpperCamelCase_							,						UpperCamelCase_   )
                           __magic_name__										=						newh * scale
                           __magic_name__										=						neww * scale
  
                    __magic_name__							,     __magic_name__										=						int(newh + 0.5   ), int(neww + 0.5   )
                    __magic_name__							,     __magic_name__										=						(
                        newh // self.size_divisor * self.size_divisor,
                        neww // self.size_divisor * self.size_divisor,
                    )
  
             else:
                    __magic_name__										=						[]
                    for image in image_inputs:
                           __magic_name__							,     __magic_name__										=						self.get_expected_values([image]   )
                           expected_values.append((expected_height, expected_width)   )
                    __magic_name__										=						max(UpperCamelCase_							,						key=lambda UpperCamelCase_   : item[0]   )[0]
                    __magic_name__										=						max(UpperCamelCase_							,						key=lambda UpperCamelCase_   : item[1]   )[1]
  
             return expected_height, expected_width
  
  
  
  @require_torch
  @require_vision
  class 					UpperCamelCase__   (							UpperCAmelCase_       ,  unittest.TestCase):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   ViltImageProcessor if is_vision_available() else None
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						ViltImageProcessingTester(self   )
  
  
  
  
  
  
  
      @property
      def 							a__ (		self   :  str   ):
  
  
  
  
  
             '''simple docstring'''
  
             return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  
  
  
      def 							a__ (		self   :  List[str]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						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_							,						'size'   )   )
             self.assertTrue(hasattr(UpperCamelCase_							,						'size_divisor'   )   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.image_processing_class.from_dict(self.image_processor_dict   )
             self.assertEqual(image_processor.size							,						{'shortest_edge': 3_0}   )
  
             __magic_name__										=						self.image_processing_class.from_dict(self.image_processor_dict							,						size=4_2   )
             self.assertEqual(image_processor.size							,						{'shortest_edge': 4_2}   )
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[int]   ):
  
  
  
  
  
             '''simple docstring'''
  
             pass
  
  
  
  
  
  
  
      def 							a__ (		self   :  Any   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.image_processing_class(**self.image_processor_dict   )
             # create random PIL images
             __magic_name__										=						prepare_image_inputs(self.image_processor_tester							,						equal_resolution=UpperCamelCase_   )
             for image in image_inputs:
                    self.assertIsInstance(UpperCamelCase_							,						Image.Image   )
  
             # Test not batched input
             __magic_name__										=						image_processing(image_inputs[0]							,						return_tensors='pt'   ).pixel_values
  
             __magic_name__							,     __magic_name__										=						self.image_processor_tester.get_expected_values(UpperCamelCase_   )
             self.assertEqual(
                 encoded_images.shape							,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,						)
  
             # Test batched
             __magic_name__										=						image_processing(UpperCamelCase_							,						return_tensors='pt'   ).pixel_values
  
             __magic_name__							,     __magic_name__										=						self.image_processor_tester.get_expected_values(UpperCamelCase_							,						batched=UpperCamelCase_   )
             self.assertEqual(
                 encoded_images.shape							,						(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     expected_height,
                     expected_width,
                 )							,						)
  
  
  
  
  
  
  
      def 							a__ (		self   :  Dict   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.image_processing_class(**self.image_processor_dict   )
             # create random numpy tensors
             __magic_name__										=						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
             __magic_name__										=						image_processing(image_inputs[0]							,						return_tensors='pt'   ).pixel_values
  
             __magic_name__							,     __magic_name__										=						self.image_processor_tester.get_expected_values(UpperCamelCase_   )
             self.assertEqual(
                 encoded_images.shape							,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,						)
  
             # Test batched
             __magic_name__										=						image_processing(UpperCamelCase_							,						return_tensors='pt'   ).pixel_values
  
             __magic_name__							,     __magic_name__										=						self.image_processor_tester.get_expected_values(UpperCamelCase_							,						batched=UpperCamelCase_   )
             self.assertEqual(
                 encoded_images.shape							,						(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     expected_height,
                     expected_width,
                 )							,						)
  
  
  
  
  
  
  
      def 							a__ (		self   :  Optional[int]   ):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						self.image_processing_class(**self.image_processor_dict   )
             # create random PyTorch tensors
             __magic_name__										=						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
             __magic_name__										=						image_processing(image_inputs[0]							,						return_tensors='pt'   ).pixel_values
  
             __magic_name__							,     __magic_name__										=						self.image_processor_tester.get_expected_values(UpperCamelCase_   )
             self.assertEqual(
                 encoded_images.shape							,						(1, self.image_processor_tester.num_channels, expected_height, expected_width)							,						)
  
             # Test batched
             __magic_name__										=						image_processing(UpperCamelCase_							,						return_tensors='pt'   ).pixel_values
  
             __magic_name__							,     __magic_name__										=						self.image_processor_tester.get_expected_values(UpperCamelCase_							,						batched=UpperCamelCase_   )
             self.assertEqual(
                 encoded_images.shape							,						(
                     self.image_processor_tester.batch_size,
                     self.image_processor_tester.num_channels,
                     expected_height,
                     expected_width,
                 )							,						)
  
  
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  from typing import List, Optional, Union
  
  import numpy as np
  
  from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
  from ...feature_extraction_utils import BatchFeature
  from ...utils import PaddingStrategy, TensorType, logging
  
  
  snake_case   :   Tuple    		=		logging.get_logger(__name__)
  
  
  
  class 					UpperCamelCase__   (							a_):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   ["""input_values""", """attention_mask"""]
  
  
  
  
  
  
  
      def __init__(		self   :  Union[str, Any]							,						UpperCamelCase_   :  int=1							,						UpperCamelCase_   :  Optional[int]=1_6_0_0_0							,						UpperCamelCase_   :  List[str]=0.0							,						UpperCamelCase_   :  Optional[int]=False							,						UpperCamelCase_   :  Tuple=True							,						**UpperCamelCase_   :  Tuple							,						):
  
  
  
  
  
             '''simple docstring'''
  
             super().__init__(feature_size=UpperCamelCase_							,						sampling_rate=UpperCamelCase_							,						padding_value=UpperCamelCase_							,						**UpperCamelCase_   )
             __magic_name__										=						return_attention_mask
             __magic_name__										=						do_normalize
  
  
  
  
  
  
  
      @staticmethod
      def 							a__ (		UpperCamelCase_   :  List[np.ndarray]							,						UpperCamelCase_   :  List[np.ndarray]							,						UpperCamelCase_   :  float = 0.0   ):
  
  
  
  
  
             '''simple docstring'''
  
             if attention_mask is not None:
                    __magic_name__										=						np.array(UpperCamelCase_							,						np.intaa   )
                    __magic_name__										=						[]
  
                    for vector, length in zip(UpperCamelCase_							,						attention_mask.sum(-1   )   ):
                           __magic_name__										=						(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7   )
                           if length < normed_slice.shape[0]:
                                  __magic_name__										=						padding_value
  
                           normed_input_values.append(UpperCamelCase_   )
             else:
                    __magic_name__										=						[(x - x.mean()) / np.sqrt(x.var() + 1e-7   ) for x in input_values]
  
             return normed_input_values
  
  
  
  
  
  
  
      def __call__(		self   :  Any							,						UpperCamelCase_   :  Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]							,						UpperCamelCase_   :  Union[bool, str, PaddingStrategy] = False							,						UpperCamelCase_   :  Optional[int] = None							,						UpperCamelCase_   :  bool = False							,						UpperCamelCase_   :  Optional[int] = None							,						UpperCamelCase_   :  Optional[bool] = None							,						UpperCamelCase_   :  Optional[Union[str, TensorType]] = None							,						UpperCamelCase_   :  Optional[int] = None							,						**UpperCamelCase_   :  Any							,						):
  
  
  
  
  
             '''simple docstring'''
  
             if sampling_rate is not None:
                    if sampling_rate != self.sampling_rate:
                           raise ValueError(
                               f"""The model corresponding to this feature extractor: {self} was trained using a sampling rate of"""
                               f""" {self.sampling_rate}. Please make sure that the provided `raw_speech` input was sampled with"""
                               f""" {self.sampling_rate} and not {sampling_rate}."""   )
             else:
                    logger.warning(
                        'It is strongly recommended to pass the ``sampling_rate`` argument to this function. '
                        'Failing to do so can result in silent errors that might be hard to debug.'   )
  
             __magic_name__										=						isinstance(UpperCamelCase_							,						np.ndarray   ) and len(raw_speech.shape   ) > 1
             if is_batched_numpy and len(raw_speech.shape   ) > 2:
                    raise ValueError(f"""Only mono-channel audio is supported for input to {self}"""   )
             __magic_name__										=						is_batched_numpy or (
                 isinstance(UpperCamelCase_							,						(list, tuple)   ) and (isinstance(raw_speech[0]							,						(np.ndarray, tuple, list)   ))
             )
  
             # always return batch
             if not is_batched:
                    __magic_name__										=						[raw_speech]
  
             # convert into correct format for padding
             __magic_name__										=						BatchFeature({'input_values': raw_speech}   )
  
             __magic_name__										=						self.pad(
                 UpperCamelCase_							,						padding=UpperCamelCase_							,						max_length=UpperCamelCase_							,						truncation=UpperCamelCase_							,						pad_to_multiple_of=UpperCamelCase_							,						return_attention_mask=UpperCamelCase_							,						)
  
             # convert input values to correct format
             __magic_name__										=						padded_inputs['input_values']
             if not isinstance(input_values[0]							,						np.ndarray   ):
                    __magic_name__										=						[np.asarray(UpperCamelCase_							,						dtype=np.floataa   ) for array in input_values]
             elif (
                 not isinstance(UpperCamelCase_							,						np.ndarray   )
                 and isinstance(input_values[0]							,						np.ndarray   )
                 and input_values[0].dtype is np.dtype(np.floataa   )
             ):
                    __magic_name__										=						[array.astype(np.floataa   ) for array in input_values]
             elif isinstance(UpperCamelCase_							,						np.ndarray   ) and input_values.dtype is np.dtype(np.floataa   ):
                    __magic_name__										=						input_values.astype(np.floataa   )
  
             # convert attention_mask to correct format
             __magic_name__										=						padded_inputs.get('attention_mask'   )
             if attention_mask is not None:
                    __magic_name__										=						[np.asarray(UpperCamelCase_							,						dtype=np.intaa   ) for array in attention_mask]
  
             # zero-mean and unit-variance normalization
             if self.do_normalize:
                    __magic_name__										=						(
                        attention_mask
                        if self._get_padding_strategies(UpperCamelCase_							,						max_length=UpperCamelCase_   ) is not PaddingStrategy.DO_NOT_PAD
                        else None
                    )
                    __magic_name__										=						self.zero_mean_unit_var_norm(
                        padded_inputs['input_values']							,						attention_mask=UpperCamelCase_							,						padding_value=self.padding_value   )
  
             if return_tensors is not None:
                    __magic_name__										=						padded_inputs.convert_to_tensors(UpperCamelCase_   )
  
             return padded_inputs