'''simple docstring'''

import unittest

from transformers import is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
    from PIL import Image
else:







    class __a :





       @staticmethod
       def      UpperCAmelCase__     (					*lowerCamelCase				:			int				,**lowerCamelCase				:			List[Any]    ):

          '''simple docstring'''

          pass







@is_pipeline_test
@require_vision
class __a (   unittest.TestCase			):





   @require_torch
   def      UpperCAmelCase__     (					self				:			List[str]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       pipeline(
          model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""				,)
      __SCREAMING_SNAKE_CASE      							=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      __SCREAMING_SNAKE_CASE      							=       image_classifier(__A				,candidate_labels=["""a""", """b""", """c"""]    )

      # The floating scores are so close, we enter floating error approximation and the order is not guaranteed across
      # python and torch versions.
      self.assertIn(
          nested_simplify(__A    )				,[
              [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """b"""}, {"""score""": 0.333, """label""": """c"""}],
              [{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """c"""}, {"""score""": 0.333, """label""": """b"""}],
          ]				,)

      __SCREAMING_SNAKE_CASE      							=       image_classifier([image] * 5				,candidate_labels=["""A""", """B""", """C"""]				,batch_size=2    )
      self.assertEqual(
          nested_simplify(__A    )				,[
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
          ]				,)





   @require_tf
   def      UpperCAmelCase__     (					self				:			int    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       pipeline(
          model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""				,framework="""tf"""    )
      __SCREAMING_SNAKE_CASE      							=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      __SCREAMING_SNAKE_CASE      							=       image_classifier(__A				,candidate_labels=["""a""", """b""", """c"""]    )

      self.assertEqual(
          nested_simplify(__A    )				,[{"""score""": 0.333, """label""": """a"""}, {"""score""": 0.333, """label""": """b"""}, {"""score""": 0.333, """label""": """c"""}]				,)

      __SCREAMING_SNAKE_CASE      							=       image_classifier([image] * 5				,candidate_labels=["""A""", """B""", """C"""]				,batch_size=2    )
      self.assertEqual(
          nested_simplify(__A    )				,[
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
              [
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
                  {"""score""": 0.333, """label""": ANY(__A    )},
              ],
          ]				,)





   @slow
   @require_torch
   def      UpperCAmelCase__     (					self				:			Union[str, Any]    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       pipeline(
          task="""zero-shot-image-classification"""				,model="""openai/clip-vit-base-patch32"""				,)
      # This is an image of 2 cats with remotes and no planes
      __SCREAMING_SNAKE_CASE      							=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      __SCREAMING_SNAKE_CASE      							=       image_classifier(__A				,candidate_labels=["""cat""", """plane""", """remote"""]    )

      self.assertEqual(
          nested_simplify(__A    )				,[
              {"""score""": 0.511, """label""": """remote"""},
              {"""score""": 0.485, """label""": """cat"""},
              {"""score""": 0.004, """label""": """plane"""},
          ]				,)

      __SCREAMING_SNAKE_CASE      							=       image_classifier([image] * 5				,candidate_labels=["""cat""", """plane""", """remote"""]				,batch_size=2    )
      self.assertEqual(
          nested_simplify(__A    )				,[
              [
                  {"""score""": 0.511, """label""": """remote"""},
                  {"""score""": 0.485, """label""": """cat"""},
                  {"""score""": 0.004, """label""": """plane"""},
              ],
          ]
          * 5				,)





   @slow
   @require_tf
   def      UpperCAmelCase__     (					self				:			str    ):

      '''simple docstring'''

      __SCREAMING_SNAKE_CASE      							=       pipeline(
          task="""zero-shot-image-classification"""				,model="""openai/clip-vit-base-patch32"""				,framework="""tf"""    )
      # This is an image of 2 cats with remotes and no planes
      __SCREAMING_SNAKE_CASE      							=       Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      __SCREAMING_SNAKE_CASE      							=       image_classifier(__A				,candidate_labels=["""cat""", """plane""", """remote"""]    )
      self.assertEqual(
          nested_simplify(__A    )				,[
              {"""score""": 0.511, """label""": """remote"""},
              {"""score""": 0.485, """label""": """cat"""},
              {"""score""": 0.004, """label""": """plane"""},
          ]				,)

      __SCREAMING_SNAKE_CASE      							=       image_classifier([image] * 5				,candidate_labels=["""cat""", """plane""", """remote"""]				,batch_size=2    )
      self.assertEqual(
          nested_simplify(__A    )				,[
              [
                  {"""score""": 0.511, """label""": """remote"""},
                  {"""score""": 0.485, """label""": """cat"""},
                  {"""score""": 0.004, """label""": """plane"""},
              ],
          ]
          * 5				,)












'''simple docstring'''

import requests
from bsa import BeautifulSoup

def 						__magic_name__       (							__UpperCAmelCase							,	__UpperCAmelCase      )						->					str:

   '''simple docstring'''







   __SCREAMING_SNAKE_CASE      							=       BeautifulSoup(requests.get(__UpperCAmelCase							,	params=__UpperCAmelCase      ).content							,	"""html.parser"""      )
   __SCREAMING_SNAKE_CASE      							=       soup.find("""div"""							,	attrs={"""class""": """gs_ri"""}      )
   __SCREAMING_SNAKE_CASE      							=       div.find("""div"""							,	attrs={"""class""": """gs_fl"""}      ).find_all("""a"""      )
   return anchors[2].get_text()


if __name__ == "__main__":
    a        =						{
        "title": (
            "Precisely geometry controlled microsupercapacitors for ultrahigh areal "
            "capacitance, volumetric capacitance, and energy density"
        ),
        "journal": "Chem. Mater.",
        "volume": 30,
        "pages": "3979-3990",
        "year": 2018,
        "hl": "en",
    }
    print(get_citation("https://scholar.google.com/scholar_lookup", params=params))





