





"""simple docstring"""


import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPImageProcessor, CLIPVisionConfig, CLIPVisionModel

from diffusers import HeunDiscreteScheduler, PriorTransformer, ShapEImgaImgPipeline
from diffusers.pipelines.shap_e import ShapERenderer
from diffusers.utils import floats_tensor, load_image, load_numpy, slow
from diffusers.utils.testing_utils import require_torch_gpu, torch_device

from ..test_pipelines_common import PipelineTesterMixin, assert_mean_pixel_difference


class _lowerCamelCase    (					a_       ,	unittest.TestCase						):
   _lowerCamelCase    :Dict     				=     ShapEImgaImgPipeline
   _lowerCamelCase    :Union[str, Any]     				=     ["image"]
   _lowerCamelCase    :Tuple     				=     ["image"]
   _lowerCamelCase    :List[Any]     				=     [
       "num_images_per_prompt",
       "num_inference_steps",
       "generator",
       "latents",
       "guidance_scale",
       "frame_size",
       "output_type",
       "return_dict",
   ]
   _lowerCamelCase    :int     				=     False






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

         """simple docstring"""
         return 32






   @property
   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						str:

         """simple docstring"""
         return 32






   @property
   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						List[Any]:

         """simple docstring"""
         return self.time_input_dim * 4






   @property
   def 	_lowerCAmelCase   (		self       :		Union[str, Any]   )			->						Dict:

         """simple docstring"""
         return 8






   @property
   def 	_lowerCAmelCase   (		self       :		str   )			->						Union[str, Any]:

         """simple docstring"""
         torch.manual_seed(0   )
         lowerCAmelCase__      :			str   =	CLIPVisionConfig(
             hidden_size=self.text_embedder_hidden_size   ,     image_size=64   ,     projection_dim=self.text_embedder_hidden_size   ,     intermediate_size=37   ,     num_attention_heads=4   ,     num_channels=3   ,     num_hidden_layers=5   ,     patch_size=1   ,     )

         lowerCAmelCase__      :			Any   =	CLIPVisionModel(UpperCamelCase   )
         return model






   @property
   def 	_lowerCAmelCase   (		self       :		int   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	CLIPImageProcessor(
             crop_size=2_24   ,     do_center_crop=UpperCamelCase   ,     do_normalize=UpperCamelCase   ,     do_resize=UpperCamelCase   ,     image_mean=[0.4814_5466, 0.457_8275, 0.4082_1073]   ,     image_std=[0.2686_2954, 0.2613_0258, 0.2757_7711]   ,     resample=3   ,     size=2_24   ,     )

         return image_processor






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

         """simple docstring"""
         torch.manual_seed(0   )

         lowerCAmelCase__      :			Dict   =	{
             """num_attention_heads""": 2,
             """attention_head_dim""": 16,
             """embedding_dim""": self.time_input_dim,
             """num_embeddings""": 32,
             """embedding_proj_dim""": self.text_embedder_hidden_size,
             """time_embed_dim""": self.time_embed_dim,
             """num_layers""": 1,
             """clip_embed_dim""": self.time_input_dim * 2,
             """additional_embeddings""": 0,
             """time_embed_act_fn""": """gelu""",
             """norm_in_type""": """layer""",
             """embedding_proj_norm_type""": """layer""",
             """encoder_hid_proj_type""": None,
             """added_emb_type""": None,
         }

         lowerCAmelCase__      :			Any   =	PriorTransformer(**UpperCamelCase   )
         return model






   @property
   def 	_lowerCAmelCase   (		self       :		str   )			->						Optional[Any]:

         """simple docstring"""
         torch.manual_seed(0   )

         lowerCAmelCase__      :			Dict   =	{
             """param_shapes""": (
                 (self.renderer_dim, 93),
                 (self.renderer_dim, 8),
                 (self.renderer_dim, 8),
                 (self.renderer_dim, 8),
             ),
             """d_latent""": self.time_input_dim,
             """d_hidden""": self.renderer_dim,
             """n_output""": 12,
             """background""": (
                 0.1,
                 0.1,
                 0.1,
             ),
         }
         lowerCAmelCase__      :			str   =	ShapERenderer(**UpperCamelCase   )
         return model






   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						Dict:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.dummy_prior
         lowerCAmelCase__      :			Tuple   =	self.dummy_image_encoder
         lowerCAmelCase__      :			Optional[int]   =	self.dummy_image_processor
         lowerCAmelCase__      :			Optional[int]   =	self.dummy_renderer

         lowerCAmelCase__      :			Tuple   =	HeunDiscreteScheduler(
             beta_schedule="""exp"""   ,     num_train_timesteps=10_24   ,     prediction_type="""sample"""   ,     use_karras_sigmas=UpperCamelCase   ,     clip_sample=UpperCamelCase   ,     clip_sample_range=1.0   ,     )
         lowerCAmelCase__      :			Union[str, Any]   =	{
             """prior""": prior,
             """image_encoder""": image_encoder,
             """image_processor""": image_processor,
             """renderer""": renderer,
             """scheduler""": scheduler,
         }

         return components






   def 	_lowerCAmelCase   (		self       :		Any   ,     UpperCamelCase       :		Any   ,     UpperCamelCase       :		Optional[int]=0   )			->						Optional[int]:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	floats_tensor((1, 3, 64, 64)   ,     rng=random.Random(UpperCamelCase   )   ).to(UpperCamelCase   )

         if str(UpperCamelCase   ).startswith("""mps"""   ):
               lowerCAmelCase__      :			int   =	torch.manual_seed(UpperCamelCase   )
         else:
               lowerCAmelCase__      :			Union[str, Any]   =	torch.Generator(device=UpperCamelCase   ).manual_seed(UpperCamelCase   )
         lowerCAmelCase__      :			Union[str, Any]   =	{
             """image""": input_image,
             """generator""": generator,
             """num_inference_steps""": 1,
             """frame_size""": 32,
             """output_type""": """np""",
         }
         return inputs






   def 	_lowerCAmelCase   (		self       :		str   )			->						Any:

         """simple docstring"""
         lowerCAmelCase__      :			Optional[int]   =	"""cpu"""

         lowerCAmelCase__      :			Tuple   =	self.get_dummy_components()

         lowerCAmelCase__      :			List[Any]   =	self.pipeline_class(**UpperCamelCase   )
         lowerCAmelCase__      :			Optional[Any]   =	pipe.to(UpperCamelCase   )

         pipe.set_progress_bar_config(disable=UpperCamelCase   )

         lowerCAmelCase__      :			List[str]   =	pipe(**self.get_dummy_inputs(UpperCamelCase   )   )
         lowerCAmelCase__      :			Union[str, Any]   =	output.images[0]
         lowerCAmelCase__      :			Optional[Any]   =	image[0, -3:, -3:, -1]

         assert image.shape == (20, 32, 32, 3)

         lowerCAmelCase__      :			List[Any]   =	np.array(
             [
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
                 0.0003_9216,
             ]   )

         assert np.abs(image_slice.flatten() - expected_slice   ).max() < 1E-2






   def 	_lowerCAmelCase   (		self       :		str   )			->						Tuple:

         """simple docstring"""
         self._test_inference_batch_consistent(batch_sizes=[1, 2]   )






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

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	torch_device == """cpu"""
         lowerCAmelCase__      :			List[Any]   =	True
         self._test_inference_batch_single_identical(
             batch_size=2   ,     test_max_difference=UpperCamelCase   ,     relax_max_difference=UpperCamelCase   ,     )






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

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	self.get_dummy_components()
         lowerCAmelCase__      :			Any   =	self.pipeline_class(**UpperCamelCase   )
         lowerCAmelCase__      :			str   =	pipe.to(UpperCamelCase   )
         pipe.set_progress_bar_config(disable=UpperCamelCase   )

         lowerCAmelCase__      :			List[Any]   =	1
         lowerCAmelCase__      :			Optional[Any]   =	2

         lowerCAmelCase__      :			List[str]   =	self.get_dummy_inputs(UpperCamelCase   )

         for key in inputs.keys():
               if key in self.batch_params:
                     lowerCAmelCase__      :			Any   =	batch_size * [inputs[key]]

         lowerCAmelCase__      :			str   =	pipe(**UpperCamelCase   ,     num_images_per_prompt=UpperCamelCase   )[0]

         assert images.shape[0] == batch_size * num_images_per_prompt






@slow
@require_torch_gpu
class _lowerCamelCase    (					unittest.TestCase						):






   def 	_lowerCAmelCase   (		self       :		int   )			->						int:

         """simple docstring"""
         super().tearDown()
         gc.collect()
         torch.cuda.empty_cache()






   def 	_lowerCAmelCase   (		self       :		List[str]   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			str   =	load_image(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main""" """/shap_e/corgi.png"""   )
         lowerCAmelCase__      :			Dict   =	load_numpy(
             """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
             """/shap_e/test_shap_e_img2img_out.npy"""   )
         lowerCAmelCase__      :			List[Any]   =	ShapEImgaImgPipeline.from_pretrained("""openai/shap-e-img2img"""   )
         lowerCAmelCase__      :			str   =	pipe.to(UpperCamelCase   )
         pipe.set_progress_bar_config(disable=UpperCamelCase   )

         lowerCAmelCase__      :			Dict   =	torch.Generator(device=UpperCamelCase   ).manual_seed(0   )

         lowerCAmelCase__      :			str   =	pipe(
             UpperCamelCase   ,     generator=UpperCamelCase   ,     guidance_scale=3.0   ,     num_inference_steps=64   ,     frame_size=64   ,     output_type="""np"""   ,     ).images[0]

         assert images.shape == (20, 64, 64, 3)

         assert_mean_pixel_difference(UpperCamelCase   ,     UpperCamelCase   )











"""simple docstring"""


import numpy as np

from transformers import BatchFeature
from transformers.testing_utils import require_tf, require_torch

from .test_feature_extraction_common import FeatureExtractionSavingTestMixin


class _lowerCamelCase    (					a_						):
   # to overwrite at feature extractactor specific tests
   _lowerCamelCase    :Optional[int]     				=     None
   _lowerCamelCase    :List[Any]     				=     None






   @property
   def 	_lowerCAmelCase   (		self       :		int   )			->						Tuple:

         """simple docstring"""
         return self.feat_extract_tester.prepare_feat_extract_dict()






   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						List[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.feature_extraction_class(**self.feat_extract_dict   )
         self.assertTrue(hasattr(UpperCamelCase   ,     """feature_size"""   )   )
         self.assertTrue(hasattr(UpperCamelCase   ,     """sampling_rate"""   )   )
         self.assertTrue(hasattr(UpperCamelCase   ,     """padding_value"""   )   )






   def 	_lowerCAmelCase   (		self       :		Any   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			Dict   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			List[Any]   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Union[str, Any]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Any   =	BatchFeature({input_name: speech_inputs}   )

         self.assertTrue(all(len(UpperCamelCase   ) == len(UpperCamelCase   ) for x, y in zip(UpperCamelCase   ,     processed_features[input_name]   )   )   )

         lowerCAmelCase__      :			List[str]   =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase   )
         lowerCAmelCase__      :			List[Any]   =	BatchFeature({input_name: speech_inputs}   ,     tensor_type="""np"""   )

         lowerCAmelCase__      :			Dict   =	processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
               lowerCAmelCase__      :			int   =	batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )






   @require_torch
   def 	_lowerCAmelCase   (		self       :		Tuple   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Optional[int]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Union[str, Any]   =	BatchFeature({input_name: speech_inputs}   ,     tensor_type="""pt"""   )

         lowerCAmelCase__      :			str   =	processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
               lowerCAmelCase__      :			int   =	batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )






   @require_tf
   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			List[str]   =	self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Dict   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Tuple   =	BatchFeature({input_name: speech_inputs}   ,     tensor_type="""tf"""   )

         lowerCAmelCase__      :			Union[str, Any]   =	processed_features[input_name]

         if len(batch_features_input.shape   ) < 3:
               lowerCAmelCase__      :			Optional[Any]   =	batch_features_input[:, :, None]

         self.assertTrue(
             batch_features_input.shape
             == (self.feat_extract_tester.batch_size, len(speech_inputs[0]   ), self.feat_extract_tester.feature_size)   )






   def 	_lowerCAmelCase   (		self       :		List[Any]   ,     UpperCamelCase       :		Union[str, Any]=False   )			->						int:

         """simple docstring"""
         def _inputs_have_equal_length(UpperCamelCase       :		int   ):
               lowerCAmelCase__      :			Optional[Any]   =	len(input[0]   )
               for input_slice in input[1:]:
                     if len(UpperCamelCase   ) != length:
                           return False
               return True

         def _inputs_are_equal(UpperCamelCase       :		int   ,     UpperCamelCase       :		Dict   ):
               if len(UpperCamelCase   ) != len(UpperCamelCase   ):
                     return False

               for input_slice_a, input_slice_a in zip(UpperCamelCase   ,     UpperCamelCase   ):
                     if not np.allclose(np.asarray(UpperCamelCase   )   ,     np.asarray(UpperCamelCase   )   ,     atol=1E-3   ):
                           return False
               return True

         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Dict   =	self.feat_extract_tester.prepare_inputs_for_common(numpify=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			str   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			Any   =	self.feat_extract_tester.seq_length_diff
         lowerCAmelCase__      :			List[str]   =	self.feat_extract_tester.max_seq_length + pad_diff
         lowerCAmelCase__      :			Optional[int]   =	self.feat_extract_tester.min_seq_length
         lowerCAmelCase__      :			Optional[int]   =	self.feat_extract_tester.batch_size
         lowerCAmelCase__      :			str   =	self.feat_extract_tester.feature_size

         # test padding for List[int] + numpy
         lowerCAmelCase__      :			List[Any]   =	feat_extract.pad(UpperCamelCase   ,     padding=UpperCamelCase   )
         lowerCAmelCase__      :			int   =	input_a[input_name]

         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   )
         lowerCAmelCase__      :			Any   =	input_a[input_name]

         lowerCAmelCase__      :			List[str]   =	feat_extract.pad(UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[-1]   )   )
         lowerCAmelCase__      :			Dict   =	input_a[input_name]

         lowerCAmelCase__      :			str   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			Optional[Any]   =	input_a[input_name]

         # max_length parameter has to be provided when setting `padding="max_length"`
         with self.assertRaises(UpperCamelCase   ):
               feat_extract.pad(UpperCamelCase   ,     padding="""max_length"""   )[input_name]

         lowerCAmelCase__      :			Optional[int]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=UpperCamelCase   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			int   =	input_a[input_name]

         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_are_equal(UpperCamelCase   ,     UpperCamelCase   )   )
         self.assertTrue(len(input_a[0]   ) == pad_min_length   )
         self.assertTrue(len(input_a[1]   ) == pad_min_length + pad_diff   )
         self.assertTrue(input_a.shape[:2] == (batch_size, len(input_a[0]   ))   )
         self.assertTrue(input_a.shape[:2] == (batch_size, pad_max_length)   )

         if feature_size > 1:
               self.assertTrue(input_a.shape[2] == input_a.shape[2] == feature_size   )

         # test padding for `pad_to_multiple_of` for List[int] + numpy
         lowerCAmelCase__      :			Any   =	feat_extract.pad(UpperCamelCase   ,     pad_to_multiple_of=10   )
         lowerCAmelCase__      :			int   =	input_a[input_name]

         lowerCAmelCase__      :			Dict   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     pad_to_multiple_of=10   )
         lowerCAmelCase__      :			Union[str, Any]   =	input_a[input_name]

         lowerCAmelCase__      :			Optional[int]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     pad_to_multiple_of=10   ,     max_length=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	input_a[input_name]

         lowerCAmelCase__      :			Union[str, Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     pad_to_multiple_of=10   ,     max_length=UpperCamelCase   ,     return_tensors="""np"""   ,     )
         lowerCAmelCase__      :			List[Any]   =	input_a[input_name]

         self.assertTrue(all(len(UpperCamelCase   ) % 10 == 0 for x in input_a   )   )
         self.assertTrue(_inputs_are_equal(UpperCamelCase   ,     UpperCamelCase   )   )

         lowerCAmelCase__      :			Optional[int]   =	pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
         self.assertTrue(all(len(UpperCamelCase   ) == expected_mult_pad_length for x in input_a   )   )
         self.assertEqual(input_a.shape[:2]   ,     (batch_size, expected_mult_pad_length)   )

         if feature_size > 1:
               self.assertTrue(input_a.shape[2] == feature_size   )

         # Check padding value is correct
         lowerCAmelCase__      :			str   =	(np.ones(self.feat_extract_tester.feature_size   ) * feat_extract.padding_value).sum()
         self.assertTrue(
             abs(np.asarray(input_a[0]   )[pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   )
             < 1E-3   )
         self.assertTrue(
             abs(
                 np.asarray(input_a[1]   )[pad_min_length + pad_diff :].sum()
                 - padding_vector_sum * (pad_max_length - pad_min_length - pad_diff)   )
             < 1E-3   )
         self.assertTrue(
             abs(
                 np.asarray(input_a[2]   )[pad_min_length + 2 * pad_diff :].sum()
                 - padding_vector_sum * (pad_max_length - pad_min_length - 2 * pad_diff)   )
             < 1E-3   )
         self.assertTrue(
             abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (pad_max_length - pad_min_length)   ) < 1E-3   )
         self.assertTrue(
             abs(input_a[0, pad_min_length:].sum() - padding_vector_sum * (expected_mult_pad_length - pad_min_length)   )
             < 1E-3   )






   def 	_lowerCAmelCase   (		self       :		Optional[Any]   ,     UpperCamelCase       :		int=False   )			->						List[str]:

         """simple docstring"""
         def _inputs_have_equal_length(UpperCamelCase       :		List[Any]   ):
               lowerCAmelCase__      :			List[str]   =	len(input[0]   )
               for input_slice in input[1:]:
                     if len(UpperCamelCase   ) != length:
                           return False
               return True

         def _inputs_are_equal(UpperCamelCase       :		Union[str, Any]   ,     UpperCamelCase       :		str   ):
               if len(UpperCamelCase   ) != len(UpperCamelCase   ):
                     return False

               for input_slice_a, input_slice_a in zip(UpperCamelCase   ,     UpperCamelCase   ):
                     if not np.allclose(np.asarray(UpperCamelCase   )   ,     np.asarray(UpperCamelCase   )   ,     atol=1E-3   ):
                           return False
               return True

         lowerCAmelCase__      :			Dict   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Any   =	self.feat_extract_tester.prepare_inputs_for_common(numpify=UpperCamelCase   )
         lowerCAmelCase__      :			str   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Optional[Any]   =	BatchFeature({input_name: speech_inputs}   )

         # truncate to smallest
         lowerCAmelCase__      :			str   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     truncation=UpperCamelCase   )
         lowerCAmelCase__      :			Dict   =	input_a[input_name]

         lowerCAmelCase__      :			str   =	feat_extract.pad(UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   )
         lowerCAmelCase__      :			Optional[int]   =	input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )

         # truncate to smallest with np
         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     return_tensors="""np"""   ,     truncation=UpperCamelCase   ,     )
         lowerCAmelCase__      :			List[Any]   =	input_a[input_name]

         lowerCAmelCase__      :			List[Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			Union[str, Any]   =	input_a[input_name]

         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(input_a.shape[1] == len(speech_inputs[0]   )   )

         # since truncation forces padding to be smaller than longest input
         # function can't return `np.ndarray`, but has to return list
         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )

         # truncate to middle
         lowerCAmelCase__      :			List[Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[1]   )   ,     truncation=UpperCamelCase   ,     return_tensors="""np"""   ,     )
         lowerCAmelCase__      :			List[Any]   =	input_a[input_name]

         lowerCAmelCase__      :			List[Any]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[1]   )   ,     truncation=UpperCamelCase   )
         lowerCAmelCase__      :			List[str]   =	input_a[input_name]

         lowerCAmelCase__      :			Any   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[1]   )   ,     return_tensors="""np"""   )
         lowerCAmelCase__      :			Dict   =	input_a[input_name]

         self.assertTrue(input_a.shape[1] == len(speech_inputs[1]   )   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(_inputs_are_equal(UpperCamelCase   ,     UpperCamelCase   )   )

         # since truncation forces padding to be smaller than longest input
         # function can't return `np.ndarray`, but has to return list
         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertTrue(len(input_a[-1]   ) == len(speech_inputs[-1]   )   )

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(UpperCamelCase   ):
               feat_extract.pad(UpperCamelCase   ,     truncation=UpperCamelCase   )[input_name]

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(UpperCamelCase   ):
               feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     truncation=UpperCamelCase   )[input_name]

         # padding has to be max_length when setting `truncation=True`
         with self.assertRaises(UpperCamelCase   ):
               feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     truncation=UpperCamelCase   )[input_name]

         # max_length parameter has to be provided when setting `truncation=True` and padding="max_length"
         with self.assertRaises(UpperCamelCase   ):
               feat_extract.pad(UpperCamelCase   ,     padding="""max_length"""   ,     truncation=UpperCamelCase   )[input_name]

         # test truncation for `pad_to_multiple_of` for List[int] + numpy
         lowerCAmelCase__      :			Any   =	12
         lowerCAmelCase__      :			Optional[int]   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     pad_to_multiple_of=UpperCamelCase   ,     truncation=UpperCamelCase   ,     )
         lowerCAmelCase__      :			List[Any]   =	input_a[input_name]

         lowerCAmelCase__      :			Any   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=len(speech_inputs[0]   )   ,     pad_to_multiple_of=UpperCamelCase   ,     )
         lowerCAmelCase__      :			Optional[Any]   =	input_a[input_name]

         # retrieve expected_length as multiple of pad_to_multiple_of
         lowerCAmelCase__      :			Union[str, Any]   =	len(speech_inputs[0]   )
         if expected_length % pad_to_multiple_of != 0:
               lowerCAmelCase__      :			Any   =	((len(speech_inputs[0]   ) // pad_to_multiple_of) + 1) * pad_to_multiple_of

         self.assertTrue(len(input_a[0]   ) == expected_length   )
         self.assertTrue(_inputs_have_equal_length(UpperCamelCase   )   )
         self.assertFalse(_inputs_have_equal_length(UpperCamelCase   )   )






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

         """simple docstring"""
         self._check_padding(numpify=UpperCamelCase   )






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

         """simple docstring"""
         self._check_padding(numpify=UpperCamelCase   )






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

         """simple docstring"""
         self._check_truncation(numpify=UpperCamelCase   )






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

         """simple docstring"""
         self._check_truncation(numpify=UpperCamelCase   )






   @require_torch
   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			int   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			str   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			str   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Optional[int]   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			Dict   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )[input_name]
         lowerCAmelCase__      :			str   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""pt"""   )[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_pt.numpy().astype(np.floataa   ).sum()   ) < 1E-2   )






   @require_tf
   def 	_lowerCAmelCase   (		self       :		Optional[Any]   )			->						str:

         """simple docstring"""
         lowerCAmelCase__      :			Tuple   =	self.feature_extraction_class(**self.feat_extract_dict   )
         lowerCAmelCase__      :			Tuple   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			List[Any]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			int   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			int   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )[input_name]
         lowerCAmelCase__      :			Any   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""tf"""   )[input_name]

         self.assertTrue(abs(input_np.astype(np.floataa   ).sum() - input_tf.numpy().astype(np.floataa   ).sum()   ) < 1E-2   )






   def 	_lowerCAmelCase   (		self       :		List[Any]   )			->						int:

         """simple docstring"""
         lowerCAmelCase__      :			Any   =	self.feat_extract_dict
         lowerCAmelCase__      :			int   =	True
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**UpperCamelCase   )
         lowerCAmelCase__      :			int   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			List[Any]   =	[len(UpperCamelCase   ) for x in speech_inputs]
         lowerCAmelCase__      :			Optional[Any]   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			List[str]   =	BatchFeature({input_name: speech_inputs}   )

         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(UpperCamelCase   ,     padding="""longest"""   ,     return_tensors="""np"""   )
         self.assertIn("""attention_mask"""   ,     UpperCamelCase   )
         self.assertListEqual(list(processed.attention_mask.shape   )   ,     list(processed[input_name].shape[:2]   )   )
         self.assertListEqual(processed.attention_mask.sum(-1   ).tolist()   ,     UpperCamelCase   )






   def 	_lowerCAmelCase   (		self       :		Optional[int]   )			->						Optional[Any]:

         """simple docstring"""
         lowerCAmelCase__      :			Union[str, Any]   =	self.feat_extract_dict
         lowerCAmelCase__      :			List[Any]   =	True
         lowerCAmelCase__      :			str   =	self.feature_extraction_class(**UpperCamelCase   )
         lowerCAmelCase__      :			int   =	self.feat_extract_tester.prepare_inputs_for_common()
         lowerCAmelCase__      :			Any   =	[len(UpperCamelCase   ) for x in speech_inputs]
         lowerCAmelCase__      :			int   =	feat_extract.model_input_names[0]

         lowerCAmelCase__      :			Optional[Any]   =	BatchFeature({input_name: speech_inputs}   )
         lowerCAmelCase__      :			Any   =	min(UpperCamelCase   )

         lowerCAmelCase__      :			Tuple   =	feat_extract.pad(
             UpperCamelCase   ,     padding="""max_length"""   ,     max_length=UpperCamelCase   ,     truncation=UpperCamelCase   ,     return_tensors="""np"""   )
         self.assertIn("""attention_mask"""   ,     UpperCamelCase   )
         self.assertListEqual(
             list(processed_pad.attention_mask.shape   )   ,     [processed_pad[input_name].shape[0], max_length]   )
         self.assertListEqual(
             processed_pad.attention_mask[:, :max_length].sum(-1   ).tolist()   ,     [max_length for x in speech_inputs]   )





