


import itertools
import os
import random
import tempfile
import unittest

import numpy as np
from datasets import load_dataset

from transformers import is_speech_available
from transformers.testing_utils import check_json_file_has_correct_format, require_torch, require_torchaudio
from transformers.utils.import_utils import is_torch_available

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
							from transformers import WhisperFeatureExtractor

if is_torch_available():
							import torch

a					  =     random.Random()


def 			UpperCAmelCase_				(      UpperCAmelCase__						,							UpperCAmelCase__=1.0						,							UpperCAmelCase__=None						,							UpperCAmelCase__=None  ):
					if rng is None:
										lowercase_  							=			global_rng

					lowercase_  							=			[]
					for batch_idx in range(shape[0]  ):
										values.append([]  )
										for _ in range(shape[1]  ):
															values[-1].append(rng.random() * scale  )

					return values







@require_torch
@require_torchaudio
class        UpperCamelCase__   (	unittest.TestCase   ):

					def __init__(     self       :   Dict							,					UpperCamelCase__       :   Union[str, Any]							,					UpperCamelCase__       :   Union[str, Any]=7							,					UpperCamelCase__       :   str=400							,					UpperCamelCase__       :   Union[str, Any]=2_000							,					UpperCamelCase__       :   Dict=10							,					UpperCamelCase__       :   Optional[Any]=160							,					UpperCamelCase__       :   Dict=8							,					UpperCamelCase__       :   Tuple=0.0							,					UpperCamelCase__       :   List[Any]=4_000							,					UpperCamelCase__       :   List[str]=False							,					UpperCamelCase__       :   List[Any]=True							,					):






										'''simple docstring'''






										lowercase_  							=			parent
										lowercase_  							=			batch_size
										lowercase_  							=			min_seq_length
										lowercase_  							=			max_seq_length
										lowercase_  							=			(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
										lowercase_  							=			padding_value
										lowercase_  							=			sampling_rate
										lowercase_  							=			return_attention_mask
										lowercase_  							=			do_normalize
										lowercase_  							=			feature_size
										lowercase_  							=			chunk_length
										lowercase_  							=			hop_length

					def   UpperCAmelCase__       (     self       :   str       ):






										'''simple docstring'''






										return {
										    "feature_size": self.feature_size,
										    "hop_length": self.hop_length,
										    "chunk_length": self.chunk_length,
										    "padding_value": self.padding_value,
										    "sampling_rate": self.sampling_rate,
										    "return_attention_mask": self.return_attention_mask,
										    "do_normalize": self.do_normalize,
										}







					def   UpperCAmelCase__       (     self       :   Optional[Any]							,					UpperCamelCase__       :   Any=False							,					UpperCamelCase__       :   Dict=False       ):






										'''simple docstring'''






										def _flatten(UpperCamelCase__       :   Optional[Any]       ):
															return list(itertools.chain(*UpperCamelCase__       )       )

										if equal_length:
															lowercase_  							=			[floats_list((self.max_seq_length, self.feature_size)       ) for _ in range(self.batch_size       )]
										else:
															# make sure that inputs increase in size
															lowercase_  							=			[
															    floats_list((x, self.feature_size)       )
															    for x in range(self.min_seq_length							,					self.max_seq_length							,					self.seq_length_diff       )
															]
										if numpify:
															lowercase_  							=			[np.asarray(UpperCamelCase__       ) for x in speech_inputs]
										return speech_inputs







@require_torch
@require_torchaudio
class        UpperCamelCase__   (	__magic_name__							,				unittest.TestCase   ):
					__SCREAMING_SNAKE_CASE       :  List[Any]						=   WhisperFeatureExtractor if is_speech_available() else None

					def   UpperCAmelCase__       (     self       :   Tuple       ):






										'''simple docstring'''






										lowercase_  							=			WhisperFeatureExtractionTester(self       )

					def   UpperCAmelCase__       (     self       :   Dict       ):






										'''simple docstring'''






										lowercase_  							=			self.feature_extraction_class(**self.feat_extract_dict       )

										with tempfile.TemporaryDirectory() as tmpdirname:
															lowercase_  							=			feat_extract_first.save_pretrained(UpperCamelCase__       )[0]
															check_json_file_has_correct_format(UpperCamelCase__       )
															lowercase_  							=			self.feature_extraction_class.from_pretrained(UpperCamelCase__       )

										lowercase_  							=			feat_extract_first.to_dict()
										lowercase_  							=			feat_extract_second.to_dict()
										lowercase_  							=			feat_extract_first.mel_filters
										lowercase_  							=			feat_extract_second.mel_filters
										self.assertTrue(np.allclose(UpperCamelCase__							,					UpperCamelCase__       )       )
										self.assertEqual(UpperCamelCase__							,					UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										lowercase_  							=			self.feature_extraction_class(**self.feat_extract_dict       )

										with tempfile.TemporaryDirectory() as tmpdirname:
															lowercase_  							=			os.path.join(UpperCamelCase__							,					"""feat_extract.json"""       )
															feat_extract_first.to_json_file(UpperCamelCase__       )
															lowercase_  							=			self.feature_extraction_class.from_json_file(UpperCamelCase__       )

										lowercase_  							=			feat_extract_first.to_dict()
										lowercase_  							=			feat_extract_second.to_dict()
										lowercase_  							=			feat_extract_first.mel_filters
										lowercase_  							=			feat_extract_second.mel_filters
										self.assertTrue(np.allclose(UpperCamelCase__							,					UpperCamelCase__       )       )
										self.assertEqual(UpperCamelCase__							,					UpperCamelCase__       )

					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
										# create three inputs of length 800, 1000, and 1200
										lowercase_  							=			[floats_list((1, x)       )[0] for x in range(800							,					1_400							,					200       )]
										lowercase_  							=			[np.asarray(UpperCamelCase__       ) for speech_input in speech_inputs]

										# Test feature size
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					padding="""max_length"""							,					return_tensors="""np"""       ).input_features
										self.assertTrue(input_features.ndim == 3       )
										self.assertTrue(input_features.shape[-1] == feature_extractor.nb_max_frames       )
										self.assertTrue(input_features.shape[-2] == feature_extractor.feature_size       )

										# Test not batched input
										lowercase_  							=			feature_extractor(speech_inputs[0]							,					return_tensors="""np"""       ).input_features
										lowercase_  							=			feature_extractor(np_speech_inputs[0]							,					return_tensors="""np"""       ).input_features
										self.assertTrue(np.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-3       )       )

										# Test batched
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""np"""       ).input_features
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""np"""       ).input_features
										for enc_seq_a, enc_seq_a in zip(UpperCamelCase__							,					UpperCamelCase__       ):
															self.assertTrue(np.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-3       )       )

										# Test 2-D numpy arrays are batched.
										lowercase_  							=			[floats_list((1, x)       )[0] for x in (800, 800, 800)]
										lowercase_  							=			np.asarray(UpperCamelCase__       )
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""np"""       ).input_features
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""np"""       ).input_features
										for enc_seq_a, enc_seq_a in zip(UpperCamelCase__							,					UpperCamelCase__       ):
															self.assertTrue(np.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-3       )       )

										# Test truncation required
										lowercase_  							=			[floats_list((1, x)       )[0] for x in range(200							,					(feature_extractor.n_samples + 500)							,					200       )]
										lowercase_  							=			[np.asarray(UpperCamelCase__       ) for speech_input in speech_inputs]

										lowercase_  							=			[x[: feature_extractor.n_samples] for x in speech_inputs]
										lowercase_  							=			[np.asarray(UpperCamelCase__       ) for speech_input in speech_inputs_truncated]

										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""np"""       ).input_features
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""np"""       ).input_features
										for enc_seq_a, enc_seq_a in zip(UpperCamelCase__							,					UpperCamelCase__       ):
															self.assertTrue(np.allclose(UpperCamelCase__							,					UpperCamelCase__							,					atol=1e-3       )       )

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										import torch

										lowercase_  							=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
										lowercase_  							=			np.random.rand(100							,					32       ).astype(np.floataa       )
										lowercase_  							=			np_speech_inputs.tolist()

										for inputs in [py_speech_inputs, np_speech_inputs]:
															lowercase_  							=			feature_extractor.pad([{"""input_features""": inputs}]							,					return_tensors="""np"""       )
															self.assertTrue(np_processed.input_features.dtype == np.floataa       )
															lowercase_  							=			feature_extractor.pad([{"""input_features""": inputs}]							,					return_tensors="""pt"""       )
															self.assertTrue(pt_processed.input_features.dtype == torch.floataa       )

					def   UpperCAmelCase__       (     self       :   Dict							,					UpperCamelCase__       :   Any       ):






										'''simple docstring'''






										lowercase_  							=			load_dataset("""hf-internal-testing/librispeech_asr_dummy"""							,					"""clean"""							,					split="""validation"""       )
										# automatic decoding with librispeech
										lowercase_  							=			ds.sort("""id"""       ).select(range(UpperCamelCase__       )       )[:num_samples]["""audio"""]

										return [x["array"] for x in speech_samples]

					def   UpperCAmelCase__       (     self       :   List[str]       ):






										'''simple docstring'''






										lowercase_  							=			torch.tensor(
										    [
										        0.1_193, -0.0_946, -0.1_098, -0.0_196, 0.0_225, -0.0_690, -0.1_736, 0.0_951,
										        0.0_971, -0.0_817, -0.0_702, 0.0_162, 0.0_260, 0.0_017, -0.0_192, -0.1_678,
										        0.0_709, -0.1_867, -0.0_655, -0.0_274, -0.0_234, -0.1_884, -0.0_516, -0.0_554,
										        -0.0_274, -0.1_425, -0.1_423, 0.0_837, 0.0_377, -0.0_854
										    ]       )
										# fmt: on

										lowercase_  							=			self._load_datasamples(1       )
										lowercase_  							=			WhisperFeatureExtractor()
										lowercase_  							=			feature_extractor(UpperCamelCase__							,					return_tensors="""pt"""       ).input_features
										self.assertEqual(input_features.shape							,					(1, 80, 3_000)       )
										self.assertTrue(torch.allclose(input_features[0, 0, :30]							,					UpperCamelCase__							,					atol=1e-4       )       )







					def   UpperCAmelCase__       (     self       :   Optional[Any]       ):






										'''simple docstring'''






										lowercase_  							=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()       )
										lowercase_  							=			self._load_datasamples(1       )[0]
										lowercase_  							=			((audio - audio.min()) / (audio.max() - audio.min())) * 65_535  # Rescale to [0, 65535] to show issue
										lowercase_  							=			feat_extract.zero_mean_unit_var_norm([audio]							,					attention_mask=UpperCamelCase__       )[0]

										self.assertTrue(np.all(np.mean(UpperCamelCase__       ) < 1e-3       )       )
										self.assertTrue(np.all(np.abs(np.var(UpperCamelCase__       ) - 1       ) < 1e-3       )       )






