



"""simple docstring"""


from ...processing_utils import ProcessorMixin
from ...tokenization_utils_base import BatchEncoding







class  A_     (	UpperCAmelCase_							):



						"""simple docstring"""
						__UpperCamelCase													=				["""image_processor""", """tokenizer"""]
						__UpperCamelCase													=				"""EfficientNetImageProcessor"""
						__UpperCamelCase													=				("""BertTokenizer""", """BertTokenizerFast""")






						def __init__(   self					:Union[str, Any]  ,    lowercase_					:Any  ,    lowercase_					:str   )							->     Tuple:
												super().__init__(a__  ,    a__   )






						def __call__(   self					:int  ,    lowercase_					:List[Any]=None  ,    lowercase_					:Any=None  ,    lowercase_					:str="max_length"  ,    lowercase_					:Any=64  ,    lowercase_					:str=None  ,    **lowercase_					:Union[str, Any]   )							->     Any:
												if text is None and images is None:
																		raise ValueError('You have to specify either text or images. Both cannot be none.'   )

												if text is not None:
																		UpperCAmelCase			 =					self.tokenizer(
																		    a__  ,    padding=a__  ,    max_length=a__  ,    return_tensors=a__  ,    **a__   )

												if images is not None:
																		UpperCAmelCase			 =					self.image_processor(a__  ,    return_tensors=a__  ,    **a__   )

												if text is not None and images is not None:
																		UpperCAmelCase			 =					image_features.pixel_values
																		return encoding
												elif text is not None:
																		return encoding
												else:
																		return BatchEncoding(data=dict(**a__   )  ,    tensor_type=a__   )






						def       UpperCAmelCase__	(   self					:List[Any]  ,    *lowercase_					:Optional[Any]  ,    **lowercase_					:Any   )							->     str:
												return self.tokenizer.batch_decode(*a__  ,    **a__   )






						def       UpperCAmelCase__	(   self					:List[Any]  ,    *lowercase_					:Optional[int]  ,    **lowercase_					:List[str]   )							->     str:
												return self.tokenizer.decode(*a__  ,    **a__   )






						@property
						def       UpperCAmelCase__	(   self					:Union[str, Any]   )							->     Optional[int]:
												UpperCAmelCase			 =					self.tokenizer.model_input_names
												UpperCAmelCase			 =					self.image_processor.model_input_names
												return list(dict.fromkeys(tokenizer_input_names + image_processor_input_names   )   )











'''simple docstring'''





import unittest

from transformers import (
    MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING,
    PreTrainedTokenizer,
    is_vision_available,
)
from transformers.pipelines import ImageClassificationPipeline, pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_torch_or_tf,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
       from PIL import Image
else:






       class     lowercase  :






             @staticmethod
             def  A__(*a__			,	**a__       )							-> Union[str, Any]:
                pass






