






'''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__      (					UpperCamelCase):
					# to overwrite at feature extractactor specific tests
					a_        =					None
					a_        =					None




					@property
					def 		A      (  self  :		str      )    ->							Dict:
								return self.feat_extract_tester.prepare_feat_extract_dict()




					def 		A      (  self  :		Optional[Any]      )    ->							int:
								UpperCAmelCase_      :       Optional[int]          =       self.feature_extraction_class(**self.feat_extract_dict      )
								self.assertTrue(hasattr(_A				, '''feature_size'''      )      )
								self.assertTrue(hasattr(_A				, '''sampling_rate'''      )      )
								self.assertTrue(hasattr(_A				, '''padding_value'''      )      )




					def 		A      (  self  :		List[str]      )    ->							Dict:
								UpperCAmelCase_      :       Union[str, Any]          =       self.feat_extract_tester.prepare_inputs_for_common()
								UpperCAmelCase_      :       Optional[int]          =       self.feature_extraction_class(**self.feat_extract_dict      )
								UpperCAmelCase_      :       Optional[Any]          =       feat_extract.model_input_names[0]

								UpperCAmelCase_      :       int          =       BatchFeature({input_name: speech_inputs}      )

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

								UpperCAmelCase_      :       str          =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=_A      )
								UpperCAmelCase_      :       Optional[Any]          =       BatchFeature({input_name: speech_inputs}				, tensor_type='''np'''      )

								UpperCAmelCase_      :       str          =       processed_features[input_name]

								if len(batch_features_input.shape      ) < 3:
											UpperCAmelCase_      :       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 		A      (  self  :		List[str]      )    ->							List[Any]:
								UpperCAmelCase_      :       Dict          =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=_A      )
								UpperCAmelCase_      :       List[str]          =       self.feature_extraction_class(**self.feat_extract_dict      )
								UpperCAmelCase_      :       Optional[int]          =       feat_extract.model_input_names[0]

								UpperCAmelCase_      :       Tuple          =       BatchFeature({input_name: speech_inputs}				, tensor_type='''pt'''      )

								UpperCAmelCase_      :       str          =       processed_features[input_name]

								if len(batch_features_input.shape      ) < 3:
											UpperCAmelCase_      :       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 		A      (  self  :		Optional[int]      )    ->							Optional[Any]:
								UpperCAmelCase_      :       str          =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=_A      )
								UpperCAmelCase_      :       Optional[Any]          =       self.feature_extraction_class(**self.feat_extract_dict      )
								UpperCAmelCase_      :       Union[str, Any]          =       feat_extract.model_input_names[0]

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

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

								if len(batch_features_input.shape      ) < 3:
											UpperCAmelCase_      :       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)      )




					def 		A      (  self  :		List[Any]				, _A  :		List[Any]=False      )    ->							Optional[int]:
								def _inputs_have_equal_length(_A  :		Any      ):
											UpperCAmelCase_      :       Dict          =       len(input[0]      )
											for input_slice in input[1:]:
														if len(_A      ) != length:
																	return False
											return True

								def _inputs_are_equal(_A  :		str				, _A  :		Union[str, Any]      ):
											if len(_A      ) != len(_A      ):
														return False

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

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

								UpperCAmelCase_      :       Union[str, Any]          =       BatchFeature({input_name: speech_inputs}      )

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

								# test padding for List[int] + numpy
								UpperCAmelCase_      :       Any          =       feat_extract.pad(_A				, padding=_A      )
								UpperCAmelCase_      :       List[Any]          =       input_a[input_name]

								UpperCAmelCase_      :       int          =       feat_extract.pad(_A				, padding='''longest'''      )
								UpperCAmelCase_      :       Optional[int]          =       input_a[input_name]

								UpperCAmelCase_      :       str          =       feat_extract.pad(_A				, padding='''max_length'''				, max_length=len(speech_inputs[-1]      )      )
								UpperCAmelCase_      :       int          =       input_a[input_name]

								UpperCAmelCase_      :       List[Any]          =       feat_extract.pad(_A				, padding='''longest'''				, return_tensors='''np'''      )
								UpperCAmelCase_      :       Dict          =       input_a[input_name]

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

								UpperCAmelCase_      :       Any          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=_A				, return_tensors='''np'''      )
								UpperCAmelCase_      :       List[Any]          =       input_a[input_name]

								self.assertFalse(_inputs_have_equal_length(_A      )      )
								self.assertTrue(_inputs_have_equal_length(_A      )      )
								self.assertTrue(_inputs_have_equal_length(_A      )      )
								self.assertTrue(_inputs_are_equal(_A				, _A      )      )
								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
								UpperCAmelCase_      :       List[Any]          =       feat_extract.pad(_A				, pad_to_multiple_of=10      )
								UpperCAmelCase_      :       Tuple          =       input_a[input_name]

								UpperCAmelCase_      :       Tuple          =       feat_extract.pad(_A				, padding='''longest'''				, pad_to_multiple_of=10      )
								UpperCAmelCase_      :       Union[str, Any]          =       input_a[input_name]

								UpperCAmelCase_      :       Any          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, pad_to_multiple_of=10				, max_length=_A      )
								UpperCAmelCase_      :       Dict          =       input_a[input_name]

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

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

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

								def _inputs_are_equal(_A  :		str				, _A  :		Dict      ):
											if len(_A      ) != len(_A      ):
														return False

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

								UpperCAmelCase_      :       Dict          =       self.feature_extraction_class(**self.feat_extract_dict      )
								UpperCAmelCase_      :       Union[str, Any]          =       self.feat_extract_tester.prepare_inputs_for_common(numpify=_A      )
								UpperCAmelCase_      :       List[str]          =       feat_extract.model_input_names[0]

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

								# truncate to smallest
								UpperCAmelCase_      :       List[str]          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=len(speech_inputs[0]      )				, truncation=_A      )
								UpperCAmelCase_      :       str          =       input_a[input_name]

								UpperCAmelCase_      :       Optional[Any]          =       feat_extract.pad(_A				, padding='''max_length'''				, max_length=len(speech_inputs[0]      )      )
								UpperCAmelCase_      :       Tuple          =       input_a[input_name]

								self.assertTrue(_inputs_have_equal_length(_A      )      )
								self.assertFalse(_inputs_have_equal_length(_A      )      )

								# truncate to smallest with np
								UpperCAmelCase_      :       str          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=len(speech_inputs[0]      )				, return_tensors='''np'''				, truncation=_A				, )
								UpperCAmelCase_      :       Tuple          =       input_a[input_name]

								UpperCAmelCase_      :       List[Any]          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=len(speech_inputs[0]      )				, return_tensors='''np'''      )
								UpperCAmelCase_      :       Union[str, Any]          =       input_a[input_name]

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

								# truncate to middle
								UpperCAmelCase_      :       Any          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=len(speech_inputs[1]      )				, truncation=_A				, return_tensors='''np'''				, )
								UpperCAmelCase_      :       Optional[Any]          =       input_a[input_name]

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

								UpperCAmelCase_      :       List[Any]          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=len(speech_inputs[1]      )				, return_tensors='''np'''      )
								UpperCAmelCase_      :       Dict          =       input_a[input_name]

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

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

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

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

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

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

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

								UpperCAmelCase_      :       str          =       feat_extract.pad(
								    _A				, padding='''max_length'''				, max_length=len(speech_inputs[0]      )				, pad_to_multiple_of=_A				, )
								UpperCAmelCase_      :       Optional[Any]          =       input_a[input_name]

								# retrieve expected_length as multiple of pad_to_multiple_of
								UpperCAmelCase_      :       Tuple          =       len(speech_inputs[0]      )
								if expected_length % pad_to_multiple_of != 0:
											UpperCAmelCase_      :       Tuple          =       ((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(_A      )      )
								self.assertFalse(_inputs_have_equal_length(_A      )      )




					def 		A      (  self  :		Tuple      )    ->							Union[str, Any]:
								self._check_padding(numpify=_A      )




					def 		A      (  self  :		Union[str, Any]      )    ->							Tuple:
								self._check_padding(numpify=_A      )




					def 		A      (  self  :		Tuple      )    ->							Any:
								self._check_truncation(numpify=_A      )




					def 		A      (  self  :		Union[str, Any]      )    ->							int:
								self._check_truncation(numpify=_A      )




					@require_torch
					def 		A      (  self  :		Optional[Any]      )    ->							Tuple:
								UpperCAmelCase_      :       List[Any]          =       self.feature_extraction_class(**self.feat_extract_dict      )
								UpperCAmelCase_      :       Tuple          =       self.feat_extract_tester.prepare_inputs_for_common()
								UpperCAmelCase_      :       Optional[Any]          =       feat_extract.model_input_names[0]

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

								UpperCAmelCase_      :       Dict          =       feat_extract.pad(_A				, padding='''longest'''				, return_tensors='''np'''      )[input_name]
								UpperCAmelCase_      :       List[Any]          =       feat_extract.pad(_A				, 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  :		Dict      )    ->							Dict:
								UpperCAmelCase_      :       Any          =       self.feature_extraction_class(**self.feat_extract_dict      )
								UpperCAmelCase_      :       Optional[Any]          =       self.feat_extract_tester.prepare_inputs_for_common()
								UpperCAmelCase_      :       Any          =       feat_extract.model_input_names[0]

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

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

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

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





					def 		A      (  self  :		Optional[Any]      )    ->							Tuple:
								UpperCAmelCase_      :       Union[str, Any]          =       self.feat_extract_dict
								UpperCAmelCase_      :       Dict          =       True
								UpperCAmelCase_      :       str          =       self.feature_extraction_class(**_A      )
								UpperCAmelCase_      :       Dict          =       self.feat_extract_tester.prepare_inputs_for_common()
								UpperCAmelCase_      :       List[str]          =       [len(_A      ) for x in speech_inputs]
								UpperCAmelCase_      :       List[str]          =       feat_extract.model_input_names[0]

								UpperCAmelCase_      :       Optional[int]          =       BatchFeature({input_name: speech_inputs}      )
								UpperCAmelCase_      :       Any          =       min(_A      )

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










'''simple docstring'''





_UpperCamelCase						:						List[str]  =					[sum(int(c, 10) ** 2 for c in i.__str__()) for i in range(100_000)]
def __UpperCAmelCase   (					A					:			int		)    ->   int:
			UpperCAmelCase_      :       str          =       0
			while number:
						# Increased Speed Slightly by checking every 5 digits together.
						sum_of_digits_squared += DIGITS_SQUARED[number % 1_0_0_0_0_0]
						number //= 1_0_0_0_0_0

			return sum_of_digits_squared


# There are 2 Chains made,
# One ends with 89 with the chain member 58 being the one which when declared first,
# there will be the least number of iterations for all the members to be checked.

# The other one ends with 1 and has only one element 1.

# So 58 and 1 are chosen to be declared at the starting.

# Changed dictionary to an array to quicken the solution
_UpperCamelCase						:						list[bool | None]  =					[None] * 10_000_000
_UpperCamelCase						:						List[str]  =					True
_UpperCamelCase						:						Tuple  =					False
def __UpperCAmelCase   (					A					:			int		)    ->   bool:

			if CHAINS[number - 1] is not None:
						return CHAINS[number - 1]  # type: ignore

			UpperCAmelCase_      :       Dict          =       chain(next_number(A		)		)
			UpperCAmelCase_      :       int          =       number_chain

			while number < 1_0_0_0_0_0_0_0:
						UpperCAmelCase_      :       Optional[Any]          =       number_chain
						number *= 1_0

			return number_chain
def __UpperCAmelCase   (					A					:			int = 1_0_0_0_0_0_0_0		)    ->   int:
			for i in range(1			,       A		):
						if CHAINS[i] is None:
									chain(i + 1		)

			return CHAINS[:number].count(A		)


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						print(f'''{solution() = }''')


