





from dataclasses import dataclass
from typing import List, Optional, Union

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

from ...models import PriorTransformer
from ...pipelines import DiffusionPipeline
from ...schedulers import HeunDiscreteScheduler
from ...utils import (
    BaseOutput,
    is_accelerate_available,
    logging,
    randn_tensor,
    replace_example_docstring,
)
from .renderer import ShapERenderer


_lowercase		:  Optional[Any]			       =logging.get_logger(__name__)  # pylint: disable=invalid-name

_lowercase		:  Optional[Any]			       ="""
    Examples:
        ```py
        >>> from PIL import Image
        >>> import torch
        >>> from diffusers import DiffusionPipeline
        >>> from diffusers.utils import export_to_gif, load_image

        >>> device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")

        >>> repo = \"openai/shap-e-img2img\"
        >>> pipe = DiffusionPipeline.from_pretrained(repo, torch_dtype=torch.float16)
        >>> pipe = pipe.to(device)

        >>> guidance_scale = 3.0
        >>> image_url = \"https://hf.co/datasets/diffusers/docs-images/resolve/main/shap-e/corgi.png\"
        >>> image = load_image(image_url).convert(\"RGB\")

        >>> images = pipe(
        ...     image,
        ...     guidance_scale=guidance_scale,
        ...     num_inference_steps=64,
        ...     frame_size=256,
        ... ).images

        >>> gif_path = export_to_gif(images[0], \"corgi_3d.gif\")
        ```
"""






@dataclass
class 						UpperCamelCase_  (  snake_case__							):
					_a      :						Union[PIL.Image.Image, np.ndarray]






