




import itertools
import random
import unittest

import numpy as np

from transformers import is_speech_available
from transformers.testing_utils import require_torch, require_torchaudio

from ...test_sequence_feature_extraction_common import SequenceFeatureExtractionTestMixin


if is_speech_available():
					from transformers import SpeechaTextFeatureExtractor

UpperCamelCase__         =      random.Random()







def      _a				(						SCREAMING_SNAKE_CASE_							:    Dict				,				SCREAMING_SNAKE_CASE_							:    List[str]=1.0				,				SCREAMING_SNAKE_CASE_							:    int=None				,				SCREAMING_SNAKE_CASE_							:    List[str]=None					):
					if rng is None:
										__lowerCAmelCase           =	global_rng

					__lowerCAmelCase           =	[]
					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       a__   ( unittest.TestCase				):






						def __init__(       self		,      _A		,      _A=7		,      _A=4_0_0		,      _A=2_0_0_0		,      _A=2_4		,      _A=2_4		,      _A=0.0		,      _A=1_6_0_0_0		,      _A=True		,      _A=True		,      ):




											"""simple docstring"""



											__lowerCAmelCase           =	parent
											__lowerCAmelCase           =	batch_size
											__lowerCAmelCase           =	min_seq_length
											__lowerCAmelCase           =	max_seq_length
											__lowerCAmelCase           =	(self.max_seq_length - self.min_seq_length) // (self.batch_size - 1)
											__lowerCAmelCase           =	feature_size
											__lowerCAmelCase           =	num_mel_bins
											__lowerCAmelCase           =	padding_value
											__lowerCAmelCase           =	sampling_rate
											__lowerCAmelCase           =	return_attention_mask
											__lowerCAmelCase           =	do_normalize






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



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






						def     __SCREAMING_SNAKE_CASE(       self		,      _A=False		,      _A=False      ):




											"""simple docstring"""



											def _flatten(_A      ):
																return list(itertools.chain(*_A      )      )

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






