





"""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 		lowercase					:





             @staticmethod
             def     _snake_case			(       *lowercase      ,						**lowercase )		->     Any:
                   pass

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





      @require_torch
      def     _snake_case			(       self )		->     List[str]:
            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(lowercase      ,						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(lowercase )      ,						[
                    [{"""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(lowercase )      ,						[
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                ]      ,						)





      @require_tf
      def     _snake_case			(       self )		->     List[str]:
            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(lowercase      ,						candidate_labels=["""a""", """b""", """c"""] )

            self.assertEqual(
                nested_simplify(lowercase )      ,						[{"""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(lowercase )      ,						[
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                    [
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                        {"""score""": 0.333, """label""": ANY(lowercase )},
                    ],
                ]      ,						)





      @slow
      @require_torch
      def     _snake_case			(       self )		->     Union[str, Any]:
            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(lowercase      ,						candidate_labels=["""cat""", """plane""", """remote"""] )

            self.assertEqual(
                nested_simplify(lowercase )      ,						[
                    {"""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(lowercase )      ,						[
                    [
                        {"""score""": 0.511, """label""": """remote"""},
                        {"""score""": 0.485, """label""": """cat"""},
                        {"""score""": 0.004, """label""": """plane"""},
                    ],
                ]
                * 5      ,						)





      @slow
      @require_tf
      def     _snake_case			(       self )		->     Optional[Any]:
            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(lowercase      ,						candidate_labels=["""cat""", """plane""", """remote"""] )
            self.assertEqual(
                nested_simplify(lowercase )      ,						[
                    {"""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(lowercase )      ,						[
                    [
                        {"""score""": 0.511, """label""": """remote"""},
                        {"""score""": 0.485, """label""": """cat"""},
                        {"""score""": 0.004, """label""": """plane"""},
                    ],
                ]
                * 5      ,						)










'''simple docstring'''







# NOTE: This file is deprecated and will be removed in a future version.
# It only exists so that temporarely `from diffusers.pipelines import DiffusionPipeline` works
from ...utils import deprecate
from ..controlnet.multicontrolnet import MultiControlNetModel  # noqa: F401
from ..controlnet.pipeline_controlnet import StableDiffusionControlNetPipeline  # noqa: F401


deprecate(
    '''stable diffusion controlnet''',
    '''0.22.0''',
    '''Importing `StableDiffusionControlNetPipeline` or `MultiControlNetModel` from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion_controlnet is deprecated. Please import `from diffusers import StableDiffusionControlNetPipeline` instead.''',
    standard_warn=False,
    stacklevel=3,
)


