





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


_lowerCAmelCase								=  logging.get_logger(__name__)

class  _UpperCAmelCase				(		_SCREAMING_SNAKE_CASE  ):
      a    							=				['''input_features''']
      def __init__(		self   ,							a__=80   ,							a__=16000   ,							a__=160   ,							a__=30   ,							a__=400   ,							a__=0.0   ,							a__=False   ,							**a__   ,							):
         super().__init__(
             feature_size=a__   ,							sampling_rate=a__   ,							padding_value=a__   ,							return_attention_mask=a__   ,							**a__   ,							)
         A_  :					Tuple         =						n_fft
         A_  :					Any         =						hop_length
         A_  :					Tuple         =						chunk_length
         A_  :					Union[str, Any]         =						chunk_length * sampling_rate
         A_  :					Union[str, Any]         =						self.n_samples // hop_length
         A_  :					int         =						sampling_rate
         A_  :					Optional[int]         =						mel_filter_bank(
             num_frequency_bins=1 + n_fft // 2   ,							num_mel_filters=a__   ,							min_frequency=0.0   ,							max_frequency=8000.0   ,							sampling_rate=a__   ,							norm="""slaney"""   ,							mel_scale="""slaney"""   ,							)
      def 		_lowerCamelCase   (		self   ,							a__							):
         A_  :					str         =						spectrogram(
             a__   ,							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_  :					Optional[int]         =						log_spec[:, :-1]
         A_  :					int         =						np.maximum(a__   ,							log_spec.max() - 8.0							)
         A_  :					Tuple         =						(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 		_lowerCamelCase   (		a__   ,							a__   ,							a__ = 0.0							):
         if attention_mask is not None:
            A_  :					Tuple         =						np.array(a__   ,							np.intaa							)
            A_  :					List[Any]         =						[]

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

               normed_input_values.append(a__							)
         else:
            A_  :					int         =						[(x - x.mean()) / np.sqrt(x.var() + 1E-7							) for x in input_values]

         return normed_input_values
      def __call__(		self   ,							a__   ,							a__ = True   ,							a__ = None   ,							a__ = None   ,							a__ = None   ,							a__ = "max_length"   ,							a__ = None   ,							a__ = None   ,							a__ = None   ,							**a__   ,							):

         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_  :					Optional[Any]         =						isinstance(a__   ,							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_  :					Tuple         =						is_batched_numpy or (
             isinstance(a__   ,							(list, tuple)							) and (isinstance(raw_speech[0]   ,							(np.ndarray, tuple, list)							))
         )

         if is_batched:
            A_  :					Tuple         =						[np.asarray([speech]   ,							dtype=np.floataa							).T for speech in raw_speech]
         elif not is_batched and not isinstance(a__   ,							np.ndarray							):
            A_  :					Any         =						np.asarray(a__   ,							dtype=np.floataa							)
         elif isinstance(a__   ,							np.ndarray							) and raw_speech.dtype is np.dtype(np.floataa							):
            A_  :					Optional[Any]         =						raw_speech.astype(np.floataa							)

         # always return batch
         if not is_batched:
            A_  :					int         =						[np.asarray([raw_speech]							).T]

         A_  :					List[Any]         =						BatchFeature({"""input_features""": raw_speech}							)

         # convert into correct format for padding

         A_  :					Tuple         =						self.pad(
             a__   ,							padding=a__   ,							max_length=max_length if max_length else self.n_samples   ,							truncation=a__   ,							pad_to_multiple_of=a__   ,							return_attention_mask=return_attention_mask or do_normalize   ,							)

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

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

         A_  :					Any         =						[self._np_extract_fbank_features(a__							) for waveform in input_features[0]]

         if isinstance(input_features[0]   ,							a__							):
            A_  :					List[str]         =						[np.asarray(a__   ,							dtype=np.floataa							) for feature in input_features]
         else:
            A_  :					Optional[int]         =						input_features

         if return_attention_mask:
            # rescale from sample (48000) to feature (3000)
            A_  :					int         =						padded_inputs["""attention_mask"""][:, :: self.hop_length]

         if return_tensors is not None:
            A_  :					Tuple         =						padded_inputs.convert_to_tensors(a__							)

         return padded_inputs






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










'''simple docstring'''






import requests
from bsa import BeautifulSoup







def 							UpperCamelCase_     (       A__   :  str = "AAPL"   ):
  '''simple docstring'''





  lowerCAmelCase_     : Dict     =  f'https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'
  lowerCAmelCase_     : Optional[Any]     =  BeautifulSoup(requests.get(A__   ).text				,       """html.parser"""   )
  lowerCAmelCase_     : Union[str, Any]     =  """My(6px) Pos(r) smartphone_Mt(6px)"""
  return soup.find("""div"""				,       class_=class_   ).find("""span"""   ).text


if __name__ == "__main__":
  for symbol in "AAPL AMZN IBM GOOG MSFT ORCL".split():
    print(F'''Current {symbol:<4} stock price is {stock_price(symbol):>8}''')



