






"""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        a     (   a_	):
    # to overwrite at feature extractactor specific tests
    UpperCAmelCase_ :     Optional[int]	     =None
    UpperCAmelCase_ :     List[Any]	     =None







    @property
    def 			UpperCamelCase_      (			self       ):
      return self.feat_extract_tester.prepare_feat_extract_dict()







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'feature_size'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'sampling_rate'       )       )
      self.assertTrue(hasattr(_lowerCamelCase							,		'padding_value'       )       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common()
      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )

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

      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase       )
      lowercase							    =       BatchFeature({input_name: speech_inputs}							,		tensor_type='np'       )

      lowercase							    =       processed_features[input_name]

      if len(batch_features_input.shape       ) < 3:
        lowercase							    =       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 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase       )
      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       feat_extract.model_input_names[0]

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

      lowercase							    =       processed_features[input_name]

      if len(batch_features_input.shape       ) < 3:
        lowercase							    =       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 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common(equal_length=_lowerCamelCase       )
      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}							,		tensor_type='tf'       )

      lowercase							    =       processed_features[input_name]

      if len(batch_features_input.shape       ) < 3:
        lowercase							    =       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 			UpperCamelCase_      (			self							,		_lowerCamelCase=False       ):
      def _inputs_have_equal_length(_lowerCamelCase       ):
        lowercase							    =       len(input[0]       )
        for input_slice in input[1:]:
          if len(_lowerCamelCase       ) != length:
            return False
        return True

      def _inputs_are_equal(_lowerCamelCase							,		_lowerCamelCase       ):
        if len(_lowerCamelCase       ) != len(_lowerCamelCase       ):
          return False

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

      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase       )
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )

      lowercase							    =       self.feat_extract_tester.seq_length_diff
      lowercase							    =       self.feat_extract_tester.max_seq_length + pad_diff
      lowercase							    =       self.feat_extract_tester.min_seq_length
      lowercase							    =       self.feat_extract_tester.batch_size
      lowercase							    =       self.feat_extract_tester.feature_size

      # test padding for List[int] + numpy
      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding=_lowerCamelCase       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='longest'       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[-1]       )       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='longest'							,		return_tensors='np'       )
      lowercase							    =       input_a[input_name]

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

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=_lowerCamelCase							,		return_tensors='np'       )
      lowercase							    =       input_a[input_name]

      self.assertFalse(_inputs_have_equal_length(_lowerCamelCase       )       )
      self.assertTrue(_inputs_have_equal_length(_lowerCamelCase       )       )
      self.assertTrue(_inputs_have_equal_length(_lowerCamelCase       )       )
      self.assertTrue(_inputs_are_equal(_lowerCamelCase							,		_lowerCamelCase       )       )
      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
      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		pad_to_multiple_of=1_0       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='longest'							,		pad_to_multiple_of=1_0       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		pad_to_multiple_of=1_0							,		max_length=_lowerCamelCase       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		pad_to_multiple_of=1_0							,		max_length=_lowerCamelCase							,		return_tensors='np'							,		)
      lowercase							    =       input_a[input_name]

      self.assertTrue(all(len(_lowerCamelCase       ) % 1_0 == 0 for x in input_a       )       )
      self.assertTrue(_inputs_are_equal(_lowerCamelCase							,		_lowerCamelCase       )       )

      lowercase							    =       pad_max_length if pad_max_length % 1_0 == 0 else (pad_max_length // 1_0 + 1) * 1_0
      self.assertTrue(all(len(_lowerCamelCase       ) == 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
      lowercase							    =       (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 			UpperCamelCase_      (			self							,		_lowerCamelCase=False       ):
      def _inputs_have_equal_length(_lowerCamelCase       ):
        lowercase							    =       len(input[0]       )
        for input_slice in input[1:]:
          if len(_lowerCamelCase       ) != length:
            return False
        return True

      def _inputs_are_equal(_lowerCamelCase							,		_lowerCamelCase       ):
        if len(_lowerCamelCase       ) != len(_lowerCamelCase       ):
          return False

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

      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common(numpify=_lowerCamelCase       )
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )

      # truncate to smallest
      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[0]       )							,		truncation=_lowerCamelCase       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[0]       )       )
      lowercase							    =       input_a[input_name]

      self.assertTrue(_inputs_have_equal_length(_lowerCamelCase       )       )
      self.assertFalse(_inputs_have_equal_length(_lowerCamelCase       )       )

      # truncate to smallest with np
      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[0]       )							,		return_tensors='np'							,		truncation=_lowerCamelCase							,		)
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[0]       )							,		return_tensors='np'       )
      lowercase							    =       input_a[input_name]

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

      # truncate to middle
      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[1]       )							,		truncation=_lowerCamelCase							,		return_tensors='np'							,		)
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[1]       )							,		truncation=_lowerCamelCase       )
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[1]       )							,		return_tensors='np'       )
      lowercase							    =       input_a[input_name]

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

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

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

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

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

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

      # test truncation for `pad_to_multiple_of` for List[int] + numpy
      lowercase							    =       1_2
      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[0]       )							,		pad_to_multiple_of=_lowerCamelCase							,		truncation=_lowerCamelCase							,		)
      lowercase							    =       input_a[input_name]

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=len(speech_inputs[0]       )							,		pad_to_multiple_of=_lowerCamelCase							,		)
      lowercase							    =       input_a[input_name]

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







    def 			UpperCamelCase_      (			self       ):
      self._check_padding(numpify=_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      self._check_padding(numpify=_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      self._check_truncation(numpify=_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      self._check_truncation(numpify=_lowerCamelCase       )







    @require_torch
    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common()
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='longest'							,		return_tensors='np'       )[input_name]
      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		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 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feature_extraction_class(**self.feat_extract_dict       )
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common()
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )

      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		padding='longest'							,		return_tensors='np'       )[input_name]
      lowercase							    =       feat_extract.pad(_lowerCamelCase							,		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 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feat_extract_dict
      lowercase							    =       True
      lowercase							    =       self.feature_extraction_class(**_lowerCamelCase       )
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common()
      lowercase							    =       [len(_lowerCamelCase       ) for x in speech_inputs]
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )

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







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.feat_extract_dict
      lowercase							    =       True
      lowercase							    =       self.feature_extraction_class(**_lowerCamelCase       )
      lowercase							    =       self.feat_extract_tester.prepare_inputs_for_common()
      lowercase							    =       [len(_lowerCamelCase       ) for x in speech_inputs]
      lowercase							    =       feat_extract.model_input_names[0]

      lowercase							    =       BatchFeature({input_name: speech_inputs}       )
      lowercase							    =       min(_lowerCamelCase       )

      lowercase							    =       feat_extract.pad(
          _lowerCamelCase							,		padding='max_length'							,		max_length=_lowerCamelCase							,		truncation=_lowerCamelCase							,		return_tensors='np'       )
      self.assertIn('attention_mask'							,		_lowerCamelCase       )
      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"""



import requests
from bsa import BeautifulSoup
def 						_SCREAMING_SNAKE_CASE (    __snake_case			:  str = "AAPL"    ):





  '''simple docstring'''





  lowercase							    =       f'https://in.finance.yahoo.com/quote/{symbol}?s={symbol}'
  lowercase							    =       BeautifulSoup(requests.get(__snake_case    ).text		,					'html.parser'    )
  lowercase							    =       '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}''')


