

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     :





       '''simple docstring'''



       @staticmethod
       def    snake_case_       (  *SCREAMING_SNAKE_CASE_   ,**SCREAMING_SNAKE_CASE_    ):

           '''simple docstring'''
           pass



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





  '''simple docstring'''



  @require_torch
  def    snake_case_       (  self    ):

      '''simple docstring'''
      snake_case							:		Dict        =		pipeline(
          model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""   ,)
      snake_case							:		Tuple        =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      snake_case							:		List[str]        =		image_classifier(SCREAMING_SNAKE_CASE_   ,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(SCREAMING_SNAKE_CASE_    )   ,[
              [{"""score""": 0.3_33, """label""": """a"""}, {"""score""": 0.3_33, """label""": """b"""}, {"""score""": 0.3_33, """label""": """c"""}],
              [{"""score""": 0.3_33, """label""": """a"""}, {"""score""": 0.3_33, """label""": """c"""}, {"""score""": 0.3_33, """label""": """b"""}],
          ]   ,)

      snake_case							:		Optional[Any]        =		image_classifier([image] * 5   ,candidate_labels=["""A""", """B""", """C"""]   ,batch_size=2    )
      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
          ]   ,)





  @require_tf
  def    snake_case_       (  self    ):

      '''simple docstring'''
      snake_case							:		Optional[int]        =		pipeline(
          model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""   ,framework="""tf"""    )
      snake_case							:		Optional[int]        =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      snake_case							:		Any        =		image_classifier(SCREAMING_SNAKE_CASE_   ,candidate_labels=["""a""", """b""", """c"""]    )

      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[{"""score""": 0.3_33, """label""": """a"""}, {"""score""": 0.3_33, """label""": """b"""}, {"""score""": 0.3_33, """label""": """c"""}]   ,)

      snake_case							:		int        =		image_classifier([image] * 5   ,candidate_labels=["""A""", """B""", """C"""]   ,batch_size=2    )
      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
              [
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
                  {"""score""": 0.3_33, """label""": ANY(SCREAMING_SNAKE_CASE_    )},
              ],
          ]   ,)





  @slow
  @require_torch
  def    snake_case_       (  self    ):

      '''simple docstring'''
      snake_case							:		Optional[int]        =		pipeline(
          task="""zero-shot-image-classification"""   ,model="""openai/clip-vit-base-patch32"""   ,)
      # This is an image of 2 cats with remotes and no planes
      snake_case							:		Any        =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      snake_case							:		str        =		image_classifier(SCREAMING_SNAKE_CASE_   ,candidate_labels=["""cat""", """plane""", """remote"""]    )

      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[
              {"""score""": 0.5_11, """label""": """remote"""},
              {"""score""": 0.4_85, """label""": """cat"""},
              {"""score""": 0.0_04, """label""": """plane"""},
          ]   ,)

      snake_case							:		Optional[Any]        =		image_classifier([image] * 5   ,candidate_labels=["""cat""", """plane""", """remote"""]   ,batch_size=2    )
      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[
              [
                  {"""score""": 0.5_11, """label""": """remote"""},
                  {"""score""": 0.4_85, """label""": """cat"""},
                  {"""score""": 0.0_04, """label""": """plane"""},
              ],
          ]
          * 5   ,)





  @slow
  @require_tf
  def    snake_case_       (  self    ):

      '''simple docstring'''
      snake_case							:		Any        =		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
      snake_case							:		List[str]        =		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
      snake_case							:		Dict        =		image_classifier(SCREAMING_SNAKE_CASE_   ,candidate_labels=["""cat""", """plane""", """remote"""]    )
      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[
              {"""score""": 0.5_11, """label""": """remote"""},
              {"""score""": 0.4_85, """label""": """cat"""},
              {"""score""": 0.0_04, """label""": """plane"""},
          ]   ,)

      snake_case							:		Optional[int]        =		image_classifier([image] * 5   ,candidate_labels=["""cat""", """plane""", """remote"""]   ,batch_size=2    )
      self.assertEqual(
          nested_simplify(SCREAMING_SNAKE_CASE_    )   ,[
              [
                  {"""score""": 0.5_11, """label""": """remote"""},
                  {"""score""": 0.4_85, """label""": """cat"""},
                  {"""score""": 0.0_04, """label""": """plane"""},
              ],
          ]
          * 5   ,)





"""simple docstring"""





from typing import TYPE_CHECKING

from ..utils import _LazyModule


UpperCamelCase_       :    Dict						      =			{
    '''config''': [
        '''EXTERNAL_DATA_FORMAT_SIZE_LIMIT''',
        '''OnnxConfig''',
        '''OnnxConfigWithPast''',
        '''OnnxSeq2SeqConfigWithPast''',
        '''PatchingSpec''',
    ],
    '''convert''': ['''export''', '''validate_model_outputs'''],
    '''features''': ['''FeaturesManager'''],
    '''utils''': ['''ParameterFormat''', '''compute_serialized_parameters_size'''],
}


if TYPE_CHECKING:
		from .config import (
		    EXTERNAL_DATA_FORMAT_SIZE_LIMIT,
		    OnnxConfig,
		    OnnxConfigWithPast,
		    OnnxSeqaSeqConfigWithPast,
		    PatchingSpec,
		)
		from .convert import export, validate_model_outputs
		from .features import FeaturesManager
		from .utils import ParameterFormat, compute_serialized_parameters_size

else:
		import sys

		UpperCamelCase_       :    List[Any]						      =			_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




