






"""simple docstring"""



import inspect
import unittest

from transformers import YolosConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
    import torch
    from torch import nn

    from transformers import YolosForObjectDetection, YolosModel
    from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class        a     :







    def __init__(			self							,		_lowerCamelCase							,		_lowerCamelCase=1_3							,		_lowerCamelCase=[3_0, 3_0]							,		_lowerCamelCase=2							,		_lowerCamelCase=3							,		_lowerCamelCase=True							,		_lowerCamelCase=True							,		_lowerCamelCase=3_2							,		_lowerCamelCase=5							,		_lowerCamelCase=4							,		_lowerCamelCase=3_7							,		_lowerCamelCase="gelu"							,		_lowerCamelCase=0.1							,		_lowerCamelCase=0.1							,		_lowerCamelCase=1_0							,		_lowerCamelCase=0.0_2							,		_lowerCamelCase=3							,		_lowerCamelCase=None							,		_lowerCamelCase=8							,		_lowerCamelCase=1_0							,		):
      lowercase							    =       parent
      lowercase							    =       batch_size
      lowercase							    =       image_size
      lowercase							    =       patch_size
      lowercase							    =       num_channels
      lowercase							    =       is_training
      lowercase							    =       use_labels
      lowercase							    =       hidden_size
      lowercase							    =       num_hidden_layers
      lowercase							    =       num_attention_heads
      lowercase							    =       intermediate_size
      lowercase							    =       hidden_act
      lowercase							    =       hidden_dropout_prob
      lowercase							    =       attention_probs_dropout_prob
      lowercase							    =       type_sequence_label_size
      lowercase							    =       initializer_range
      lowercase							    =       num_labels
      lowercase							    =       scope
      lowercase							    =       n_targets
      lowercase							    =       num_detection_tokens
      # we set the expected sequence length (which is used in several tests)
      # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
      lowercase							    =       (image_size[1] // patch_size) * (image_size[0] // patch_size)
      lowercase							    =       num_patches + 1 + self.num_detection_tokens







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]       )

      lowercase							    =       None
      if self.use_labels:
        # labels is a list of Dict (each Dict being the labels for a given example in the batch)
        lowercase							    =       []
        for i in range(self.batch_size       ):
          lowercase							    =       {}
          lowercase							    =       torch.randint(
              high=self.num_labels							,		size=(self.n_targets,)							,		device=_lowerCamelCase       )
          lowercase							    =       torch.rand(self.n_targets							,		4							,		device=_lowerCamelCase       )
          labels.append(_lowerCamelCase       )

      lowercase							    =       self.get_config()

      return config, pixel_values, labels







    def 			UpperCamelCase_      (			self       ):
      return YolosConfig(
          image_size=self.image_size							,		patch_size=self.patch_size							,		num_channels=self.num_channels							,		hidden_size=self.hidden_size							,		num_hidden_layers=self.num_hidden_layers							,		num_attention_heads=self.num_attention_heads							,		intermediate_size=self.intermediate_size							,		hidden_act=self.hidden_act							,		hidden_dropout_prob=self.hidden_dropout_prob							,		attention_probs_dropout_prob=self.attention_probs_dropout_prob							,		is_decoder=_lowerCamelCase							,		initializer_range=self.initializer_range							,		num_detection_tokens=self.num_detection_tokens							,		num_labels=self.num_labels							,		)







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       YolosModel(config=_lowerCamelCase       )
      model.to(_lowerCamelCase       )
      model.eval()
      lowercase							    =       model(_lowerCamelCase       )
      self.parent.assertEqual(
          result.last_hidden_state.shape							,		(self.batch_size, self.expected_seq_len, self.hidden_size)       )







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
      lowercase							    =       YolosForObjectDetection(_lowerCamelCase       )
      model.to(_lowerCamelCase       )
      model.eval()

      lowercase							    =       model(pixel_values=_lowerCamelCase       )
      lowercase							    =       model(_lowerCamelCase       )

      self.parent.assertEqual(result.logits.shape							,		(self.batch_size, self.num_detection_tokens, self.num_labels + 1)       )
      self.parent.assertEqual(result.pred_boxes.shape							,		(self.batch_size, self.num_detection_tokens, 4)       )

      lowercase							    =       model(pixel_values=_lowerCamelCase							,		labels=_lowerCamelCase       )

      self.parent.assertEqual(result.loss.shape							,		()       )
      self.parent.assertEqual(result.logits.shape							,		(self.batch_size, self.num_detection_tokens, self.num_labels + 1)       )
      self.parent.assertEqual(result.pred_boxes.shape							,		(self.batch_size, self.num_detection_tokens, 4)       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.prepare_config_and_inputs()
      lowercase    ,     lowercase    ,     lowercase							    =       config_and_inputs
      lowercase							    =       {'pixel_values': pixel_values}
      return config, inputs_dict


@require_torch
class        a     (   a_,				a_,				unittest.TestCase	):
    UpperCAmelCase_ :     Any	     =(YolosModel, YolosForObjectDetection) if is_torch_available() else ()
    UpperCAmelCase_ :     Dict	     =(
        {"feature-extraction": YolosModel, "object-detection": YolosForObjectDetection} if is_torch_available() else {}
    )

    UpperCAmelCase_ :     List[str]	     =False
    UpperCAmelCase_ :     str	     =False
    UpperCAmelCase_ :     Tuple	     =False
    UpperCAmelCase_ :     int	     =False







    def 			UpperCamelCase_      (			self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase=False       ):
      lowercase							    =       super()._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase							,		return_labels=_lowerCamelCase       )

      if return_labels:
        if model_class.__name__ == "YolosForObjectDetection":
          lowercase							    =       []
          for i in range(self.model_tester.batch_size       ):
            lowercase							    =       {}
            lowercase							    =       torch.ones(
                size=(self.model_tester.n_targets,)							,		device=_lowerCamelCase							,		dtype=torch.long       )
            lowercase							    =       torch.ones(
                self.model_tester.n_targets							,		4							,		device=_lowerCamelCase							,		dtype=torch.float       )
            labels.append(_lowerCamelCase       )
          lowercase							    =       labels

      return inputs_dict







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       YolosModelTester(self       )
      lowercase							    =       ConfigTester(self							,		config_class=_lowerCamelCase							,		has_text_modality=_lowerCamelCase							,		hidden_size=3_7       )







    def 			UpperCamelCase_      (			self       ):
      self.config_tester.run_common_tests()







    def 			UpperCamelCase_      (			self       ):
      # YOLOS does not use inputs_embeds
      pass







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase							    =       model_class(_lowerCamelCase       )
        self.assertIsInstance(model.get_input_embeddings()							,		(nn.Module)       )
        lowercase							    =       model.get_output_embeddings()
        self.assertTrue(x is None or isinstance(_lowerCamelCase							,		nn.Linear       )       )







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase							    =       model_class(_lowerCamelCase       )
        lowercase							    =       inspect.signature(model.forward       )
        # signature.parameters is an OrderedDict => so arg_names order is deterministic
        lowercase							    =       [*signature.parameters.keys()]

        lowercase							    =       ['pixel_values']
        self.assertListEqual(arg_names[:1]							,		_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()
      lowercase							    =       True

      # in YOLOS, the seq_len is different
      lowercase							    =       self.model_tester.expected_seq_len
      for model_class in self.all_model_classes:
        lowercase							    =       True
        lowercase							    =       False
        lowercase							    =       True
        lowercase							    =       model_class(_lowerCamelCase       )
        model.to(_lowerCamelCase       )
        model.eval()
        with torch.no_grad():
          lowercase							    =       model(**self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )       )
        lowercase							    =       outputs.attentions
        self.assertEqual(len(_lowerCamelCase       )							,		self.model_tester.num_hidden_layers       )

        # check that output_attentions also work using config
        del inputs_dict["output_attentions"]
        lowercase							    =       True
        lowercase							    =       model_class(_lowerCamelCase       )
        model.to(_lowerCamelCase       )
        model.eval()
        with torch.no_grad():
          lowercase							    =       model(**self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )       )
        lowercase							    =       outputs.attentions
        self.assertEqual(len(_lowerCamelCase       )							,		self.model_tester.num_hidden_layers       )

        self.assertListEqual(
            list(attentions[0].shape[-3:]       )							,		[self.model_tester.num_attention_heads, seq_len, seq_len]							,		)
        lowercase							    =       len(_lowerCamelCase       )

        # Check attention is always last and order is fine
        lowercase							    =       True
        lowercase							    =       True
        lowercase							    =       model_class(_lowerCamelCase       )
        model.to(_lowerCamelCase       )
        model.eval()
        with torch.no_grad():
          lowercase							    =       model(**self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )       )

        lowercase							    =       1
        self.assertEqual(out_len + added_hidden_states							,		len(_lowerCamelCase       )       )

        lowercase							    =       outputs.attentions

        self.assertEqual(len(_lowerCamelCase       )							,		self.model_tester.num_hidden_layers       )
        self.assertListEqual(
            list(self_attentions[0].shape[-3:]       )							,		[self.model_tester.num_attention_heads, seq_len, seq_len]							,		)







    def 			UpperCamelCase_      (			self       ):
      def check_hidden_states_output(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       ):
        lowercase							    =       model_class(_lowerCamelCase       )
        model.to(_lowerCamelCase       )
        model.eval()

        with torch.no_grad():
          lowercase							    =       model(**self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase       )       )

        lowercase							    =       outputs.hidden_states

        lowercase							    =       getattr(
            self.model_tester							,		'expected_num_hidden_layers'							,		self.model_tester.num_hidden_layers + 1       )
        self.assertEqual(len(_lowerCamelCase       )							,		_lowerCamelCase       )

        # YOLOS has a different seq_length
        lowercase							    =       self.model_tester.expected_seq_len

        self.assertListEqual(
            list(hidden_states[0].shape[-2:]       )							,		[seq_length, self.model_tester.hidden_size]							,		)

      lowercase    ,     lowercase							    =       self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        lowercase							    =       True
        check_hidden_states_output(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       )

        # check that output_hidden_states also work using config
        del inputs_dict["output_hidden_states"]
        lowercase							    =       True

        check_hidden_states_output(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase       )







    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_object_detection(*_lowerCamelCase       )







    @slow
    def 			UpperCamelCase_      (			self       ):
      for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowercase							    =       YolosModel.from_pretrained(_lowerCamelCase       )
        self.assertIsNotNone(_lowerCamelCase       )


