




'''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      __lowerCAmelCase    (						*lowerCAmelCase_ :						Any							,    **lowerCAmelCase_ :						List[Any]      )    ->							str:


																		"""simple docstring"""


																		pass

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







							@require_torch
							def      __lowerCAmelCase    (						self :						Union[str, Any]      )    ->							Tuple:


														"""simple docstring"""


														_a			  =       pipeline(
														    model='''hf-internal-testing/tiny-random-clip-zero-shot-image-classification'''							,    )
														_a			  =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
														_a			  =       image_classifier(lowerCAmelCase_							,    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(lowerCAmelCase_      )							,    [
														        [{'''score''': 0.3_3_3, '''label''': '''a'''}, {'''score''': 0.3_3_3, '''label''': '''b'''}, {'''score''': 0.3_3_3, '''label''': '''c'''}],
														        [{'''score''': 0.3_3_3, '''label''': '''a'''}, {'''score''': 0.3_3_3, '''label''': '''c'''}, {'''score''': 0.3_3_3, '''label''': '''b'''}],
														    ]							,    )

														_a			  =       image_classifier([image] * 5							,    candidate_labels=['''A''', '''B''', '''C''']							,    batch_size=2      )
														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														    ]							,    )







							@require_tf
							def      __lowerCAmelCase    (						self :						Tuple      )    ->							str:


														"""simple docstring"""


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

														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [{'''score''': 0.3_3_3, '''label''': '''a'''}, {'''score''': 0.3_3_3, '''label''': '''b'''}, {'''score''': 0.3_3_3, '''label''': '''c'''}]							,    )

														_a			  =       image_classifier([image] * 5							,    candidate_labels=['''A''', '''B''', '''C''']							,    batch_size=2      )
														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														        [
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														            {'''score''': 0.3_3_3, '''label''': ANY(lowerCAmelCase_      )},
														        ],
														    ]							,    )







							@slow
							@require_torch
							def      __lowerCAmelCase    (						self :						List[Any]      )    ->							Tuple:


														"""simple docstring"""


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

														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [
														        {'''score''': 0.5_1_1, '''label''': '''remote'''},
														        {'''score''': 0.4_8_5, '''label''': '''cat'''},
														        {'''score''': 0.0_0_4, '''label''': '''plane'''},
														    ]							,    )

														_a			  =       image_classifier([image] * 5							,    candidate_labels=['''cat''', '''plane''', '''remote''']							,    batch_size=2      )
														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [
														        [
														            {'''score''': 0.5_1_1, '''label''': '''remote'''},
														            {'''score''': 0.4_8_5, '''label''': '''cat'''},
														            {'''score''': 0.0_0_4, '''label''': '''plane'''},
														        ],
														    ]
														    * 5							,    )







							@slow
							@require_tf
							def      __lowerCAmelCase    (						self :						Union[str, Any]      )    ->							Dict:


														"""simple docstring"""


														_a			  =       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
														_a			  =       Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''      )
														_a			  =       image_classifier(lowerCAmelCase_							,    candidate_labels=['''cat''', '''plane''', '''remote''']      )
														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [
														        {'''score''': 0.5_1_1, '''label''': '''remote'''},
														        {'''score''': 0.4_8_5, '''label''': '''cat'''},
														        {'''score''': 0.0_0_4, '''label''': '''plane'''},
														    ]							,    )

														_a			  =       image_classifier([image] * 5							,    candidate_labels=['''cat''', '''plane''', '''remote''']							,    batch_size=2      )
														self.assertEqual(
														    nested_simplify(lowerCAmelCase_      )							,    [
														        [
														            {'''score''': 0.5_1_1, '''label''': '''remote'''},
														            {'''score''': 0.4_8_5, '''label''': '''cat'''},
														            {'''score''': 0.0_0_4, '''label''': '''plane'''},
														        ],
														    ]
														    * 5							,    )







'''simple docstring'''


from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_torch_available,
    is_vision_available,
)


_snake_case   :   List[Any]     							=	{'configuration_beit': ['BEIT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'BeitConfig', 'BeitOnnxConfig']}

try:
				if not is_vision_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case   :   Any     							=	['BeitFeatureExtractor']
				_snake_case   :   Any     							=	['BeitImageProcessor']

try:
				if not is_torch_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case   :   List[str]     							=	[
				    'BEIT_PRETRAINED_MODEL_ARCHIVE_LIST',
				    'BeitForImageClassification',
				    'BeitForMaskedImageModeling',
				    'BeitForSemanticSegmentation',
				    'BeitModel',
				    'BeitPreTrainedModel',
				]


try:
				if not is_flax_available():
								raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
				pass
else:
				_snake_case   :   List[str]     							=	[
				    'FlaxBeitForImageClassification',
				    'FlaxBeitForMaskedImageModeling',
				    'FlaxBeitModel',
				    'FlaxBeitPreTrainedModel',
				]

if TYPE_CHECKING:
				from .configuration_beit import BEIT_PRETRAINED_CONFIG_ARCHIVE_MAP, BeitConfig, BeitOnnxConfig

				try:
								if not is_vision_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .feature_extraction_beit import BeitFeatureExtractor
								from .image_processing_beit import BeitImageProcessor

				try:
								if not is_torch_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_beit import (
								    BEIT_PRETRAINED_MODEL_ARCHIVE_LIST,
								    BeitForImageClassification,
								    BeitForMaskedImageModeling,
								    BeitForSemanticSegmentation,
								    BeitModel,
								    BeitPreTrainedModel,
								)

				try:
								if not is_flax_available():
												raise OptionalDependencyNotAvailable()
				except OptionalDependencyNotAvailable:
								pass
				else:
								from .modeling_flax_beit import (
								    FlaxBeitForImageClassification,
								    FlaxBeitForMaskedImageModeling,
								    FlaxBeitModel,
								    FlaxBeitPreTrainedModel,
								)


else:
				import sys

				_snake_case   :   Union[str, Any]     							=	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)