class 						UpperCamelCase_  (  snake_case__							):



					def __init__(		self     :     Optional[Any]       ,      lowerCamelCase     :     PriorTransformer       ,      lowerCamelCase     :     CLIPVisionModel       ,      lowerCamelCase     :     CLIPImageProcessor       ,      lowerCamelCase     :     HeunDiscreteScheduler       ,      lowerCamelCase     :     ShapERenderer       ,      ):
							super().__init__()

							self.register_modules(
							    prior=lowerCamelCase       ,      image_encoder=lowerCamelCase       ,      image_processor=lowerCamelCase       ,      scheduler=lowerCamelCase       ,      renderer=lowerCamelCase       ,      )



					def   __a     (		self     :     Optional[int]       ,      lowerCamelCase     :     Any       ,      lowerCamelCase     :     List[Any]       ,      lowerCamelCase     :     Tuple       ,      lowerCamelCase     :     Tuple       ,      lowerCamelCase     :     Optional[Any]       ,      lowerCamelCase     :     Optional[Any]						):
							if latents is None:
									lowerCamelCase_	:     Tuple 						=      randn_tensor(lowerCamelCase       ,      generator=lowerCamelCase       ,      device=lowerCamelCase       ,      dtype=lowerCamelCase						)
							else:
									if latents.shape != shape:
											raise ValueError(F"Unexpected latents shape, got {latents.shape}, expected {shape}"						)
									lowerCamelCase_	:     Tuple 						=      latents.to(lowerCamelCase						)

							lowerCamelCase_	:     Optional[Any] 						=      latents * scheduler.init_noise_sigma
							return latents



					def   __a     (		self     :     List[str]       ,      lowerCamelCase     :     str=0						):
							if is_accelerate_available():
									from accelerate import cpu_offload
							else:
									raise ImportError('Please install accelerate via `pip install accelerate`'						)

							lowerCamelCase_	:     int 						=      torch.device(F"cuda:{gpu_id}"						)

							lowerCamelCase_	:     Union[str, Any] 						=      [self.image_encoder, self.prior]
							for cpu_offloaded_model in models:
									if cpu_offloaded_model is not None:
											cpu_offload(lowerCamelCase       ,      lowerCamelCase						)



					@property
					def   __a     (		self     :     Optional[int]						):
							if self.device != torch.device('meta'						) or not hasattr(self.image_encoder       ,      '_hf_hook'						):
									return self.device
							for module in self.image_encoder.modules():
									if (
									    hasattr(lowerCamelCase       ,      '_hf_hook'						)
									    and hasattr(module._hf_hook       ,      'execution_device'						)
									    and module._hf_hook.execution_device is not None
									):
											return torch.device(module._hf_hook.execution_device						)
							return self.device



					def   __a     (		self     :     List[Any]       ,      lowerCamelCase     :     int       ,      lowerCamelCase     :     List[Any]       ,      lowerCamelCase     :     List[Any]       ,      lowerCamelCase     :     Tuple       ,      ):
							if isinstance(lowerCamelCase       ,      lowerCamelCase						) and isinstance(image[0]       ,      torch.Tensor						):
									lowerCamelCase_	:     Any 						=      torch.cat(lowerCamelCase       ,      axis=0						) if image[0].ndim == 4 else torch.stack(lowerCamelCase       ,      axis=0						)

							if not isinstance(lowerCamelCase       ,      torch.Tensor						):
									lowerCamelCase_	:     str 						=      self.image_processor(lowerCamelCase       ,      return_tensors='pt'						).pixel_values[0].unsqueeze(0						)

							lowerCamelCase_	:     str 						=      image.to(dtype=self.image_encoder.dtype       ,      device=lowerCamelCase						)

							lowerCamelCase_	:     List[Any] 						=      self.image_encoder(lowerCamelCase						)['last_hidden_state']
							lowerCamelCase_	:     Tuple 						=      image_embeds[:, 1:, :].contiguous()  # batch_size, dim, 256

							lowerCamelCase_	:     Dict 						=      image_embeds.repeat_interleave(lowerCamelCase       ,      dim=0						)

							if do_classifier_free_guidance:
									lowerCamelCase_	:     Optional[int] 						=      torch.zeros_like(lowerCamelCase						)

									# For classifier free guidance, we need to do two forward passes.
									# Here we concatenate the unconditional and text embeddings into a single batch
									# to avoid doing two forward passes
									lowerCamelCase_	:     str 						=      torch.cat([negative_image_embeds, image_embeds]						)

							return image_embeds





					@torch.no_grad()
					@replace_example_docstring(lowerCamelCase						)
					def __call__(		self     :     Union[str, Any]       ,      lowerCamelCase     :     Union[PIL.Image.Image, List[PIL.Image.Image]]       ,      lowerCamelCase     :     int = 1       ,      lowerCamelCase     :     int = 25       ,      lowerCamelCase     :     Optional[Union[torch.Generator, List[torch.Generator]]] = None       ,      lowerCamelCase     :     Optional[torch.FloatTensor] = None       ,      lowerCamelCase     :     float = 4.0       ,      lowerCamelCase     :     int = 64       ,      lowerCamelCase     :     Optional[str] = "pil"       ,      lowerCamelCase     :     bool = True       ,      ):

							if isinstance(lowerCamelCase       ,      PIL.Image.Image						):
									lowerCamelCase_	:     str 						=      1
							elif isinstance(lowerCamelCase       ,      torch.Tensor						):
									lowerCamelCase_	:     List[Any] 						=      image.shape[0]
							elif isinstance(lowerCamelCase       ,      lowerCamelCase						) and isinstance(image[0]       ,      (torch.Tensor, PIL.Image.Image)						):
									lowerCamelCase_	:     Any 						=      len(lowerCamelCase						)
							else:
									raise ValueError(
									    F"`image` has to be of type `PIL.Image.Image`, `torch.Tensor`, `List[PIL.Image.Image]` or `List[torch.Tensor]` but is {type(lowerCamelCase						)}"						)

							lowerCamelCase_	:     int 						=      self._execution_device

							lowerCamelCase_	:     List[Any] 						=      batch_size * num_images_per_prompt

							lowerCamelCase_	:     Dict 						=      guidance_scale > 1.0
							lowerCamelCase_	:     Any 						=      self._encode_image(lowerCamelCase       ,      lowerCamelCase       ,      lowerCamelCase       ,      lowerCamelCase						)

							# prior

							self.scheduler.set_timesteps(lowerCamelCase       ,      device=lowerCamelCase						)
							lowerCamelCase_	:     List[Any] 						=      self.scheduler.timesteps

							lowerCamelCase_	:     str 						=      self.prior.config.num_embeddings
							lowerCamelCase_	:     Union[str, Any] 						=      self.prior.config.embedding_dim

							lowerCamelCase_	:     Dict 						=      self.prepare_latents(
							    (batch_size, num_embeddings * embedding_dim)       ,      image_embeds.dtype       ,      lowerCamelCase       ,      lowerCamelCase       ,      lowerCamelCase       ,      self.scheduler       ,      )

							# YiYi notes: for testing only to match ldm, we can directly create a latents with desired shape: batch_size, num_embeddings, embedding_dim
							lowerCamelCase_	:     Tuple 						=      latents.reshape(latents.shape[0]       ,      lowerCamelCase       ,      lowerCamelCase						)

							for i, t in enumerate(self.progress_bar(lowerCamelCase						)						):
									# expand the latents if we are doing classifier free guidance
									lowerCamelCase_	:     Optional[int] 						=      torch.cat([latents] * 2						) if do_classifier_free_guidance else latents
									lowerCamelCase_	:     Optional[int] 						=      self.scheduler.scale_model_input(lowerCamelCase       ,      lowerCamelCase						)

									lowerCamelCase_	:     Optional[Any] 						=      self.prior(
									    lowerCamelCase       ,      timestep=lowerCamelCase       ,      proj_embedding=lowerCamelCase       ,      ).predicted_image_embedding

									# remove the variance
									lowerCamelCase_						,      lowerCamelCase_	:     str 						=      noise_pred.split(
									    scaled_model_input.shape[2]       ,      dim=2						)  # batch_size, num_embeddings, embedding_dim

									if do_classifier_free_guidance is not None:
											lowerCamelCase_						,      lowerCamelCase_	:     Union[str, Any] 						=      noise_pred.chunk(2						)
											lowerCamelCase_	:     Tuple 						=      noise_pred_uncond + guidance_scale * (noise_pred - noise_pred_uncond)

									lowerCamelCase_	:     List[Any] 						=      self.scheduler.step(
									    lowerCamelCase       ,      timestep=lowerCamelCase       ,      sample=lowerCamelCase       ,      ).prev_sample

							if output_type == "latent":
									return ShapEPipelineOutput(images=lowerCamelCase						)

							lowerCamelCase_	:     List[Any] 						=      []
							for i, latent in enumerate(lowerCamelCase						):
									print()
									lowerCamelCase_	:     Optional[int] 						=      self.renderer.decode(
									    latent[None, :]       ,      lowerCamelCase       ,      size=lowerCamelCase       ,      ray_batch_size=40_96       ,      n_coarse_samples=64       ,      n_fine_samples=1_28       ,      )

									images.append(lowerCamelCase						)

							lowerCamelCase_	:     Any 						=      torch.stack(lowerCamelCase						)

							if output_type not in ["np", "pil"]:
									raise ValueError(F"Only the output types `pil` and `np` are supported not output_type={output_type}"						)

							lowerCamelCase_	:     Optional[int] 						=      images.cpu().numpy()

							if output_type == "pil":
									lowerCamelCase_	:     List[str] 						=      [self.numpy_to_pil(lowerCamelCase						) for image in images]

							# Offload last model to CPU
							if hasattr(self       ,      'final_offload_hook'						) and self.final_offload_hook is not None:
									self.final_offload_hook.offload()

							if not return_dict:
									return (images,)

							return ShapEPipelineOutput(images=lowerCamelCase						)







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 						UpperCamelCase_  (  snake_case__							):
					# to overwrite at feature extractactor specific tests
					_a      :						str						    =					None
					_a      :						Tuple						    =					None



					@property
					def   __a     (		self     :     str						):
							return self.feat_extract_tester.prepare_feat_extract_dict()



					def   __a     (		self     :     int						):
							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'feature_size'						)						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'sampling_rate'						)						)
							self.assertTrue(hasattr(lowerCamelCase       ,      'padding_value'						)						)



					def   __a     (		self     :     List[Any]						):
							lowerCamelCase_	:     Dict 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     str 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     int 						=      feat_extract.model_input_names[0]

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

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

							lowerCamelCase_	:     Tuple 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     Union[str, Any] 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='np'						)

							lowerCamelCase_	:     int 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     Union[str, 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)						)



					@require_torch
					def   __a     (		self     :     Dict						):
							lowerCamelCase_	:     Any 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     List[Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     Tuple 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Any 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='pt'						)

							lowerCamelCase_	:     Optional[int] 						=      processed_features[input_name]

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     Optional[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   __a     (		self     :     Tuple						):
							lowerCamelCase_	:     int 						=      self.feat_extract_tester.prepare_inputs_for_common(equal_length=lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     int 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     List[str] 						=      BatchFeature({input_name: speech_inputs}       ,      tensor_type='tf'						)

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

							if len(batch_features_input.shape						) < 3:
									lowerCamelCase_	:     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   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     int=False						):
							def _inputs_have_equal_length(lowerCamelCase     :     Union[str, Any]						):
									lowerCamelCase_	:     Any 						=      len(input[0]						)
									for input_slice in input[1:]:
											if len(lowerCamelCase						) != length:
													return False
									return True

							def _inputs_are_equal(lowerCamelCase     :     List[str]       ,      lowerCamelCase     :     Dict						):
									if len(lowerCamelCase						) != len(lowerCamelCase						):
											return False

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

							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase						)
							lowerCamelCase_	:     List[Any] 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     List[Any] 						=      BatchFeature({input_name: speech_inputs}						)

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

							# test padding for List[int] + numpy
							lowerCamelCase_	:     int 						=      feat_extract.pad(lowerCamelCase       ,      padding=lowerCamelCase						)
							lowerCamelCase_	:     Tuple 						=      input_a[input_name]

							lowerCamelCase_	:     List[str] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'						)
							lowerCamelCase_	:     Optional[Any] 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[-1]						)						)
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     Union[str, Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)
							lowerCamelCase_	:     int 						=      input_a[input_name]

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

							lowerCamelCase_	:     Union[str, Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=lowerCamelCase       ,      return_tensors='np'						)
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertTrue(_inputs_are_equal(lowerCamelCase       ,      lowerCamelCase						)						)
							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_	:     Optional[Any] 						=      feat_extract.pad(lowerCamelCase       ,      pad_to_multiple_of=10						)
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      pad_to_multiple_of=10						)
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      pad_to_multiple_of=10       ,      max_length=lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     Any 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      pad_to_multiple_of=10       ,      max_length=lowerCamelCase       ,      return_tensors='np'       ,      )
							lowerCamelCase_	:     str 						=      input_a[input_name]

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

							lowerCamelCase_	:     Dict 						=      pad_max_length if pad_max_length % 10 == 0 else (pad_max_length // 10 + 1) * 10
							self.assertTrue(all(len(lowerCamelCase						) == 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_	:     Dict 						=      (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   __a     (		self     :     Optional[Any]       ,      lowerCamelCase     :     Any=False						):
							def _inputs_have_equal_length(lowerCamelCase     :     Dict						):
									lowerCamelCase_	:     Dict 						=      len(input[0]						)
									for input_slice in input[1:]:
											if len(lowerCamelCase						) != length:
													return False
									return True

							def _inputs_are_equal(lowerCamelCase     :     int       ,      lowerCamelCase     :     List[str]						):
									if len(lowerCamelCase						) != len(lowerCamelCase						):
											return False

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

							lowerCamelCase_	:     List[str] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common(numpify=lowerCamelCase						)
							lowerCamelCase_	:     Any 						=      feat_extract.model_input_names[0]

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

							# truncate to smallest
							lowerCamelCase_	:     Dict 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      truncation=lowerCamelCase						)
							lowerCamelCase_	:     int 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)						)
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)

							# truncate to smallest with np
							lowerCamelCase_	:     Optional[int] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      return_tensors='np'       ,      truncation=lowerCamelCase       ,      )
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     int 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      return_tensors='np'						)
							lowerCamelCase_	:     Tuple 						=      input_a[input_name]

							self.assertTrue(_inputs_have_equal_length(lowerCamelCase						)						)
							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(lowerCamelCase						)						)

							# truncate to middle
							lowerCamelCase_	:     Tuple 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      truncation=lowerCamelCase       ,      return_tensors='np'       ,      )
							lowerCamelCase_	:     Union[str, Any] 						=      input_a[input_name]

							lowerCamelCase_	:     str 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      truncation=lowerCamelCase						)
							lowerCamelCase_	:     Any 						=      input_a[input_name]

							lowerCamelCase_	:     int 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[1]						)       ,      return_tensors='np'						)
							lowerCamelCase_	:     Optional[int] 						=      input_a[input_name]

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

							# 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(lowerCamelCase						)						)
							self.assertTrue(len(input_a[-1]						) == len(speech_inputs[-1]						)						)

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

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

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

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

							# test truncation for `pad_to_multiple_of` for List[int] + numpy
							lowerCamelCase_	:     str 						=      12
							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      pad_to_multiple_of=lowerCamelCase       ,      truncation=lowerCamelCase       ,      )
							lowerCamelCase_	:     List[str] 						=      input_a[input_name]

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=len(speech_inputs[0]						)       ,      pad_to_multiple_of=lowerCamelCase       ,      )
							lowerCamelCase_	:     Dict 						=      input_a[input_name]

							# retrieve expected_length as multiple of pad_to_multiple_of
							lowerCamelCase_	:     Optional[Any] 						=      len(speech_inputs[0]						)
							if expected_length % pad_to_multiple_of != 0:
									lowerCamelCase_	:     str 						=      ((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(lowerCamelCase						)						)
							self.assertFalse(_inputs_have_equal_length(lowerCamelCase						)						)



					def   __a     (		self     :     Any						):
							self._check_padding(numpify=lowerCamelCase						)



					def   __a     (		self     :     List[Any]						):
							self._check_padding(numpify=lowerCamelCase						)



					def   __a     (		self     :     int						):
							self._check_truncation(numpify=lowerCamelCase						)



					def   __a     (		self     :     Optional[int]						):
							self._check_truncation(numpify=lowerCamelCase						)



					@require_torch
					def   __a     (		self     :     str						):
							lowerCamelCase_	:     List[Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     str 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.model_input_names[0]

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

							lowerCamelCase_	:     int 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)[input_name]
							lowerCamelCase_	:     Dict 						=      feat_extract.pad(lowerCamelCase       ,      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   __a     (		self     :     Any						):
							lowerCamelCase_	:     Union[str, Any] 						=      self.feature_extraction_class(**self.feat_extract_dict						)
							lowerCamelCase_	:     List[str] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     Tuple 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Tuple 						=      BatchFeature({input_name: speech_inputs}						)

							lowerCamelCase_	:     Dict 						=      feat_extract.pad(lowerCamelCase       ,      padding='longest'       ,      return_tensors='np'						)[input_name]
							lowerCamelCase_	:     List[str] 						=      feat_extract.pad(lowerCamelCase       ,      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   __a     (		self     :     str						):
							lowerCamelCase_	:     Any 						=      self.feat_extract_dict
							lowerCamelCase_	:     Optional[Any] 						=      True
							lowerCamelCase_	:     Dict 						=      self.feature_extraction_class(**lowerCamelCase						)
							lowerCamelCase_	:     Optional[int] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     List[str] 						=      [len(lowerCamelCase						) for x in speech_inputs]
							lowerCamelCase_	:     List[Any] 						=      feat_extract.model_input_names[0]

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

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





					def   __a     (		self     :     Dict						):
							lowerCamelCase_	:     int 						=      self.feat_extract_dict
							lowerCamelCase_	:     Any 						=      True
							lowerCamelCase_	:     int 						=      self.feature_extraction_class(**lowerCamelCase						)
							lowerCamelCase_	:     List[str] 						=      self.feat_extract_tester.prepare_inputs_for_common()
							lowerCamelCase_	:     str 						=      [len(lowerCamelCase						) for x in speech_inputs]
							lowerCamelCase_	:     Optional[Any] 						=      feat_extract.model_input_names[0]

							lowerCamelCase_	:     Any 						=      BatchFeature({input_name: speech_inputs}						)
							lowerCamelCase_	:     Optional[Any] 						=      min(lowerCamelCase						)

							lowerCamelCase_	:     List[Any] 						=      feat_extract.pad(
							    lowerCamelCase       ,      padding='max_length'       ,      max_length=lowerCamelCase       ,      truncation=lowerCamelCase       ,      return_tensors='np'						)
							self.assertIn('attention_mask'       ,      lowerCamelCase						)
							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]						)
