






'''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 		UpperCamelCase__    :




         '''simple docstring'''





         @staticmethod
         def 			UpperCamelCase_					(      *_lowerCAmelCase   ,**_lowerCAmelCase       ):
               pass




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




  '''simple docstring'''





  @require_torch
  def 			UpperCamelCase_					(      self       ):
        lowerCamelCase__         =  pipeline(
            model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""   ,)
        lowerCamelCase__         =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
        lowerCamelCase__         =  image_classifier(UpperCAmelCase__   ,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(UpperCAmelCase__       )   ,[
                [{"""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"""}],
            ]   ,)

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






  @require_tf
  def 			UpperCamelCase_					(      self       ):
        lowerCamelCase__         =  pipeline(
            model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""   ,framework="""tf"""       )
        lowerCamelCase__         =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
        lowerCamelCase__         =  image_classifier(UpperCAmelCase__   ,candidate_labels=["""a""", """b""", """c"""]       )

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

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






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

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

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






  @slow
  @require_tf
  def 			UpperCamelCase_					(      self       ):
        lowerCamelCase__         =  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
        lowerCamelCase__         =  Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""       )
        lowerCamelCase__         =  image_classifier(UpperCAmelCase__   ,candidate_labels=["""cat""", """plane""", """remote"""]       )
        self.assertEqual(
            nested_simplify(UpperCAmelCase__       )   ,[
                {"""score""": 0.511, """label""": """remote"""},
                {"""score""": 0.485, """label""": """cat"""},
                {"""score""": 0.004, """label""": """plane"""},
            ]   ,)

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









'''simple docstring'''







import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers.testing_utils import require_vision
from transformers.utils import is_vision_available


if is_vision_available():
							from PIL import Image

							from transformers import AutoProcessor, BertTokenizer, BlipImageProcessor, BlipProcessor, PreTrainedTokenizerFast




@require_vision
class 		UpperCamelCase__    (unittest.TestCase			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  tempfile.mkdtemp()

								lowerCamelCase__         =  BlipImageProcessor()
								lowerCamelCase__         =  BertTokenizer.from_pretrained("""hf-internal-testing/tiny-random-BertModel"""       )

								lowerCamelCase__         =  BlipProcessor(_lowerCAmelCase   ,_lowerCAmelCase       )

								processor.save_pretrained(self.tmpdirname       )






		def 			UpperCamelCase_					(      self   ,**_lowerCAmelCase       ):
								return AutoProcessor.from_pretrained(self.tmpdirname   ,**_lowerCAmelCase       ).tokenizer






		def 			UpperCamelCase_					(      self   ,**_lowerCAmelCase       ):
								return AutoProcessor.from_pretrained(self.tmpdirname   ,**_lowerCAmelCase       ).image_processor






		def 			UpperCamelCase_					(      self       ):
								shutil.rmtree(self.tmpdirname       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  [np.random.randint(2_55   ,size=(3, 30, 4_00)   ,dtype=np.uinta       )]

								lowerCamelCase__         =  [Image.fromarray(np.moveaxis(_lowerCAmelCase   ,0   ,-1       )       ) for x in image_inputs]

								return image_inputs






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  BlipProcessor(tokenizer=self.get_tokenizer()   ,image_processor=self.get_image_processor()       )
								processor.save_pretrained(self.tmpdirname       )

								lowerCamelCase__         =  self.get_tokenizer(bos_token="""(BOS)"""   ,eos_token="""(EOS)"""       )
								lowerCamelCase__         =  self.get_image_processor(do_normalize=_lowerCAmelCase   ,padding_value=1.0       )

								lowerCamelCase__         =  BlipProcessor.from_pretrained(
								    self.tmpdirname   ,bos_token="""(BOS)"""   ,eos_token="""(EOS)"""   ,do_normalize=_lowerCAmelCase   ,padding_value=1.0       )

								self.assertEqual(processor.tokenizer.get_vocab()   ,tokenizer_add_kwargs.get_vocab()       )
								self.assertIsInstance(processor.tokenizer   ,_lowerCAmelCase       )

								self.assertEqual(processor.image_processor.to_json_string()   ,image_processor_add_kwargs.to_json_string()       )
								self.assertIsInstance(processor.image_processor   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_image_processor()
								lowerCamelCase__         =  self.get_tokenizer()

								lowerCamelCase__         =  BlipProcessor(tokenizer=_lowerCAmelCase   ,image_processor=_lowerCAmelCase       )

								lowerCamelCase__         =  self.prepare_image_inputs()

								lowerCamelCase__         =  image_processor(_lowerCAmelCase   ,return_tensors="""np"""       )
								lowerCamelCase__         =  processor(images=_lowerCAmelCase   ,return_tensors="""np"""       )

								for key in input_feat_extract.keys():
														self.assertAlmostEqual(input_feat_extract[key].sum()   ,input_processor[key].sum()   ,delta=1E-2       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_image_processor()
								lowerCamelCase__         =  self.get_tokenizer()

								lowerCamelCase__         =  BlipProcessor(tokenizer=_lowerCAmelCase   ,image_processor=_lowerCAmelCase       )

								lowerCamelCase__         =  """lower newer"""

								lowerCamelCase__         =  processor(text=_lowerCAmelCase       )

								lowerCamelCase__         =  tokenizer(_lowerCAmelCase   ,return_token_type_ids=_lowerCAmelCase       )

								for key in encoded_tok.keys():
														self.assertListEqual(encoded_tok[key]   ,encoded_processor[key]       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_image_processor()
								lowerCamelCase__         =  self.get_tokenizer()

								lowerCamelCase__         =  BlipProcessor(tokenizer=_lowerCAmelCase   ,image_processor=_lowerCAmelCase       )

								lowerCamelCase__         =  """lower newer"""
								lowerCamelCase__         =  self.prepare_image_inputs()

								lowerCamelCase__         =  processor(text=_lowerCAmelCase   ,images=_lowerCAmelCase       )

								self.assertListEqual(list(inputs.keys()       )   ,["""pixel_values""", """input_ids""", """attention_mask"""]       )

								# test if it raises when no input is passed
								with pytest.raises(_lowerCAmelCase       ):
														processor()






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_image_processor()
								lowerCamelCase__         =  self.get_tokenizer()

								lowerCamelCase__         =  BlipProcessor(tokenizer=_lowerCAmelCase   ,image_processor=_lowerCAmelCase       )

								lowerCamelCase__         =  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

								lowerCamelCase__         =  processor.batch_decode(_lowerCAmelCase       )
								lowerCamelCase__         =  tokenizer.batch_decode(_lowerCAmelCase       )

								self.assertListEqual(_lowerCAmelCase   ,_lowerCAmelCase       )






		def 			UpperCamelCase_					(      self       ):
								lowerCamelCase__         =  self.get_image_processor()
								lowerCamelCase__         =  self.get_tokenizer()

								lowerCamelCase__         =  BlipProcessor(tokenizer=_lowerCAmelCase   ,image_processor=_lowerCAmelCase       )

								lowerCamelCase__         =  """lower newer"""
								lowerCamelCase__         =  self.prepare_image_inputs()

								lowerCamelCase__         =  processor(text=_lowerCAmelCase   ,images=_lowerCAmelCase       )

								# For now the processor supports only ['pixel_values', 'input_ids', 'attention_mask']
								self.assertListEqual(list(inputs.keys()       )   ,["""pixel_values""", """input_ids""", """attention_mask"""]       )

