


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
  import torch

  from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin



class    UpperCAmelCase_	:
       '''simple docstring'''






       def __init__(     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE="resnet50" ,					__SCREAMING_SNAKE_CASE=3 ,					__SCREAMING_SNAKE_CASE=32 ,					__SCREAMING_SNAKE_CASE=3 ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE=True ,					):




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		parent
              UpperCamelCase    :	Optional[int]   	=		out_indices if out_indices is not None else [4]
              UpperCamelCase    :	List[str]   	=		stage_names
              UpperCamelCase    :	Tuple   	=		out_features
              UpperCamelCase    :	List[Any]   	=		backbone
              UpperCamelCase    :	Union[str, Any]   	=		batch_size
              UpperCamelCase    :	List[str]   	=		image_size
              UpperCamelCase    :	Dict   	=		num_channels
              UpperCamelCase    :	Union[str, Any]   	=		use_pretrained_backbone
              UpperCamelCase    :	Dict   	=		is_training






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)
              UpperCamelCase    :	Optional[int]   	=		self.get_config()

              return config, pixel_values






       def  _lowercase   (     self						):




              """simple docstring"""




              return TimmBackboneConfig(
                  image_size=self.image_size ,					num_channels=self.num_channels ,					out_features=self.out_features ,					out_indices=self.out_indices ,					stage_names=self.stage_names ,					use_pretrained_backbone=self.use_pretrained_backbone ,					backbone=self.backbone ,					)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	str   	=		TimmBackbone(config=__SCREAMING_SNAKE_CASE						)
              model.to(__SCREAMING_SNAKE_CASE						)
              model.eval()
              with torch.no_grad():
                     UpperCamelCase    :	Dict   	=		model(__SCREAMING_SNAKE_CASE						)
              self.parent.assertEqual(
                  result.feature_map[-1].shape ,					(self.batch_size, model.channels[-1], 14, 14) ,					)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Union[str, Any]   	=		self.prepare_config_and_inputs()
              UpperCamelCase	, UpperCamelCase    :	List[Any]   	=		config_and_inputs
              UpperCamelCase    :	str   	=		{'''pixel_values''': pixel_values}
              return config, inputs_dict




