


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

lowerCAmelCase           =		random.Random()







def        _lowerCamelCase(	lowercase__   , lowercase__=1.0   , lowercase__=None   , lowercase__=None	)						->	List[Any]:

		'''simple docstring'''







		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       A    (   unittest.TestCase ):


							def __init__(self      ,				lowerCAmelCase      ,				lowerCAmelCase=7      ,				lowerCAmelCase=4_0_0      ,				lowerCAmelCase=2_0_0_0      ,				lowerCAmelCase=2_4      ,				lowerCAmelCase=2_4      ,				lowerCAmelCase=0.0      ,				lowerCAmelCase=1_6_0_0_0      ,				lowerCAmelCase=True      ,				lowerCAmelCase=True      ,				):
									__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=			feature_size
									__lowercase=			num_mel_bins
									__lowercase=			padding_value
									__lowercase=			sampling_rate
									__lowercase=			return_attention_mask
									__lowercase=			do_normalize


							def 			_A       (self					):
									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 			_A       (self      ,				lowerCAmelCase=False      ,				lowerCAmelCase=False					):
									def _flatten(lowerCAmelCase					):
											return list(itertools.chain(*lowerCAmelCase					)					)

									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(lowerCAmelCase					) for x in speech_inputs]
									return speech_inputs





@require_torch
@require_torchaudio
class       A    (   A_					,				unittest.TestCase ):
							UpperCamelCase_   :							Any       =SpeechaTextFeatureExtractor if is_speech_available() else None


							def 			_A       (self					):
									__lowercase=			SpeechaTextFeatureExtractionTester(self					)


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


							def 			_A       (self					):
									# Tests that all call wrap to encode_plus and batch_encode_plus
									__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(8_0_0      ,				1_4_0_0      ,				2_0_0					)]
									__lowercase=			[np.asarray(lowerCAmelCase					) for speech_input in speech_inputs]

									# Test feature size
									__lowercase=			feature_extractor(lowerCAmelCase      ,				padding=lowerCAmelCase      ,				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
									__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(lowerCAmelCase      ,				lowerCAmelCase      ,				atol=1E-3					)					)

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

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


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

									__lowercase=			['longest', 'max_length', 'do_not_pad']
									__lowercase=			[None, 1_6, None]
									for max_length, padding in zip(lowerCAmelCase      ,				lowerCAmelCase					):
											__lowercase=			feature_extractor(
											    lowerCAmelCase      ,				padding=lowerCAmelCase      ,				max_length=lowerCAmelCase      ,				return_attention_mask=lowerCAmelCase					)
											__lowercase=			inputs.input_features
											__lowercase=			inputs.attention_mask
											__lowercase=			[np.sum(lowerCAmelCase					) 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 			_A       (self					):
									__lowercase=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
									__lowercase=			[floats_list((1, x)					)[0] for x in range(8_0_0      ,				1_4_0_0      ,				2_0_0					)]

									__lowercase=			['longest', 'max_length', 'do_not_pad']
									__lowercase=			[None, 1_6, None]
									for max_length, padding in zip(lowerCAmelCase      ,				lowerCAmelCase					):
											__lowercase=			feature_extractor(
											    lowerCAmelCase      ,				max_length=lowerCAmelCase      ,				padding=lowerCAmelCase      ,				return_tensors='np'      ,				return_attention_mask=lowerCAmelCase					)
											__lowercase=			inputs.input_features
											__lowercase=			inputs.attention_mask
											__lowercase=			[np.sum(lowerCAmelCase					) 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 			_A       (self					):
									__lowercase=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
									__lowercase=			[floats_list((1, x)					)[0] for x in range(8_0_0      ,				1_4_0_0      ,				2_0_0					)]
									__lowercase=			feature_extractor(
									    lowerCAmelCase      ,				padding='max_length'      ,				max_length=4      ,				truncation=lowerCAmelCase      ,				return_tensors='np'      ,				return_attention_mask=lowerCAmelCase      ,				)
									__lowercase=			inputs.input_features
									__lowercase=			inputs.attention_mask
									__lowercase=			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 			_A       (self					):
									__lowercase=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
									__lowercase=			[floats_list((1, x)					)[0] for x in range(8_0_0      ,				1_4_0_0      ,				2_0_0					)]
									__lowercase=			feature_extractor(
									    lowerCAmelCase      ,				padding='longest'      ,				max_length=4      ,				truncation=lowerCAmelCase      ,				return_tensors='np'      ,				return_attention_mask=lowerCAmelCase      ,				)
									__lowercase=			inputs.input_features
									__lowercase=			inputs.attention_mask
									__lowercase=			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)					)

									__lowercase=			[floats_list((1, x)					)[0] for x in range(8_0_0      ,				1_4_0_0      ,				2_0_0					)]
									__lowercase=			feature_extractor(
									    lowerCAmelCase      ,				padding='longest'      ,				max_length=1_6      ,				truncation=lowerCAmelCase      ,				return_tensors='np'      ,				return_attention_mask=lowerCAmelCase      ,				)
									__lowercase=			inputs.input_features
									__lowercase=			inputs.attention_mask
									__lowercase=			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 			_A       (self					):
									import torch

									__lowercase=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
									__lowercase=			np.random.rand(1_0_0      ,				3_2					).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 			_A       (self      ,				lowerCAmelCase					):
									from datasets import load_dataset

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

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







							def 			_A       (self					):
									# fmt: off
									__lowercase=			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

									__lowercase=			self._load_datasamples(1					)
									__lowercase=			self.feature_extraction_class(**self.feat_extract_tester.prepare_feat_extract_dict()					)
									__lowercase=			feature_extractor(lowerCAmelCase      ,				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]      ,				lowerCAmelCase      ,				atol=1E-4					)					)










