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 		_a					(*SCREAMING_SNAKE_CASE_   ,				**SCREAMING_SNAKE_CASE_	)		->      Union[str, Any]:





            '''simple docstring'''





            pass



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






  @require_torch
  def 		_a					(self	)		->      Dict:





       '''simple docstring'''





       UpperCamelCase__										=      pipeline(
           model='''hf-internal-testing/tiny-random-clip-zero-shot-image-classification'''   ,				)
       UpperCamelCase__										=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
       UpperCamelCase__										=      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.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'''}],
           ]   ,				)

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






  @require_tf
  def 		_a					(self	)		->      Union[str, Any]:





       '''simple docstring'''





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

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

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






  @slow
  @require_torch
  def 		_a					(self	)		->      Optional[int]:





       '''simple docstring'''





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

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

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






  @slow
  @require_tf
  def 		_a					(self	)		->      Any:





       '''simple docstring'''





       UpperCamelCase__										=      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
       UpperCamelCase__										=      Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''	)
       UpperCamelCase__										=      image_classifier(SCREAMING_SNAKE_CASE_   ,				candidate_labels=['''cat''', '''plane''', '''remote''']	)
       self.assertEqual(
           nested_simplify(SCREAMING_SNAKE_CASE_	)   ,				[
               {'''score''': 0.511, '''label''': '''remote'''},
               {'''score''': 0.485, '''label''': '''cat'''},
               {'''score''': 0.004, '''label''': '''plane'''},
           ]   ,				)

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




from datetime import datetime

import matplotlib.pyplot as plt
import torch







def  __UpperCamelCase    (						A							):
     for param in module.parameters():
          UpperCamelCase__										=      False







def  __UpperCamelCase    (						):
     UpperCamelCase__										=      '''cuda''' if torch.cuda.is_available() else '''cpu'''
     if torch.backends.mps.is_available() and torch.backends.mps.is_built():
          UpperCamelCase__										=      '''mps'''
     if device == "mps":
          print(
              '''WARNING: MPS currently doesn\'t seem to work, and messes up backpropagation without any visible torch'''
              ''' errors. I recommend using CUDA on a colab notebook or CPU instead if you\'re facing inexplicable issues'''
              ''' with generations.'''							)
     return device







def  __UpperCamelCase    (						A							):
     UpperCamelCase__										=      plt.imshow(A							)
     fig.axes.get_xaxis().set_visible(A							)
     fig.axes.get_yaxis().set_visible(A							)
     plt.show()







def  __UpperCamelCase    (						):
     UpperCamelCase__										=      datetime.now()
     UpperCamelCase__										=      current_time.strftime('''%H:%M:%S'''							)
     return timestamp



