


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 						lowerCamelCase_							:



						'''simple docstring'''







						@staticmethod
						def A   (					*snake_case_			,							**snake_case_    ) ->      str:







									'''simple docstring'''

									pass
@is_pipeline_test
@require_vision
class 						lowerCamelCase_							(					unittest.TestCase					):



					'''simple docstring'''







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







								'''simple docstring'''

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

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






					@require_tf
					def A   (					self    ) ->      str:







								'''simple docstring'''

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

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

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






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







								'''simple docstring'''

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

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

								__lowercase			       = image_classifier([image] * 5			,							candidate_labels=['''cat''', '''plane''', '''remote''']			,							batch_size=2    )
								self.assertEqual(
								    nested_simplify(snake_case_    )			,							[
								        [
								            {'''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 A   (					self    ) ->      Union[str, Any]:







								'''simple docstring'''

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

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






from typing import TYPE_CHECKING

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


a			:			Optional[Any]												=					{
    '''configuration_llama''': ['''LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''LlamaConfig'''],
}

try:
	if not is_sentencepiece_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a			:			Optional[int]												=					['''LlamaTokenizer''']

try:
	if not is_tokenizers_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a			:			Optional[int]												=					['''LlamaTokenizerFast''']

try:
	if not is_torch_available():
		raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
	pass
else:
	a			:			Any												=					[
	    '''LlamaForCausalLM''',
	    '''LlamaModel''',
	    '''LlamaPreTrainedModel''',
	    '''LlamaForSequenceClassification''',
	]


if TYPE_CHECKING:
	from .configuration_llama import LLAMA_PRETRAINED_CONFIG_ARCHIVE_MAP, LlamaConfig

	try:
		if not is_sentencepiece_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_llama import LlamaTokenizer

	try:
		if not is_tokenizers_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .tokenization_llama_fast import LlamaTokenizerFast

	try:
		if not is_torch_available():
			raise OptionalDependencyNotAvailable()
	except OptionalDependencyNotAvailable:
		pass
	else:
		from .modeling_llama import LlamaForCausalLM, LlamaForSequenceClassification, LlamaModel, LlamaPreTrainedModel


else:
	import sys

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


