






'''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 	lowerCamelCase_       (							*UpperCamelCase__:       Optional[int]    ,							**UpperCamelCase__:       List[Any]  ):
																	pass

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




							@require_torch
							def 	lowerCamelCase_       (							self:       Union[str, Any]  ):
														lowerCamelCase__      :			Tuple 						= pipeline(
														    model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""    ,							)
														lowerCamelCase__      :			int 						= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  )
														lowerCamelCase__      :			List[str] 						= 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__      :			List[str] 						= 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 	lowerCamelCase_       (							self:       Any  ):
														lowerCamelCase__      :			List[Any] 						= pipeline(
														    model="""hf-internal-testing/tiny-random-clip-zero-shot-image-classification"""    ,							framework="""tf"""  )
														lowerCamelCase__      :			Any 						= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  )
														lowerCamelCase__      :			List[str] 						= 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__      :			int 						= 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 	lowerCamelCase_       (							self:       Union[str, Any]  ):
														lowerCamelCase__      :			List[str] 						= 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__      :			Optional[int] 						= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  )
														lowerCamelCase__      :			str 						= 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__      :			int 						= 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 	lowerCamelCase_       (							self:       int  ):
														lowerCamelCase__      :			Optional[int] 						= 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__      :			List[str] 						= Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  )
														lowerCamelCase__      :			Optional[Any] 						= 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__      :			Tuple 						= 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'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_speech_available,
    is_torch_available,
)


_A			:    Any					  ={
    '''configuration_trocr''': ['''TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''TrOCRConfig'''],
    '''processing_trocr''': ['''TrOCRProcessor'''],
}


try:
			if not is_torch_available():
						raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
			pass
else:
			_A			:    str					  =[
			    '''TROCR_PRETRAINED_MODEL_ARCHIVE_LIST''',
			    '''TrOCRForCausalLM''',
			    '''TrOCRPreTrainedModel''',
			]


if TYPE_CHECKING:
			from .configuration_trocr import TROCR_PRETRAINED_CONFIG_ARCHIVE_MAP, TrOCRConfig
			from .processing_trocr import TrOCRProcessor

			try:
						if not is_torch_available():
									raise OptionalDependencyNotAvailable()
			except OptionalDependencyNotAvailable:
						pass
			else:
						from .modeling_trocr import TROCR_PRETRAINED_MODEL_ARCHIVE_LIST, TrOCRForCausalLM, TrOCRPreTrainedModel

else:
			import sys

			_A			:    Dict					  =_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