def 						_SCREAMING_SNAKE_CASE (    ):





  '''simple docstring'''





  lowercase							    =       Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
  return image



@require_torch
@require_vision
class        a     (   unittest.TestCase	):







    @cached_property
    def 			UpperCamelCase_      (			self       ):
      return AutoImageProcessor.from_pretrained('hustvl/yolos-small'       ) if is_vision_available() else None







    @slow
    def 			UpperCamelCase_      (			self       ):
      lowercase							    =       YolosForObjectDetection.from_pretrained('hustvl/yolos-small'       ).to(_lowerCamelCase       )

      lowercase							    =       self.default_image_processor
      lowercase							    =       prepare_img()
      lowercase							    =       image_processor(images=_lowerCamelCase							,		return_tensors='pt'       ).to(_lowerCamelCase       )

      # forward pass
      with torch.no_grad():
        lowercase							    =       model(inputs.pixel_values       )

      # verify outputs
      lowercase							    =       torch.Size((1, 1_0_0, 9_2)       )
      self.assertEqual(outputs.logits.shape							,		_lowerCamelCase       )

      lowercase							    =       torch.tensor(
          [[-2_4.0_2_4_8, -1_0.3_0_2_4, -1_4.8_2_9_0], [-4_2.0_3_9_2, -1_6.8_2_0_0, -2_7.4_3_3_4], [-2_7.2_7_4_3, -1_1.8_1_5_4, -1_8.7_1_4_8]]							,		device=_lowerCamelCase							,		)
      lowercase							    =       torch.tensor(
          [[0.2_5_5_9, 0.5_4_5_5, 0.4_7_0_6], [0.2_9_8_9, 0.7_2_7_9, 0.1_8_7_5], [0.7_7_3_2, 0.4_0_1_7, 0.4_4_6_2]]							,		device=_lowerCamelCase       )
      self.assertTrue(torch.allclose(outputs.logits[0, :3, :3]							,		_lowerCamelCase							,		atol=1e-4       )       )
      self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3]							,		_lowerCamelCase							,		atol=1e-4       )       )

      # verify postprocessing
      lowercase							    =       image_processor.post_process_object_detection(
          _lowerCamelCase							,		threshold=0.3							,		target_sizes=[image.size[::-1]]       )[0]
      lowercase							    =       torch.tensor([0.9_9_9_4, 0.9_7_9_0, 0.9_9_6_4, 0.9_9_7_2, 0.9_8_6_1]       ).to(_lowerCamelCase       )
      lowercase							    =       [7_5, 7_5, 1_7, 6_3, 1_7]
      lowercase							    =       torch.tensor([3_3_5.0_6_0_9, 7_9.3_8_4_8, 3_7_5.4_2_1_6, 1_8_7.2_4_9_5]       ).to(_lowerCamelCase       )

      self.assertEqual(len(results['scores']       )							,		5       )
      self.assertTrue(torch.allclose(results['scores']							,		_lowerCamelCase							,		atol=1e-4       )       )
      self.assertSequenceEqual(results['labels'].tolist()							,		_lowerCamelCase       )
      self.assertTrue(torch.allclose(results['boxes'][0, :]							,		_lowerCamelCase       )       )










"""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}''')


