
"""simple docstring"""
import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)






class      _UpperCAmelCase				(					unittest.TestCase):
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   ["a", "b", "c"]

      # Defaults to last layer if both are None
      _snake_case			,					_snake_case     :						Optional[Any]						=   get_aligned_output_features_output_indices(lowerCAmelCase_						,    lowerCAmelCase_						,    lowerCAmelCase_     )
      self.assertEqual(lowerCAmelCase_						,    ["c"]     )
      self.assertEqual(lowerCAmelCase_						,    [2]     )

      # Out indices set to match out features
      _snake_case			,					_snake_case     :						Dict						=   get_aligned_output_features_output_indices(["a", "c"]						,    lowerCAmelCase_						,    lowerCAmelCase_     )
      self.assertEqual(lowerCAmelCase_						,    ["a", "c"]     )
      self.assertEqual(lowerCAmelCase_						,    [0, 2]     )

      # Out features set to match out indices
      _snake_case			,					_snake_case     :						int						=   get_aligned_output_features_output_indices(lowerCAmelCase_						,    [0, 2]						,    lowerCAmelCase_     )
      self.assertEqual(lowerCAmelCase_						,    ["a", "c"]     )
      self.assertEqual(lowerCAmelCase_						,    [0, 2]     )

      # Out features selected from negative indices
      _snake_case			,					_snake_case     :						int						=   get_aligned_output_features_output_indices(lowerCAmelCase_						,    [-3, -1]						,    lowerCAmelCase_     )
      self.assertEqual(lowerCAmelCase_						,    ["a", "c"]     )
      self.assertEqual(lowerCAmelCase_						,    [-3, -1]     )
    def 					lowerCamelCase__	(    self     ):







      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(["a", "b"]						,    (0, 1)						,    lowerCAmelCase_     )

      # Out features must be a list
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(("a", "b")						,    (0, 1)						,    ["a", "b"]     )

      # Out features must be a subset of stage names
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(["a", "b"]						,    (0, 1)						,    ["a"]     )

      # Out indices must be a list or tuple
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(lowerCAmelCase_						,    0						,    ["a", "b"]     )

      # Out indices must be a subset of stage names
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(lowerCAmelCase_						,    (0, 1)						,    ["a"]     )

      # Out features and out indices must be the same length
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(["a", "b"]						,    (0,)						,    ["a", "b", "c"]     )

      # Out features should match out indices
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(["a", "b"]						,    (0, 2)						,    ["a", "b", "c"]     )

      # Out features and out indices should be in order
      with self.assertRaises(lowerCAmelCase_     ):
        verify_out_features_out_indices(["b", "a"]						,    (0, 1)						,    ["a", "b"]     )

      # Check passes with valid inputs
      verify_out_features_out_indices(["a", "b", "d"]						,    (0, 1, -1)						,    ["a", "b", "c", "d"]     )


    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   BackboneMixin()

      _snake_case     :						Optional[Any]						=   ["a", "b", "c"]
      _snake_case     :						Optional[Any]						=   ["a", "c"]
      _snake_case     :						Union[str, Any]						=   [0, 2]

      # Check that the output features and indices are set correctly
      self.assertEqual(backbone.out_features						,    ["a", "c"]     )
      self.assertEqual(backbone.out_indices						,    [0, 2]     )

      # Check out features and indices are updated correctly
      _snake_case     :						List[str]						=   ["a", "b"]
      self.assertEqual(backbone.out_features						,    ["a", "b"]     )
      self.assertEqual(backbone.out_indices						,    [0, 1]     )

      _snake_case     :						List[Any]						=   [-3, -1]
      self.assertEqual(backbone.out_features						,    ["a", "c"]     )
      self.assertEqual(backbone.out_indices						,    [-3, -1]     )








"""simple docstring"""
from datetime import datetime

import requests
from bsa import BeautifulSoup

if __name__ == "__main__":
    _a      :			Dict					=							input("""Enter image url: """).strip()
    print(f'Downloading image from {url} ...')
    _a      :			str					=							BeautifulSoup(requests.get(url).content, """html.parser""")
    # The image URL is in the content field of the first meta tag with property og:image
    _a      :			str					=							soup.find("""meta""", {"""property""": """og:image"""})["""content"""]
    _a      :			Dict					=							requests.get(image_url).content
    _a      :			str					=							f'{datetime.now():%Y-%m-%d_%H:%M:%S}.jpg'
    with open(file_name, """wb""") as fp:
        fp.write(image_data)
    print(f'Done. Image saved to disk as {file_name}.')