@require_torch
@require_timm
class    UpperCAmelCase_	(							snake_case_,     snake_case_,     snake_case_,     unittest.TestCase):
       '''simple docstring'''
       __UpperCamelCase      :     str							=					(TimmBackbone,) if is_torch_available() else ()
       __UpperCamelCase      :     int							=					{"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
       __UpperCamelCase      :     Optional[Any]							=					False
       __UpperCamelCase      :     str							=					False
       __UpperCamelCase      :     int							=					False
       __UpperCamelCase      :     str							=					False






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Dict   	=		TimmBackboneModelTester(self						)
              UpperCamelCase    :	Dict   	=		ConfigTester(self ,					config_class=__SCREAMING_SNAKE_CASE ,					has_text_modality=__SCREAMING_SNAKE_CASE						)






       def  _lowercase   (     self						):




              """simple docstring"""




              self.config_tester.create_and_test_config_to_json_string()
              self.config_tester.create_and_test_config_to_json_file()
              self.config_tester.create_and_test_config_from_and_save_pretrained()
              self.config_tester.create_and_test_config_with_num_labels()
              self.config_tester.check_config_can_be_init_without_params()
              self.config_tester.check_config_arguments_init()






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase    :	Dict   	=		'''resnet18'''
              UpperCamelCase    :	List[Any]   	=		'''microsoft/resnet-18'''

              UpperCamelCase    :	Union[str, Any]   	=		AutoBackbone.from_pretrained(__SCREAMING_SNAKE_CASE ,					use_timm_backbone=__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	Optional[Any]   	=		AutoBackbone.from_pretrained(__SCREAMING_SNAKE_CASE						)

              self.assertEqual(len(timm_model.out_features						) ,					len(transformers_model.out_features						)						)
              self.assertEqual(len(timm_model.stage_names						) ,					len(transformers_model.stage_names						)						)
              self.assertEqual(timm_model.channels ,					transformers_model.channels						)
              # Out indices are set to the last layer by default. For timm models, we don't know
              # the number of layers in advance, so we set it to (-1,), whereas for transformers
              # models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
              self.assertEqual(timm_model.out_indices ,					(-1,)						)
              self.assertEqual(transformers_model.out_indices ,					[len(timm_model.stage_names						) - 1]						)

              UpperCamelCase    :	List[Any]   	=		AutoBackbone.from_pretrained(__SCREAMING_SNAKE_CASE ,					use_timm_backbone=__SCREAMING_SNAKE_CASE ,					out_indices=[1, 2, 3]						)
              UpperCamelCase    :	Any   	=		AutoBackbone.from_pretrained(__SCREAMING_SNAKE_CASE ,					out_indices=[1, 2, 3]						)

              self.assertEqual(timm_model.out_indices ,					transformers_model.out_indices						)
              self.assertEqual(len(timm_model.out_features						) ,					len(transformers_model.out_features						)						)
              self.assertEqual(timm_model.channels ,					transformers_model.channels						)






       @unittest.skip('''TimmBackbone doesn\'t support feed forward chunking'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone doesn\'t have num_hidden_layers attribute'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone initialization is managed on the timm side'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone models doesn\'t have inputs_embeds'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone model cannot be created without specifying a backbone checkpoint'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''model weights aren\'t tied in TimmBackbone.'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''Only checkpoints on timm can be loaded into TimmBackbone'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone doesn\'t have hidden size info in its configuration.'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''TimmBackbone doesn\'t support output_attentions.'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''Safetensors is not supported by timm.'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       @unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''						)
       def  _lowercase   (     self						):




              """simple docstring"""




              pass






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase	, UpperCamelCase    :	List[str]   	=		self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     UpperCamelCase    :	Optional[Any]   	=		model_class(__SCREAMING_SNAKE_CASE						)
                     UpperCamelCase    :	Dict   	=		inspect.signature(model.forward						)
                     # signature.parameters is an OrderedDict => so arg_names order is deterministic
                     UpperCamelCase    :	Tuple   	=		[*signature.parameters.keys()]

                     UpperCamelCase    :	List[str]   	=		['''pixel_values''']
                     self.assertListEqual(arg_names[:1] ,					__SCREAMING_SNAKE_CASE						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase	, UpperCamelCase    :	Optional[Any]   	=		self.model_tester.prepare_config_and_inputs_for_common()
              UpperCamelCase    :	Tuple   	=		True
              UpperCamelCase    :	int   	=		self.has_attentions

              # no need to test all models as different heads yield the same functionality
              UpperCamelCase    :	Tuple   	=		self.all_model_classes[0]
              UpperCamelCase    :	int   	=		model_class(__SCREAMING_SNAKE_CASE						)
              model.to(__SCREAMING_SNAKE_CASE						)

              UpperCamelCase    :	List[Any]   	=		self._prepare_for_class(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	str   	=		model(**__SCREAMING_SNAKE_CASE						)
              UpperCamelCase    :	List[str]   	=		outputs[0][-1]

              # Encoder-/Decoder-only models
              UpperCamelCase    :	Optional[Any]   	=		outputs.hidden_states[0]
              hidden_states.retain_grad()

              if self.has_attentions:
                     UpperCamelCase    :	List[str]   	=		outputs.attentions[0]
                     attentions.retain_grad()

              output.flatten()[0].backward(retain_graph=__SCREAMING_SNAKE_CASE						)

              self.assertIsNotNone(hidden_states.grad						)

              if self.has_attentions:
                     self.assertIsNotNone(attentions.grad						)






       def  _lowercase   (     self						):




              """simple docstring"""




              UpperCamelCase	, UpperCamelCase    :	str   	=		self.model_tester.prepare_config_and_inputs_for_common()

              for model_class in self.all_model_classes:
                     UpperCamelCase    :	Tuple   	=		model_class(__SCREAMING_SNAKE_CASE						)
                     model.to(__SCREAMING_SNAKE_CASE						)
                     model.eval()
                     UpperCamelCase    :	Union[str, Any]   	=		model(**__SCREAMING_SNAKE_CASE						)

                     self.assertEqual(len(result.feature_maps						) ,					len(config.out_indices						)						)
                     self.assertEqual(len(model.channels						) ,					len(config.out_indices						)						)

                     # Check output of last stage is taken if out_features=None, out_indices=None
                     UpperCamelCase    :	Tuple   	=		copy.deepcopy(__SCREAMING_SNAKE_CASE						)
                     UpperCamelCase    :	Union[str, Any]   	=		None
                     UpperCamelCase    :	Dict   	=		model_class(__SCREAMING_SNAKE_CASE						)
                     model.to(__SCREAMING_SNAKE_CASE						)
                     model.eval()
                     UpperCamelCase    :	List[Any]   	=		model(**__SCREAMING_SNAKE_CASE						)

                     self.assertEqual(len(result.feature_maps						) ,					1						)
                     self.assertEqual(len(model.channels						) ,					1						)

                     # Check backbone can be initialized with fresh weights
                     UpperCamelCase    :	Dict   	=		copy.deepcopy(__SCREAMING_SNAKE_CASE						)
                     UpperCamelCase    :	List[Any]   	=		False
                     UpperCamelCase    :	Union[str, Any]   	=		model_class(__SCREAMING_SNAKE_CASE						)
                     model.to(__SCREAMING_SNAKE_CASE						)
                     model.eval()
                     UpperCamelCase    :	List[str]   	=		model(**__SCREAMING_SNAKE_CASE						)





import requests
from bsa import BeautifulSoup


def      a	(							SCREAMING_SNAKE_CASE_      :		str = "AAPL"       ):






       """simple docstring"""





       UpperCamelCase    :	Dict   	=		F"""https://in.finance.yahoo.com/quote/{symbol}?s={symbol}"""
       UpperCamelCase    :	Any   	=		BeautifulSoup(requests.get(SCREAMING_SNAKE_CASE_       ).text							,			'''html.parser'''       )
       UpperCamelCase    :	Dict   	=		'''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}''')

