


"""simple docstring"""







import copy
from typing import Any, Dict, List, Optional, Union

import numpy as np

from ...audio_utils import mel_filter_bank, spectrogram, window_function
from ...feature_extraction_sequence_utils import SequenceFeatureExtractor
from ...feature_extraction_utils import BatchFeature
from ...utils import TensorType, logging


__lowercase    					=      logging.get_logger(__name__)






class 						_A  (  _a  ):







    """simple docstring"""




    UpperCAmelCase       :							Optional[int]	=       ["""input_features"""]






    def __init__(					self				:    Tuple				, __UpperCAmelCase				:    List[Any]=80				, __UpperCAmelCase				:    Tuple=16000				, __UpperCAmelCase				:    Optional[Any]=160				, __UpperCAmelCase				:    Optional[int]=30				, __UpperCAmelCase				:    Any=400				, __UpperCAmelCase				:    List[Any]=0.0				, __UpperCAmelCase				:    Tuple=False				, **__UpperCAmelCase				:    Dict				, ):
      super().__init__(
          feature_size=__UpperCAmelCase				, sampling_rate=__UpperCAmelCase				, padding_value=__UpperCAmelCase				, return_attention_mask=__UpperCAmelCase				, **__UpperCAmelCase				, )
      a						:		Optional[int]      							=			n_fft
      a						:		Union[str, Any]      							=			hop_length
      a						:		Optional[int]      							=			chunk_length
      a						:		str      							=			chunk_length * sampling_rate
      a						:		List[str]      							=			self.n_samples // hop_length
      a						:		Dict      							=			sampling_rate
      a						:		List[str]      							=			mel_filter_bank(
          num_frequency_bins=1 + n_fft // 2				, num_mel_filters=__UpperCAmelCase				, min_frequency=0.0				, max_frequency=8_000.0				, sampling_rate=__UpperCAmelCase				, norm="slaney"				, mel_scale="slaney"				, )






    def 	__snake_case							(					self				:    int				, __UpperCAmelCase				:    np.array):
      a						:		List[str]      							=			spectrogram(
          __UpperCAmelCase				, window_function(self.n_fft				, "hann")				, frame_length=self.n_fft				, hop_length=self.hop_length				, power=2.0				, mel_filters=self.mel_filters				, log_mel="log10"				, )
      a						:		Union[str, Any]      							=			log_spec[:, :-1]
      a						:		List[str]      							=			np.maximum(__UpperCAmelCase				, log_spec.max() - 8.0)
      a						:		Dict      							=			(log_spec + 4.0) / 4.0
      return log_spec






    @staticmethod
    # Copied from transformers.models.wav2vec2.feature_extraction_wav2vec2.Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm
    def 	__snake_case							(					__UpperCAmelCase				:    List[np.ndarray]				, __UpperCAmelCase				:    List[np.ndarray]				, __UpperCAmelCase				:    float = 0.0):
      if attention_mask is not None:
        a						:		str      							=			np.array(__UpperCAmelCase				, np.intaa)
        a						:		Dict      							=			[]

        for vector, length in zip(__UpperCAmelCase				, attention_mask.sum(-1)):
          a						:		Any      							=			(vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7)
          if length < normed_slice.shape[0]:
            a						:		Any      							=			padding_value

          normed_input_values.append(__UpperCAmelCase)
      else:
        a						:		List[str]      							=			[(x - x.mean()) / np.sqrt(x.var() + 1e-7) for x in input_values]

      return normed_input_values






    def __call__(					self				:    List[Any]				, __UpperCAmelCase				:    Union[np.ndarray, List[float], List[np.ndarray], List[List[float]]]				, __UpperCAmelCase				:    bool = True				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[Union[str, TensorType]] = None				, __UpperCAmelCase				:    Optional[bool] = None				, __UpperCAmelCase				:    Optional[str] = "max_length"				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[int] = None				, __UpperCAmelCase				:    Optional[bool] = None				, **__UpperCAmelCase				:    Tuple				, ):

      if sampling_rate is not None:
        if sampling_rate != self.sampling_rate:
          raise ValueError(
              f'''The model corresponding to this feature extractor: {self.__class__.__name__} was trained using a'''
              f''' sampling rate of {self.sampling_rate}. Please make sure that the provided `raw_speech` input'''
              f''' was sampled with {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.")

      a						:		Tuple      							=			isinstance(__UpperCAmelCase				, np.ndarray) and len(raw_speech.shape) > 1
      if is_batched_numpy and len(raw_speech.shape) > 2:
        raise ValueError(f'''Only mono-channel audio is supported for input to {self}''')
      a						:		str      							=			is_batched_numpy or (
          isinstance(__UpperCAmelCase				, (list, tuple)) and (isinstance(raw_speech[0]				, (np.ndarray, tuple, list)))
      )

      if is_batched:
        a						:		Optional[int]      							=			[np.asarray([speech]				, dtype=np.floataa).T for speech in raw_speech]
      elif not is_batched and not isinstance(__UpperCAmelCase				, np.ndarray):
        a						:		str      							=			np.asarray(__UpperCAmelCase				, dtype=np.floataa)
      elif isinstance(__UpperCAmelCase				, np.ndarray) and raw_speech.dtype is np.dtype(np.floataa):
        a						:		Union[str, Any]      							=			raw_speech.astype(np.floataa)

      # always return batch
      if not is_batched:
        a						:		Union[str, Any]      							=			[np.asarray([raw_speech]).T]

      a						:		Any      							=			BatchFeature({"input_features": raw_speech})

      # convert into correct format for padding

      a						:		List[str]      							=			self.pad(
          __UpperCAmelCase				, padding=__UpperCAmelCase				, max_length=max_length if max_length else self.n_samples				, truncation=__UpperCAmelCase				, pad_to_multiple_of=__UpperCAmelCase				, return_attention_mask=return_attention_mask or do_normalize				, )

      # zero-mean and unit-variance normalization
      if do_normalize:
        a						:		int      							=			self.zero_mean_unit_var_norm(
            padded_inputs["input_features"]				, attention_mask=padded_inputs["attention_mask"]				, padding_value=self.padding_value				, )
        a						:		int      							=			np.stack(padded_inputs["input_features"]				, axis=0)

      # make sure list is in array format
      a						:		Optional[Any]      							=			padded_inputs.get("input_features").transpose(2				, 0				, 1)

      a						:		Optional[int]      							=			[self._np_extract_fbank_features(__UpperCAmelCase) for waveform in input_features[0]]

      if isinstance(input_features[0]				, __UpperCAmelCase):
        a						:		Union[str, Any]      							=			[np.asarray(__UpperCAmelCase				, dtype=np.floataa) for feature in input_features]
      else:
        a						:		Union[str, Any]      							=			input_features

      if return_attention_mask:
        # rescale from sample (48000) to feature (3000)
        a						:		Union[str, Any]      							=			padded_inputs["attention_mask"][:, :: self.hop_length]

      if return_tensors is not None:
        a						:		int      							=			padded_inputs.convert_to_tensors(__UpperCAmelCase)

      return padded_inputs






    def 	__snake_case							(					self				:    List[Any]):
      a						:		Tuple      							=			copy.deepcopy(self.__dict__)
      a						:		Optional[int]      							=			self.__class__.__name__
      if "mel_filters" in output:
        del output["mel_filters"]
      return output









def 		_lowercase (     lowercase__						):
      if not all(x.isalpha() for x in string						):
            raise ValueError('''String must only contain alphabetic characters.'''						)

      __lowerCAmelCase					:						int					=					sorted(string.lower()						)
      return len(lowercase__						) == len(set(lowercase__						)						)


if __name__ == "__main__":
 _UpperCamelCase 			=		input("Enter a string ").strip()

 _UpperCamelCase 			=		is_isogram(input_str)
 print(F"{input_str} is {'an' if isogram else 'not an'} isogram.")


