





"""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    _UpperCAmelCase  :


							@staticmethod
							def       lowerCamelCase			(   *__UpperCamelCase     :Tuple	,			**__UpperCamelCase     :Dict						):
														pass






@is_pipeline_test
@require_torch_or_tf
@require_vision
class    _UpperCAmelCase  (      unittest.TestCase					):
					UpperCamelCase						=				MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
					UpperCamelCase						=				TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING


					def       lowerCamelCase			(   self     :Union[str, Any]	,			__UpperCamelCase     :List[str]	,			__UpperCamelCase     :Union[str, Any]	,			__UpperCamelCase     :int						):
												A						=    ImageClassificationPipeline(model=_UpperCAmelCase	,			image_processor=_UpperCAmelCase	,			top_k=2						)
												A						=    [
												    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"						),
												    '''http://images.cocodataset.org/val2017/000000039769.jpg''',
												]
												return image_classifier, examples


					def       lowerCamelCase			(   self     :Any	,			__UpperCamelCase     :Optional[Any]	,			__UpperCamelCase     :Optional[int]						):
												A						=    image_classifier("./tests/fixtures/tests_samples/COCO/000000039769.png"						)

												self.assertEqual(
												    _UpperCAmelCase	,			[
												        {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												        {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												    ]	,			)

												import datasets

												A						=    datasets.load_dataset("hf-internal-testing/fixtures_image_utils"	,			"image"	,			split="test"						)

												# Accepts URL + PIL.Image + lists
												A						=    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(
												    _UpperCAmelCase	,			[
												        [
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												        ],
												        [
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												        ],
												        [
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												        ],
												        [
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												        ],
												        [
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												            {"score": ANY(_UpperCAmelCase						), "label": ANY(_UpperCAmelCase						)},
												        ],
												    ]	,			)


					@require_torch
					def       lowerCamelCase			(   self     :Tuple						):
												A						=    '''hf-internal-testing/tiny-random-vit'''
												A						=    pipeline("image-classification"	,			model=_UpperCAmelCase						)

												A						=    image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"						)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}]	,			)

												A						=    image_classifier(
												    [
												        "http://images.cocodataset.org/val2017/000000039769.jpg",
												        "http://images.cocodataset.org/val2017/000000039769.jpg",
												    ]	,			top_k=2	,			)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[
												        [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
												        [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
												    ]	,			)


					@require_tf
					def       lowerCamelCase			(   self     :Optional[int]						):
												A						=    '''hf-internal-testing/tiny-random-vit'''
												A						=    pipeline("image-classification"	,			model=_UpperCAmelCase	,			framework="tf"						)

												A						=    image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"						)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}]	,			)

												A						=    image_classifier(
												    [
												        "http://images.cocodataset.org/val2017/000000039769.jpg",
												        "http://images.cocodataset.org/val2017/000000039769.jpg",
												    ]	,			top_k=2	,			)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[
												        [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
												        [{"label": "LABEL_1", "score": 0.574}, {"label": "LABEL_0", "score": 0.426}],
												    ]	,			)


					def       lowerCamelCase			(   self     :Dict						):
												A						=    PreTrainedTokenizer()

												# Assert that the pipeline can be initialized with a feature extractor that is not in any mapping
												A						=    pipeline(
												    "image-classification"	,			model="hf-internal-testing/tiny-random-vit"	,			tokenizer=_UpperCAmelCase						)

												self.assertIs(image_classifier.tokenizer	,			_UpperCAmelCase						)


					@slow
					@require_torch
					def       lowerCamelCase			(   self     :Optional[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
												A						=    pipeline("image-classification"	,			model="deepmind/vision-perceiver-conv"						)
												A						=    image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"						)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[
												        {"score": 0.4_385, "label": "tabby, tabby cat"},
												        {"score": 0.321, "label": "tiger cat"},
												        {"score": 0.0_502, "label": "Egyptian cat"},
												        {"score": 0.0_137, "label": "crib, cot"},
												        {"score": 0.007, "label": "radiator"},
												    ]	,			)

												A						=    pipeline("image-classification"	,			model="deepmind/vision-perceiver-fourier"						)
												A						=    image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"						)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[
												        {"score": 0.5_658, "label": "tabby, tabby cat"},
												        {"score": 0.1_309, "label": "tiger cat"},
												        {"score": 0.0_722, "label": "Egyptian cat"},
												        {"score": 0.0_707, "label": "remote control, remote"},
												        {"score": 0.0_082, "label": "computer keyboard, keypad"},
												    ]	,			)

												A						=    pipeline("image-classification"	,			model="deepmind/vision-perceiver-learned"						)
												A						=    image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"						)
												self.assertEqual(
												    nested_simplify(_UpperCAmelCase	,			decimals=4						)	,			[
												        {"score": 0.3_022, "label": "tabby, tabby cat"},
												        {"score": 0.2_362, "label": "Egyptian cat"},
												        {"score": 0.1_856, "label": "tiger cat"},
												        {"score": 0.0_324, "label": "remote control, remote"},
												        {"score": 0.0_096, "label": "quilt, comforter, comfort, puff"},
												    ]	,			)










'''simple docstring'''







import re






def  lowerCAmelCase__		(					a_  :     Optional[int]			)   -> Optional[Any]:
       def docstring_decorator(a_  :     Dict			):
              UpperCAmelCase__	:   Optional[int]												=	fn.__doc__
              UpperCAmelCase__	:   Dict												=	func_doc.split('''\n'''			)
              UpperCAmelCase__	:   Any												=	0
              while i < len(a_			) and re.search(r'''^\s*Examples?:\s*$'''			,						lines[i]			) is None:
                     i += 1
              if i < len(a_			):
                     UpperCAmelCase__	:   List[Any]												=	example_docstring
                     UpperCAmelCase__	:   int												=	'''\n'''.join(a_			)
              else:
                     raise ValueError(
                         f"""The function {fn} should have an empty 'Examples:' in its docstring as placeholder, """
                         f"""current docstring is:\n{func_doc}"""			)
              UpperCAmelCase__	:   Any												=	func_doc
              return fn

       return docstring_decorator