



from typing import List, Optional, Union

import numpy as np

from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import PaddingStrategy, TensorType, logging


UpperCAmelCase__     = logging.get_logger(__name__)







class     __lowerCAmelCase					(    A		):
			UpperCamelCase           =  ['''input_values''', '''padding_mask''']



			def __init__(		self     :						Any				,	A     :						int = 1				,	A     :						int = 2_40_00				,	A     :						float = 0.0				,	A     :						float = None				,	A     :						float = None				,	**A     :						Dict				,	)     ->					Dict:



						"""simple docstring"""






						super().__init__(feature_size=A				,	sampling_rate=A				,	padding_value=A				,	**A)
						_UpperCAmelCase	 =     chunk_length_s
						_UpperCAmelCase	 =     overlap



			@property
			def 					_lowerCamelCase (		self     :						int)     ->					Optional[int]:



						"""simple docstring"""






						if self.chunk_length_s is None:
									return None
						else:
									return int(self.chunk_length_s * self.sampling_rate)



			@property
			def 					_lowerCamelCase (		self     :						Optional[int])     ->					Optional[int]:



						"""simple docstring"""






						if self.chunk_length_s is None or self.overlap is None:
									return None
						else:
									return max(1				,	int((1.0 - self.overlap) * self.chunk_length))



			def __call__(		self     :						Tuple				,	A     :						Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				,	A     :						Optional[Union[bool, str, PaddingStrategy]] = None				,	A     :						Optional[bool] = False				,	A     :						Optional[int] = None				,	A     :						Optional[Union[str, TensorType]] = None				,	A     :						Optional[int] = None				,	)     ->					BatchFeature:



						"""simple docstring"""






						if sampling_rate is not None:
									if sampling_rate != self.sampling_rate:
												raise ValueError(
												    F"The model corresponding to this feature extractor: {self} was trained using a sampling rate of"
												    F" {self.sampling_rate}. Please make sure that the provided audio input was sampled with"
												    F" {self.sampling_rate} and not {sampling_rate}.")
						else:
									logger.warning(
									    'It is strongly recommended to pass the `sampling_rate` argument to this function. '
									    'Failing to do so can result in silent errors that might be hard to debug.')

						if padding and truncation:
									raise ValueError('Both padding and truncation were set. Make sure you only set one.')
						elif padding is None:
									# by default let's pad the inputs
									_UpperCAmelCase	 =     True

						_UpperCAmelCase	 =     bool(
						    isinstance(A				,	(list, tuple)) and (isinstance(raw_audio[0]				,	(np.ndarray, tuple, list))))

						if is_batched:
									_UpperCAmelCase	 =     [np.asarray(A				,	dtype=np.floataa).T for audio in raw_audio]
						elif not is_batched and not isinstance(A				,	np.ndarray):
									_UpperCAmelCase	 =     np.asarray(A				,	dtype=np.floataa)
						elif isinstance(A				,	np.ndarray) and raw_audio.dtype is np.dtype(np.floataa):
									_UpperCAmelCase	 =     raw_audio.astype(np.floataa)

						# always return batch
						if not is_batched:
									_UpperCAmelCase	 =     [np.asarray(A).T]

						# verify inputs are valid
						for idx, example in enumerate(A):
									if example.ndim > 2:
												raise ValueError(F"Expected input shape (channels, length) but got shape {example.shape}")
									if self.feature_size == 1 and example.ndim != 1:
												raise ValueError(F"Expected mono audio but example has {example.shape[-1]} channels")
									if self.feature_size == 2 and example.shape[-1] != 2:
												raise ValueError(F"Expected stereo audio but example has {example.shape[-1]} channels")

						_UpperCAmelCase	 =     None
						_UpperCAmelCase	 =     BatchFeature({'input_values': raw_audio})
						if self.chunk_stride is not None and self.chunk_length is not None and max_length is None:
									if truncation:
												_UpperCAmelCase	 =     min(array.shape[0] for array in raw_audio)
												_UpperCAmelCase	 =     int(np.floor(max_length / self.chunk_stride))
												_UpperCAmelCase	 =     (nb_step - 1) * self.chunk_stride + self.chunk_length
									elif padding:
												_UpperCAmelCase	 =     max(array.shape[0] for array in raw_audio)
												_UpperCAmelCase	 =     int(np.ceil(max_length / self.chunk_stride))
												_UpperCAmelCase	 =     (nb_step - 1) * self.chunk_stride + self.chunk_length
												_UpperCAmelCase	 =     'max_length'
									else:
												_UpperCAmelCase	 =     input_values

        # normal padding on batch
						if padded_inputs is None:
									_UpperCAmelCase	 =     self.pad(
									    A				,	max_length=A				,	truncation=A				,	padding=A				,	return_attention_mask=A				,	)
									if padding:
												_UpperCAmelCase	 =     padded_inputs.pop('attention_mask')

						_UpperCAmelCase	 =     []
						for example in padded_inputs.pop('input_values'):
									if self.feature_size == 1:
												_UpperCAmelCase	 =     example[..., None]
									input_values.append(example.T)

						_UpperCAmelCase	 =     input_values
						if return_tensors is not None:
									_UpperCAmelCase	 =     padded_inputs.convert_to_tensors(A)

						return padded_inputs





from collections import Counter
from timeit import timeit





def 							A			(  _UpperCAmelCase       :     str = ""							,     )       ->				bool:







			'''simple docstring'''
			return sum(c % 2 for c in Counter(input_str.replace(' '							,     ''					).lower()					).values()					) < 2





def 							A			(  _UpperCAmelCase       :     str = ""					)       ->				bool:







			'''simple docstring'''
			if len(_UpperCAmelCase					) == 0:
						return True
			_UpperCAmelCase	 =     input_str.replace(' '							,     ''					).lower()
			# character_freq_dict: Stores the frequency of every character in the input string
			_UpperCAmelCase	 =     {}

			for character in lower_case_input_str:
						_UpperCAmelCase	 =     character_freq_dict.get(_UpperCAmelCase							,     0					) + 1
			_UpperCAmelCase	 =     0

			for character_count in character_freq_dict.values():
						if character_count % 2:
									odd_char += 1
			if odd_char > 1:
						return False
			return True





def 							A			(  _UpperCAmelCase       :     str = ""					)       ->				None:







			'''simple docstring'''
			print('\nFor string = '							,     _UpperCAmelCase							,     ':'					)
			print(
			    '> can_string_be_rearranged_as_palindrome_counter()'							,     '\tans ='							,     can_string_be_rearranged_as_palindrome_counter(_UpperCAmelCase					)							,     '\ttime ='							,     timeit(
			        'z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'							,     setup='import __main__ as z'							,     )							,     'seconds'							,     )
			print(
			    '> can_string_be_rearranged_as_palindrome()'							,     '\tans ='							,     can_string_be_rearranged_as_palindrome(_UpperCAmelCase					)							,     '\ttime ='							,     timeit(
			        'z.can_string_be_rearranged_as_palindrome(z.check_str)'							,     setup='import __main__ as z'							,     )							,     'seconds'							,     )


if __name__ == "__main__":
							UpperCAmelCase__     = input(
							    "Enter string to determine if it can be rearranged as a palindrome or not: "
							).strip()
							benchmark(check_str)
							UpperCAmelCase__     = can_string_be_rearranged_as_palindrome_counter(check_str)
							print(f"""{check_str} can {"" if status else "not "}be rearranged as a palindrome""")