from __future__ import annotations







def        _lowerCamelCase(	lowercase__   , lowercase__	)						->	bool:

		'''simple docstring'''







		__lowercase=			get_failure_array(lowercase__	)

		# 2) Step through text searching for pattern
		__lowercase,							__lowercase=			0, 0  # index into text, pattern
		while i < len(lowercase__	):
				if pattern[j] == text[i]:
						if j == (len(lowercase__	) - 1):
								return True
						j += 1

				# if this is a prefix in our pattern
				# just go back far enough to continue
				elif j > 0:
						__lowercase=			failure[j - 1]
						continue
				i += 1
		return False







def        _lowerCamelCase(	lowercase__	)						->	list[int]:

		'''simple docstring'''







		__lowercase=			[0]
		__lowercase=			0
		__lowercase=			1
		while j < len(lowercase__	):
				if pattern[i] == pattern[j]:
						i += 1
				elif i > 0:
						__lowercase=			failure[i - 1]
						continue
				j += 1
				failure.append(lowercase__	)
		return failure


if __name__ == "__main__":
	# Test 1)
	lowerCAmelCase           =		'''abc1abc12'''
	lowerCAmelCase           =		'''alskfjaldsabc1abc1abc12k23adsfabcabc'''
	lowerCAmelCase           =		'''alskfjaldsk23adsfabcabc'''
	assert kmp(pattern, texta) and not kmp(pattern, texta)

	# Test 2)
	lowerCAmelCase           =		'''ABABX'''
	lowerCAmelCase           =		'''ABABZABABYABABX'''
	assert kmp(pattern, text)

	# Test 3)
	lowerCAmelCase           =		'''AAAB'''
	lowerCAmelCase           =		'''ABAAAAAB'''
	assert kmp(pattern, text)

	# Test 4)
	lowerCAmelCase           =		'''abcdabcy'''
	lowerCAmelCase           =		'''abcxabcdabxabcdabcdabcy'''
	assert kmp(pattern, text)

	# Test 5)
	lowerCAmelCase           =		'''aabaabaaa'''
	assert get_failure_array(pattern) == [0, 1, 0, 1, 2, 3, 4, 5, 2]