@is_pipeline_test
@require_torch_or_tf
@require_vision
class     lowercase  ( unittest.TestCase):
      __lowercase					=	MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
      __lowercase					=	TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING






      def  A__(self			,	a__			,	a__			,	a__       )							-> Dict:
         SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			ImageClassificationPipeline(model=a__			,	image_processor=a__			,	top_k=2       )
         SCREAMING_SNAKE_CASE__      :					List[Any]							    =			[
             Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       ),
             '''http://images.cocodataset.org/val2017/000000039769.jpg''',
         ]
         return image_classifier, examples






      def  A__(self			,	a__			,	a__       )							-> List[Any]:
         SCREAMING_SNAKE_CASE__      :					int							    =			image_classifier('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       )

         self.assertEqual(
             a__			,	[
                 {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                 {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
             ]			,	)

         import datasets

         SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			datasets.load_dataset('''hf-internal-testing/fixtures_image_utils'''			,	'''image'''			,	split='''test'''       )

         # Accepts URL + PIL.Image + lists
         SCREAMING_SNAKE_CASE__      :					Tuple							    =			image_classifier(
             [
                 Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''       ),
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                 # RGBA
                 dataset[0]['''file'''],
                 # LA
                 dataset[1]['''file'''],
                 # L
                 dataset[2]['''file'''],
             ]       )
         self.assertEqual(
             a__			,	[
                 [
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                 ],
                 [
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                 ],
                 [
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                 ],
                 [
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                 ],
                 [
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                     {'''score''': ANY(a__       ), '''label''': ANY(a__       )},
                 ],
             ]			,	)






      @require_torch
      def  A__(self       )							-> List[str]:
         SCREAMING_SNAKE_CASE__      :					List[str]							    =			'''hf-internal-testing/tiny-random-vit'''
         SCREAMING_SNAKE_CASE__      :					Any							    =			pipeline('''image-classification'''			,	model=a__       )

         SCREAMING_SNAKE_CASE__      :					Any							    =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''       )
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}]			,	)

         SCREAMING_SNAKE_CASE__      :					Any							    =			image_classifier(
             [
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
             ]			,	top_k=2			,	)
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[
                 [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
                 [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
             ]			,	)






      @require_tf
      def  A__(self       )							-> Optional[int]:
         SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			'''hf-internal-testing/tiny-random-vit'''
         SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			pipeline('''image-classification'''			,	model=a__			,	framework='''tf'''       )

         SCREAMING_SNAKE_CASE__      :					List[str]							    =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''       )
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}]			,	)

         SCREAMING_SNAKE_CASE__      :					Dict							    =			image_classifier(
             [
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
                 '''http://images.cocodataset.org/val2017/000000039769.jpg''',
             ]			,	top_k=2			,	)
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[
                 [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
                 [{'''label''': '''LABEL_1''', '''score''': 0.5_74}, {'''label''': '''LABEL_0''', '''score''': 0.4_26}],
             ]			,	)






      def  A__(self       )							-> Union[str, Any]:
         SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			PreTrainedTokenizer()

         # Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
         SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			pipeline(
             '''image-classification'''			,	model='''hf-internal-testing/tiny-random-vit'''			,	tokenizer=a__       )

         self.assertIs(image_classifier.tokenizer			,	a__       )






      @slow
      @require_torch
      def  A__(self       )							-> int:
         # Perceiver is not tested by `run_pipeline_test` properly.
         # That is because the type of feature_extractor and model preprocessor need to be kept
         # in sync, which is not the case in the current design
         SCREAMING_SNAKE_CASE__      :					Union[str, Any]							    =			pipeline('''image-classification'''			,	model='''deepmind/vision-perceiver-conv'''       )
         SCREAMING_SNAKE_CASE__      :					str							    =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''       )
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[
                 {'''score''': 0.43_85, '''label''': '''tabby, tabby cat'''},
                 {'''score''': 0.3_21, '''label''': '''tiger cat'''},
                 {'''score''': 0.05_02, '''label''': '''Egyptian cat'''},
                 {'''score''': 0.01_37, '''label''': '''crib, cot'''},
                 {'''score''': 0.0_07, '''label''': '''radiator'''},
             ]			,	)

         SCREAMING_SNAKE_CASE__      :					str							    =			pipeline('''image-classification'''			,	model='''deepmind/vision-perceiver-fourier'''       )
         SCREAMING_SNAKE_CASE__      :					Optional[Any]							    =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''       )
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[
                 {'''score''': 0.56_58, '''label''': '''tabby, tabby cat'''},
                 {'''score''': 0.13_09, '''label''': '''tiger cat'''},
                 {'''score''': 0.07_22, '''label''': '''Egyptian cat'''},
                 {'''score''': 0.07_07, '''label''': '''remote control, remote'''},
                 {'''score''': 0.00_82, '''label''': '''computer keyboard, keypad'''},
             ]			,	)

         SCREAMING_SNAKE_CASE__      :					Dict							    =			pipeline('''image-classification'''			,	model='''deepmind/vision-perceiver-learned'''       )
         SCREAMING_SNAKE_CASE__      :					Optional[int]							    =			image_classifier('''http://images.cocodataset.org/val2017/000000039769.jpg'''       )
         self.assertEqual(
             nested_simplify(a__			,	decimals=4       )			,	[
                 {'''score''': 0.30_22, '''label''': '''tabby, tabby cat'''},
                 {'''score''': 0.23_62, '''label''': '''Egyptian cat'''},
                 {'''score''': 0.18_56, '''label''': '''tiger cat'''},
                 {'''score''': 0.03_24, '''label''': '''remote control, remote'''},
                 {'''score''': 0.00_96, '''label''': '''quilt, comforter, comfort, puff'''},
             ]			,	)

