'''simple docstring'''




import inspect
from typing import Callable, List, Optional, Union

import torch
from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer

from diffusers import DiffusionPipeline
from diffusers.models import AutoencoderKL, UNetaDConditionModel
from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
from diffusers.utils import logging


__lowercase          =  logging.get_logger(__name__)  # pylint: disable=invalid-name






class 				a__(					__snake_case	):


			'''simple docstring'''






			def __init__(   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    __lowerCAmelCase       ,    ):




					"""simple docstring"""


					super().__init__()
					self.register_modules(
					    vae=UpperCamelCase__       ,    text_encoder=UpperCamelCase__       ,    tokenizer=UpperCamelCase__       ,    unet=UpperCamelCase__       ,    scheduler=UpperCamelCase__       ,    safety_checker=UpperCamelCase__       ,    feature_extractor=UpperCamelCase__       ,    )



			def 							a_       (   self       ,    __lowerCAmelCase = "auto"):




					"""simple docstring"""


					if slice_size == "auto":
							# half the attention head size is usually a good trade-off between
							# speed and memory
							lowerCAmelCase   					=  self.unet.config.attention_head_dim // 2
					self.unet.set_attention_slice(UpperCamelCase__)



			def 							a_       (   self):




					"""simple docstring"""


					self.enable_attention_slicing(UpperCamelCase__)







			@torch.no_grad()
			def __call__(   self       ,    __lowerCAmelCase       ,    __lowerCAmelCase = 512       ,    __lowerCAmelCase = 512       ,    __lowerCAmelCase = 50       ,    __lowerCAmelCase = 7.5       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = 1       ,    __lowerCAmelCase = 0.0       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = "pil"       ,    __lowerCAmelCase = True       ,    __lowerCAmelCase = None       ,    __lowerCAmelCase = 1       ,    __lowerCAmelCase = None       ,    **__lowerCAmelCase       ,    ):




					"""simple docstring"""


					if isinstance(UpperCamelCase__       ,    UpperCamelCase__):
							lowerCAmelCase   					=  1
					elif isinstance(UpperCamelCase__       ,    UpperCamelCase__):
							lowerCAmelCase   					=  len(UpperCamelCase__)
					else:
							raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(UpperCamelCase__)}")

					if height % 8 != 0 or width % 8 != 0:
							raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")

					if (callback_steps is None) or (
					    callback_steps is not None and (not isinstance(UpperCamelCase__       ,    UpperCamelCase__) or callback_steps <= 0)
					):
							raise ValueError(
							    f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
							    f" {type(UpperCamelCase__)}.")

					# get prompt text embeddings
					lowerCAmelCase   					=  self.tokenizer(
					    UpperCamelCase__       ,    padding="""max_length"""       ,    max_length=self.tokenizer.model_max_length       ,    return_tensors="""pt"""       ,    )
					lowerCAmelCase   					=  text_inputs.input_ids

					if text_input_ids.shape[-1] > self.tokenizer.model_max_length:
							lowerCAmelCase   					=  self.tokenizer.batch_decode(text_input_ids[:, self.tokenizer.model_max_length :])
							logger.warning(
							    """The following part of your input was truncated because CLIP can only handle sequences up to"""
							    f" {self.tokenizer.model_max_length} tokens: {removed_text}")
							lowerCAmelCase   					=  text_input_ids[:, : self.tokenizer.model_max_length]

					if text_embeddings is None:
							lowerCAmelCase   					=  self.text_encoder(text_input_ids.to(self.device))[0]

					# duplicate text embeddings for each generation per prompt, using mps friendly method
					lowerCAmelCase   					=  text_embeddings.shape
					lowerCAmelCase   					=  text_embeddings.repeat(1       ,    UpperCamelCase__       ,    1)
					lowerCAmelCase   					=  text_embeddings.view(bs_embed * num_images_per_prompt       ,    UpperCamelCase__       ,    -1)

					# here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
					# of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
					# corresponds to doing no classifier free guidance.
					lowerCAmelCase   					=  guidance_scale > 1.0
					# get unconditional embeddings for classifier free guidance
					if do_classifier_free_guidance:
							lowerCAmelCase   					=  42
							if negative_prompt is None:
									lowerCAmelCase   					=  [""]
							elif type(UpperCamelCase__) is not type(UpperCamelCase__):
									raise TypeError(
									    f"`negative_prompt` should be the same type to `prompt`, but got {type(UpperCamelCase__)} !="
									    f" {type(UpperCamelCase__)}.")
							elif isinstance(UpperCamelCase__       ,    UpperCamelCase__):
									lowerCAmelCase   					=  [negative_prompt]
							elif batch_size != len(UpperCamelCase__):
									raise ValueError(
									    f"`negative_prompt`: {negative_prompt} has batch size {len(UpperCamelCase__)}, but `prompt`:"
									    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
									    """ the batch size of `prompt`.""")
							else:
									lowerCAmelCase   					=  negative_prompt

							lowerCAmelCase   					=  text_input_ids.shape[-1]
							lowerCAmelCase   					=  self.tokenizer(
							    UpperCamelCase__       ,    padding="""max_length"""       ,    max_length=UpperCamelCase__       ,    truncation=UpperCamelCase__       ,    return_tensors="""pt"""       ,    )
							lowerCAmelCase   					=  self.text_encoder(uncond_input.input_ids.to(self.device))[0]

							# duplicate unconditional embeddings for each generation per prompt, using mps friendly method
							lowerCAmelCase   					=  uncond_embeddings.shape[1]
							lowerCAmelCase   					=  uncond_embeddings.repeat(UpperCamelCase__       ,    UpperCamelCase__       ,    1)
							lowerCAmelCase   					=  uncond_embeddings.view(batch_size * num_images_per_prompt       ,    UpperCamelCase__       ,    -1)

							# 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   					=  torch.cat([uncond_embeddings, text_embeddings])

					# get the initial random noise unless the user supplied it

					# Unlike in other pipelines, latents need to be generated in the target device
					# for 1-to-1 results reproducibility with the CompVis implementation.
					# However this currently doesn't work in `mps`.
					lowerCAmelCase   					=  (batch_size * num_images_per_prompt, self.unet.config.in_channels, height // 8, width // 8)
					lowerCAmelCase   					=  (batch_size * num_images_per_prompt, self.unet.config.in_channels, 64, 64)
					lowerCAmelCase   					=  text_embeddings.dtype
					if latents is None:
							if self.device.type == "mps":
									# randn does not exist on mps
									lowerCAmelCase   					=  torch.randn(
									    UpperCamelCase__       ,    generator=UpperCamelCase__       ,    device="""cpu"""       ,    dtype=UpperCamelCase__).to(self.device)
									lowerCAmelCase   					=  torch.randn(UpperCamelCase__       ,    generator=UpperCamelCase__       ,    device="""cpu"""       ,    dtype=UpperCamelCase__).to(
									    self.device)
							else:
									lowerCAmelCase   					=  torch.randn(
									    UpperCamelCase__       ,    generator=UpperCamelCase__       ,    device=self.device       ,    dtype=UpperCamelCase__)
									lowerCAmelCase   					=  torch.randn(UpperCamelCase__       ,    generator=UpperCamelCase__       ,    device=self.device       ,    dtype=UpperCamelCase__)
					else:
							if latents_reference.shape != latents_shape:
									raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {latents_shape}")
							lowerCAmelCase   					=  latents_reference.to(self.device)
							lowerCAmelCase   					=  latents.to(self.device)

					# This is the key part of the pipeline where we
					# try to ensure that the generated images w/ the same seed
					# but different sizes actually result in similar images
					lowerCAmelCase   					=  (latents_shape[3] - latents_shape_reference[3]) // 2
					lowerCAmelCase   					=  (latents_shape[2] - latents_shape_reference[2]) // 2
					lowerCAmelCase   					=  latents_shape_reference[3] if dx >= 0 else latents_shape_reference[3] + 2 * dx
					lowerCAmelCase   					=  latents_shape_reference[2] if dy >= 0 else latents_shape_reference[2] + 2 * dy
					lowerCAmelCase   					=  0 if dx < 0 else dx
					lowerCAmelCase   					=  0 if dy < 0 else dy
					lowerCAmelCase   					=  max(-dx       ,    0)
					lowerCAmelCase   					=  max(-dy       ,    0)
					# import pdb
					# pdb.set_trace()
					lowerCAmelCase   					=  latents_reference[:, :, dy : dy + h, dx : dx + w]

					# set timesteps
					self.scheduler.set_timesteps(UpperCamelCase__)

					# Some schedulers like PNDM have timesteps as arrays
					# It's more optimized to move all timesteps to correct device beforehand
					lowerCAmelCase   					=  self.scheduler.timesteps.to(self.device)

					# scale the initial noise by the standard deviation required by the scheduler
					lowerCAmelCase   					=  latents * self.scheduler.init_noise_sigma

					# prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
					# eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
					# eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
					# and should be between [0, 1]
					lowerCAmelCase   					=  "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
					lowerCAmelCase   					=  {}
					if accepts_eta:
							lowerCAmelCase   					=  eta

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

							# predict the noise residual
							lowerCAmelCase   					=  self.unet(UpperCamelCase__       ,    UpperCamelCase__       ,    encoder_hidden_states=UpperCamelCase__).sample

							# perform guidance
							if do_classifier_free_guidance:
									lowerCAmelCase   					=  noise_pred.chunk(2)
									lowerCAmelCase   					=  noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

							# compute the previous noisy sample x_t -> x_t-1
							lowerCAmelCase   					=  self.scheduler.step(UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__       ,    **UpperCamelCase__).prev_sample

							# call the callback, if provided
							if callback is not None and i % callback_steps == 0:
									callback(UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__)

					lowerCAmelCase   					=  1 / 0.18215 * latents
					lowerCAmelCase   					=  self.vae.decode(UpperCamelCase__).sample

					lowerCAmelCase   					=  (image / 2 + 0.5).clamp(0       ,    1)

					# we always cast to float32 as this does not cause significant overhead and is compatible with bfloat16
					lowerCAmelCase   					=  image.cpu().permute(0       ,    2       ,    3       ,    1).float().numpy()

					if self.safety_checker is not None:
							lowerCAmelCase   					=  self.feature_extractor(self.numpy_to_pil(UpperCamelCase__)       ,    return_tensors="""pt""").to(
							    self.device)
							lowerCAmelCase   					=  self.safety_checker(
							    images=UpperCamelCase__       ,    clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype))
					else:
							lowerCAmelCase   					=  None

					if output_type == "pil":
							lowerCAmelCase   					=  self.numpy_to_pil(UpperCamelCase__)

					if not return_dict:
							return (image, has_nsfw_concept)

					return StableDiffusionPipelineOutput(images=UpperCamelCase__       ,    nsfw_content_detected=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     snake_case	(				__snake_case  ):
				# to overwrite at feature extractactor specific tests
				SCREAMING_SNAKE_CASE_   :      List[str]         =  None
				SCREAMING_SNAKE_CASE_   :      Tuple         =  None

				@property
				def 							lowercase_     (	self							:				str)->   Any:



						'''simple docstring'''


						return self.feat_extract_tester.prepare_feat_extract_dict()

				def 							lowercase_     (	self							:				Tuple)->   Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[int]          =			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 							lowercase_     (	self							:				Dict)->   Any:



						'''simple docstring'''


						__lowerCAmelCase:       Tuple          =			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:       List[Any]          =			BatchFeature({input_name: speech_inputs})

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

						__lowerCAmelCase:       Tuple          =			self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase__)
						__lowerCAmelCase:       Optional[int]          =			BatchFeature({input_name: speech_inputs}     ,  tensor_type="np")

						__lowerCAmelCase:       Optional[int]          =			processed_features[input_name]

						if len(batch_features_input.shape) < 3:
								__lowerCAmelCase:       Dict          =			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 							lowercase_     (	self							:				Optional[int])->   Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Any          =			self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase__)
						__lowerCAmelCase:       int          =			self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase:       Any          =			feat_extract.model_input_names[0]

						__lowerCAmelCase:       Any          =			BatchFeature({input_name: speech_inputs}     ,  tensor_type="pt")

						__lowerCAmelCase:       str          =			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))

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



						'''simple docstring'''


						__lowerCAmelCase:       Any          =			self.feat_extract_tester.prepare_inputs_for_common(equal_length=UpperCamelCase__)
						__lowerCAmelCase:       Optional[int]          =			self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase:       Any          =			feat_extract.model_input_names[0]

						__lowerCAmelCase:       Optional[int]          =			BatchFeature({input_name: speech_inputs}     ,  tensor_type="tf")

						__lowerCAmelCase:       int          =			processed_features[input_name]

						if len(batch_features_input.shape) < 3:
								__lowerCAmelCase:       Dict          =			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 							lowercase_     (	self							:				Union[str, Any]     ,  UpperCamelCase__							:				List[str]=False)->   Optional[int]:



						'''simple docstring'''


						def _inputs_have_equal_length(UpperCamelCase__							:				Tuple):
								__lowerCAmelCase:       Optional[int]          =			len(input[0])
								for input_slice in input[1:]:
										if len(UpperCamelCase__) != length:
												return False
								return True

						def _inputs_are_equal(UpperCamelCase__							:				str     ,  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:       List[str]          =			self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase:       Optional[Any]          =			self.feat_extract_tester.prepare_inputs_for_common(numpify=UpperCamelCase__)
						__lowerCAmelCase:       Tuple          =			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:       str          =			self.feat_extract_tester.max_seq_length + pad_diff
						__lowerCAmelCase:       Tuple          =			self.feat_extract_tester.min_seq_length
						__lowerCAmelCase:       Union[str, Any]          =			self.feat_extract_tester.batch_size
						__lowerCAmelCase:       Tuple          =			self.feat_extract_tester.feature_size

						# test padding for List[int] + numpy
						__lowerCAmelCase:       Optional[int]          =			feat_extract.pad(UpperCamelCase__     ,  padding=UpperCamelCase__)
						__lowerCAmelCase:       Optional[int]          =			input_a[input_name]

						__lowerCAmelCase:       List[Any]          =			feat_extract.pad(UpperCamelCase__     ,  padding="longest")
						__lowerCAmelCase:       int          =			input_a[input_name]

						__lowerCAmelCase:       Tuple          =			feat_extract.pad(UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[-1]))
						__lowerCAmelCase:       Optional[Any]          =			input_a[input_name]

						__lowerCAmelCase:       Union[str, Any]          =			feat_extract.pad(UpperCamelCase__     ,  padding="longest"     ,  return_tensors="np")
						__lowerCAmelCase:       Optional[int]          =			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:       Any          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=UpperCamelCase__     ,  return_tensors="np")
						__lowerCAmelCase:       Optional[Any]          =			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:       Dict          =			feat_extract.pad(UpperCamelCase__     ,  pad_to_multiple_of=1_0)
						__lowerCAmelCase:       Tuple          =			input_a[input_name]

						__lowerCAmelCase:       Tuple          =			feat_extract.pad(UpperCamelCase__     ,  padding="longest"     ,  pad_to_multiple_of=1_0)
						__lowerCAmelCase:       List[str]          =			input_a[input_name]

						__lowerCAmelCase:       str          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  pad_to_multiple_of=1_0     ,  max_length=UpperCamelCase__)
						__lowerCAmelCase:       str          =			input_a[input_name]

						__lowerCAmelCase:       Dict          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  pad_to_multiple_of=1_0     ,  max_length=UpperCamelCase__     ,  return_tensors="np"     ,  )
						__lowerCAmelCase:       List[str]          =			input_a[input_name]

						self.assertTrue(all(len(UpperCamelCase__) % 1_0 == 0 for x in input_a))
						self.assertTrue(_inputs_are_equal(UpperCamelCase__     ,  UpperCamelCase__))

						__lowerCAmelCase:       Optional[Any]          =			pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
						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:       Any          =			(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 							lowercase_     (	self							:				Optional[int]     ,  UpperCamelCase__							:				Optional[int]=False)->   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__							:				Optional[int]     ,  UpperCamelCase__							:				List[Any]):
								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:       Any          =			feat_extract.model_input_names[0]

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

						# truncate to smallest
						__lowerCAmelCase:       int          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[0])     ,  truncation=UpperCamelCase__)
						__lowerCAmelCase:       Any          =			input_a[input_name]

						__lowerCAmelCase:       str          =			feat_extract.pad(UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[0]))
						__lowerCAmelCase:       Tuple          =			input_a[input_name]

						self.assertTrue(_inputs_have_equal_length(UpperCamelCase__))
						self.assertFalse(_inputs_have_equal_length(UpperCamelCase__))

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

						__lowerCAmelCase:       List[str]          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[0])     ,  return_tensors="np")
						__lowerCAmelCase:       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:       Union[str, Any]          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[1])     ,  truncation=UpperCamelCase__     ,  return_tensors="np"     ,  )
						__lowerCAmelCase:       int          =			input_a[input_name]

						__lowerCAmelCase:       List[Any]          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[1])     ,  truncation=UpperCamelCase__)
						__lowerCAmelCase:       Dict          =			input_a[input_name]

						__lowerCAmelCase:       List[Any]          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[1])     ,  return_tensors="np")
						__lowerCAmelCase:       str          =			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:       Tuple          =			1_2
						__lowerCAmelCase:       Optional[int]          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[0])     ,  pad_to_multiple_of=UpperCamelCase__     ,  truncation=UpperCamelCase__     ,  )
						__lowerCAmelCase:       Dict          =			input_a[input_name]

						__lowerCAmelCase:       List[str]          =			feat_extract.pad(
						    UpperCamelCase__     ,  padding="max_length"     ,  max_length=len(speech_inputs[0])     ,  pad_to_multiple_of=UpperCamelCase__     ,  )
						__lowerCAmelCase:       str          =			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:       Optional[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 							lowercase_     (	self							:				Union[str, Any])->   Optional[Any]:



						'''simple docstring'''


						self._check_padding(numpify=UpperCamelCase__)

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



						'''simple docstring'''


						self._check_padding(numpify=UpperCamelCase__)

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



						'''simple docstring'''


						self._check_truncation(numpify=UpperCamelCase__)

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



						'''simple docstring'''


						self._check_truncation(numpify=UpperCamelCase__)

				@require_torch
				def 							lowercase_     (	self							:				Dict)->   Dict:



						'''simple docstring'''


						__lowerCAmelCase:       Optional[Any]          =			self.feature_extraction_class(**self.feat_extract_dict)
						__lowerCAmelCase:       Optional[Any]          =			self.feat_extract_tester.prepare_inputs_for_common()
						__lowerCAmelCase:       Any          =			feat_extract.model_input_names[0]

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

						__lowerCAmelCase:       str          =			feat_extract.pad(UpperCamelCase__     ,  padding="longest"     ,  return_tensors="np")[input_name]
						__lowerCAmelCase:       Dict          =			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 							lowercase_     (	self							:				Tuple)->   Union[str, Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Dict          =			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:       Any          =			BatchFeature({input_name: speech_inputs})

						__lowerCAmelCase:       Dict          =			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 							lowercase_     (	self							:				Optional[int])->   List[Any]:



						'''simple docstring'''


						__lowerCAmelCase:       Any          =			self.feat_extract_dict
						__lowerCAmelCase:       Any          =			True
						__lowerCAmelCase:       str          =			self.feature_extraction_class(**UpperCamelCase__)
						__lowerCAmelCase:       List[Any]          =			self.feat_extract_tester.prepare_inputs_for_common()
						__lowerCAmelCase:       Tuple          =			[len(UpperCamelCase__) for x in speech_inputs]
						__lowerCAmelCase:       Optional[Any]          =			feat_extract.model_input_names[0]

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

						__lowerCAmelCase:       Optional[Any]          =			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 							lowercase_     (	self							:				List[str])->   Any:



						'''simple docstring'''


						__lowerCAmelCase:       Any          =			self.feat_extract_dict
						__lowerCAmelCase:       str          =			True
						__lowerCAmelCase:       int          =			self.feature_extraction_class(**UpperCamelCase__)
						__lowerCAmelCase:       int          =			self.feat_extract_tester.prepare_inputs_for_common()
						__lowerCAmelCase:       str          =			[len(UpperCamelCase__) for x in speech_inputs]
						__lowerCAmelCase:       Any          =			feat_extract.model_input_names[0]

						__lowerCAmelCase:       Optional[int]          =			BatchFeature({input_name: speech_inputs})
						__lowerCAmelCase:       List[str]          =			min(UpperCamelCase__)

						__lowerCAmelCase:       List[str]          =			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])