@require_torch
@require_torchaudio
class       a__   ( snake_case__			,    unittest.TestCase				):
						_a							:   int =   SpeechaTextFeatureExtractor if is_speech_available() else None






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	SpeechaTextFeatureExtractionTester(self      )






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											self.assertTrue(np.all(np.mean(_A		,      axis=0      ) < 1E-3      )      )
											self.assertTrue(np.all(np.abs(np.var(_A		,      axis=0      ) - 1      ) < 1E-3      )      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											# create three inputs of length 800, 1000, and 1200
											__lowerCAmelCase           =	[floats_list((1, x)      )[0] for x in range(8_0_0		,      1_4_0_0		,      2_0_0      )]
											__lowerCAmelCase           =	[np.asarray(_A      ) for speech_input in speech_inputs]

											# Test feature size
											__lowerCAmelCase           =	feature_extractor(_A		,      padding=_A		,      return_tensors="np"      ).input_features
											self.assertTrue(input_features.ndim == 3      )
											self.assertTrue(input_features.shape[-1] == feature_extractor.feature_size      )

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

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

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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											__lowerCAmelCase           =	[floats_list((1, x)      )[0] for x in range(8_0_0		,      1_4_0_0		,      2_0_0      )]

											__lowerCAmelCase           =	["longest", "max_length", "do_not_pad"]
											__lowerCAmelCase           =	[None, 1_6, None]
											for max_length, padding in zip(_A		,      _A      ):
																__lowerCAmelCase           =	feature_extractor(
																    _A		,      padding=_A		,      max_length=_A		,      return_attention_mask=_A      )
																__lowerCAmelCase           =	inputs.input_features
																__lowerCAmelCase           =	inputs.attention_mask
																__lowerCAmelCase           =	[np.sum(_A      ) for x in attention_mask]

																self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]      )
																self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]      )
																self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											__lowerCAmelCase           =	[floats_list((1, x)      )[0] for x in range(8_0_0		,      1_4_0_0		,      2_0_0      )]

											__lowerCAmelCase           =	["longest", "max_length", "do_not_pad"]
											__lowerCAmelCase           =	[None, 1_6, None]
											for max_length, padding in zip(_A		,      _A      ):
																__lowerCAmelCase           =	feature_extractor(
																    _A		,      max_length=_A		,      padding=_A		,      return_tensors="np"		,      return_attention_mask=_A      )
																__lowerCAmelCase           =	inputs.input_features
																__lowerCAmelCase           =	inputs.attention_mask
																__lowerCAmelCase           =	[np.sum(_A      ) for x in attention_mask]

																self._check_zero_mean_unit_variance(input_features[0][: fbank_feat_lengths[0]]      )
																self.assertTrue(input_features[0][fbank_feat_lengths[0] :].sum() < 1E-6      )
																self._check_zero_mean_unit_variance(input_features[1][: fbank_feat_lengths[1]]      )
																self.assertTrue(input_features[0][fbank_feat_lengths[1] :].sum() < 1E-6      )
																self._check_zero_mean_unit_variance(input_features[2][: fbank_feat_lengths[2]]      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											__lowerCAmelCase           =	[floats_list((1, x)      )[0] for x in range(8_0_0		,      1_4_0_0		,      2_0_0      )]
											__lowerCAmelCase           =	feature_extractor(
											    _A		,      padding="max_length"		,      max_length=4		,      truncation=_A		,      return_tensors="np"		,      return_attention_mask=_A		,      )
											__lowerCAmelCase           =	inputs.input_features
											__lowerCAmelCase           =	inputs.attention_mask
											__lowerCAmelCase           =	np.sum(attention_mask == 1		,      axis=1      )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]      )
											self._check_zero_mean_unit_variance(input_features[1]      )
											self._check_zero_mean_unit_variance(input_features[2]      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											__lowerCAmelCase           =	[floats_list((1, x)      )[0] for x in range(8_0_0		,      1_4_0_0		,      2_0_0      )]
											__lowerCAmelCase           =	feature_extractor(
											    _A		,      padding="longest"		,      max_length=4		,      truncation=_A		,      return_tensors="np"		,      return_attention_mask=_A		,      )
											__lowerCAmelCase           =	inputs.input_features
											__lowerCAmelCase           =	inputs.attention_mask
											__lowerCAmelCase           =	np.sum(attention_mask == 1		,      axis=1      )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]      )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]      )
											self._check_zero_mean_unit_variance(input_features[2]      )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape		,      (3, 4, 2_4)      )

											__lowerCAmelCase           =	[floats_list((1, x)      )[0] for x in range(8_0_0		,      1_4_0_0		,      2_0_0      )]
											__lowerCAmelCase           =	feature_extractor(
											    _A		,      padding="longest"		,      max_length=1_6		,      truncation=_A		,      return_tensors="np"		,      return_attention_mask=_A		,      )
											__lowerCAmelCase           =	inputs.input_features
											__lowerCAmelCase           =	inputs.attention_mask
											__lowerCAmelCase           =	np.sum(attention_mask == 1		,      axis=1      )

											self._check_zero_mean_unit_variance(input_features[0, : fbank_feat_lengths[0]]      )
											self._check_zero_mean_unit_variance(input_features[1, : fbank_feat_lengths[1]]      )
											self._check_zero_mean_unit_variance(input_features[2]      )

											# make sure that if max_length < longest -> then pad to max_length
											self.assertEqual(input_features.shape		,      (3, 6, 2_4)      )






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											import torch

											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											__lowerCAmelCase           =	np.random.rand(1_0_0		,      3_2      ).astype(np.floataa      )
											__lowerCAmelCase           =	np_speech_inputs.tolist()

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






						def     __SCREAMING_SNAKE_CASE(       self		,      _A      ):




											"""simple docstring"""



											from datasets import load_dataset

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

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






						def     __SCREAMING_SNAKE_CASE(       self      ):




											"""simple docstring"""



											__lowerCAmelCase           =	np.array([
											    -1.57_45, -1.77_13, -1.70_20, -1.60_69, -1.22_50, -1.11_05, -0.90_72, -0.82_41,
											    -1.23_10, -0.80_98, -0.33_20, -0.41_01, -0.79_85, -0.49_96, -0.82_13, -0.91_28,
											    -1.04_20, -1.12_86, -1.04_40, -0.79_99, -0.84_05, -1.22_75, -1.54_43, -1.46_25,
											]      )
											# fmt: on

											__lowerCAmelCase           =	self._load_datasamples(1      )
											__lowerCAmelCase           =	self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()      )
											__lowerCAmelCase           =	feature_extractor(_A		,      return_tensors="pt"      ).input_features
											self.assertEquals(input_features.shape		,      (1, 5_8_4, 2_4)      )
											self.assertTrue(np.allclose(input_features[0, 0, :3_0]		,      _A		,      atol=1E-4      )      )










import math







def      _a				(						SCREAMING_SNAKE_CASE_							:    int					):

					if 1 < number < 4:
										# 2 and 3 are primes
										return True
					elif number < 2 or number % 2 == 0 or number % 3 == 0:
										# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
										return False

					# All primes number are in format of 6k +/- 1
					for i in range(5				,				int(math.sqrt(SCREAMING_SNAKE_CASE_					) + 1					)				,				6					):
										if number % i == 0 or number % (i + 2) == 0:
															return False
					return True







def      _a				(						SCREAMING_SNAKE_CASE_							:    int = 1_00_01					):

					try:
										__lowerCAmelCase           =	int(SCREAMING_SNAKE_CASE_					)
					except (TypeError, ValueError):
										raise TypeError("Parameter nth must be int or castable to int."					) from None
					if nth <= 0:
										raise ValueError("Parameter nth must be greater than or equal to one."					)
					__lowerCAmelCase           =	[]
					__lowerCAmelCase           =	2
					while len(SCREAMING_SNAKE_CASE_					) < nth:
										if is_prime(SCREAMING_SNAKE_CASE_					):
															primes.append(SCREAMING_SNAKE_CASE_					)
															num += 1
										else:
															num += 1
					return primes[len(SCREAMING_SNAKE_CASE_					) - 1]


if __name__ == "__main__":
					print(f'''{solution() = }''')




