






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       snake_case_   ( *_lowerCAmelCase     ,						**_lowerCAmelCase		):



           '''simple docstring'''
           pass







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




      """simple docstring"""



      @require_torch
      def       snake_case_   ( self		):



          '''simple docstring'''
          lowerCAmelCase__ :List[Any]   				=					pipeline(
              model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification"     ,						)
          lowerCAmelCase__ :List[str]   				=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
          lowerCAmelCase__ :str   				=					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.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[Any]   				=					image_classifier([image] * 5     ,						candidate_labels=["A", "B", "C"]     ,						batch_size=2		)
          self.assertEqual(
              nested_simplify(snake_case_		)     ,						[
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
              ]     ,						)
      @require_tf
      def       snake_case_   ( self		):



          '''simple docstring'''
          lowerCAmelCase__ :Union[str, Any]   				=					pipeline(
              model="hf-internal-testing/tiny-random-clip-zero-shot-image-classification"     ,						framework="tf"		)
          lowerCAmelCase__ :Union[str, Any]   				=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
          lowerCAmelCase__ :List[str]   				=					image_classifier(snake_case_     ,						candidate_labels=["a", "b", "c"]		)

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

          lowerCAmelCase__ :List[str]   				=					image_classifier([image] * 5     ,						candidate_labels=["A", "B", "C"]     ,						batch_size=2		)
          self.assertEqual(
              nested_simplify(snake_case_		)     ,						[
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
                  [
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                      {"score": 0.333, "label": ANY(snake_case_		)},
                  ],
              ]     ,						)
      @slow
      @require_torch
      def       snake_case_   ( self		):



          '''simple docstring'''
          lowerCAmelCase__ :Dict   				=					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__ :Any   				=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
          lowerCAmelCase__ :Any   				=					image_classifier(snake_case_     ,						candidate_labels=["cat", "plane", "remote"]		)

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



      @slow
      @require_tf
      def       snake_case_   ( self		):



          '''simple docstring'''
          lowerCAmelCase__ :Dict   				=					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__ :Optional[Any]   				=					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"		)
          lowerCAmelCase__ :int   				=					image_classifier(snake_case_     ,						candidate_labels=["cat", "plane", "remote"]		)
          self.assertEqual(
              nested_simplify(snake_case_		)     ,						[
                  {"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(snake_case_		)     ,						[
                  [
                      {"score": 0.511, "label": "remote"},
                      {"score": 0.485, "label": "cat"},
                      {"score": 0.004, "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__)