import PIL.Image
import PIL.ImageOps
from packaging import version
from PIL import Image


if version.parse(version.parse(PIL.__version__).base_version) >= version.parse('9.1.0'):
							a					  =     {
							    'linear': PIL.Image.Resampling.BILINEAR,
							    'bilinear': PIL.Image.Resampling.BILINEAR,
							    'bicubic': PIL.Image.Resampling.BICUBIC,
							    'lanczos': PIL.Image.Resampling.LANCZOS,
							    'nearest': PIL.Image.Resampling.NEAREST,
							}
else:
							a					  =     {
							    'linear': PIL.Image.LINEAR,
							    'bilinear': PIL.Image.BILINEAR,
							    'bicubic': PIL.Image.BICUBIC,
							    'lanczos': PIL.Image.LANCZOS,
							    'nearest': PIL.Image.NEAREST,
							}


def 			UpperCAmelCase_				(      UpperCAmelCase__  ):
					lowercase_  							=			(images / 2 + 0.5).clamp(0						,							1  )
					lowercase_  							=			images.cpu().permute(0						,							2						,							3						,							1  ).float().numpy()
					lowercase_  							=			numpy_to_pil(UpperCAmelCase__  )
					return images



def 			UpperCAmelCase_				(      UpperCAmelCase__  ):
					if images.ndim == 3:
										lowercase_  							=			images[None, ...]
					lowercase_  							=			(images * 2_5_5).round().astype("""uint8"""  )
					if images.shape[-1] == 1:
										# special case for grayscale (single channel) images
										lowercase_  							=			[Image.fromarray(image.squeeze()						,							mode="""L"""  ) for image in images]
					else:
										lowercase_  							=			[Image.fromarray(UpperCAmelCase__  ) for image in images]

					return pil_images


