






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





     '''simple docstring'''






     @staticmethod
     def __lowercase				(    *UpperCAmelCase_ ,      **UpperCAmelCase_)       ->					Union[str, Any]:




            '''simple docstring'''




            pass







@is_pipeline_test
@require_torch_or_tf
@require_vision
class 		_a   (						unittest.TestCase    ):





   '''simple docstring'''






   UpperCamelCase__			     =				MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
   UpperCamelCase__			     =				TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING





   def __lowercase				(    self ,      UpperCAmelCase_ ,      UpperCAmelCase_ ,      UpperCAmelCase_)       ->					Any:




          '''simple docstring'''




          lowercase__:				Any			  =			ImageClassificationPipeline(model=A_ ,      image_processor=A_ ,      top_k=2)
          lowercase__:				Optional[Any]			  =			[
              Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"),
              "http://images.cocodataset.org/val2017/000000039769.jpg",
          ]
          return image_classifier, examples





   def __lowercase				(    self ,      UpperCAmelCase_ ,      UpperCAmelCase_)       ->					int:




          '''simple docstring'''




          lowercase__:				Tuple			  =			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

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

          # Accepts URL + PIL.Image + lists
          lowercase__:				Any			  =			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 __lowercase				(    self)       ->					Optional[int]:




          '''simple docstring'''




          lowercase__:				Any			  =			"hf-internal-testing/tiny-random-vit"
          lowercase__:				List[Any]			  =			pipeline("image-classification" ,      model=A_)

          lowercase__:				Optional[int]			  =			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}] ,      )

          lowercase__:				List[str]			  =			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 __lowercase				(    self)       ->					int:




          '''simple docstring'''




          lowercase__:				int			  =			"hf-internal-testing/tiny-random-vit"
          lowercase__:				List[Any]			  =			pipeline("image-classification" ,      model=A_ ,      framework="tf")

          lowercase__:				Union[str, 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}] ,      )

          lowercase__:				Optional[int]			  =			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 __lowercase				(    self)       ->					Union[str, Any]:




          '''simple docstring'''




          lowercase__:				Optional[Any]			  =			PreTrainedTokenizer()

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

          self.assertIs(image_classifier.tokenizer ,      A_)





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




          '''simple docstring'''




          lowercase__:				Dict			  =			pipeline("image-classification" ,      model="deepmind/vision-perceiver-conv")
          lowercase__:				Union[str, Any]			  =			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"},
              ] ,      )

          lowercase__:				str			  =			pipeline("image-classification" ,      model="deepmind/vision-perceiver-fourier")
          lowercase__:				Optional[int]			  =			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"},
              ] ,      )

          lowercase__:				List[Any]			  =			pipeline("image-classification" ,      model="deepmind/vision-perceiver-learned")
          lowercase__:				str			  =			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"},
              ] ,      )









from typing import Dict, List, Optional, Union

import numpy as np

from ...image_processing_utils import BaseImageProcessor, BatchFeature, get_size_dict
from ...image_transforms import (
    get_resize_output_image_size,
    normalize,
    pad,
    rescale,
    resize,
    to_channel_dimension_format,
)
from ...image_utils import (
    IMAGENET_STANDARD_MEAN,
    IMAGENET_STANDARD_STD,
    ChannelDimension,
    ImageInput,
    PILImageResampling,
    get_image_size,
    make_list_of_images,
    to_numpy_array,
    valid_images,
)
from ...utils import TensorType, logging
from ...utils.import_utils import is_vision_available


SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)


if is_vision_available():
					import PIL

class  a     (		UpperCAmelCase ):
						_lowercase			  =	["pixel_values"]


						def __init__(				self  ,    A_ = True  ,    A_ = None  ,    A_ = PILImageResampling.BILINEAR  ,    A_ = True  ,    A_ = False  ,    A_ = True  ,    A_ = True  ,    A_ = 1 / 255  ,    A_ = True  ,    A_ = None  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										super().__init__(**A_		)

										_UpperCAmelCase				:						str       						=			size if size is not None else {"height": 2560, "width": 1920}
										if isinstance(A_  ,    (tuple, list)		):
														# The previous feature extractor size parameter was in (width, height) format
														_UpperCAmelCase				:						List[Any]       						=			size[::-1]
										_UpperCAmelCase				:						Dict       						=			get_size_dict(A_		)

										_UpperCAmelCase				:						int       						=			do_resize
										_UpperCAmelCase				:						Dict       						=			size
										_UpperCAmelCase				:						List[Any]       						=			resample
										_UpperCAmelCase				:						Union[str, Any]       						=			do_thumbnail
										_UpperCAmelCase				:						Optional[int]       						=			do_align_long_axis
										_UpperCAmelCase				:						Optional[Any]       						=			do_pad
										_UpperCAmelCase				:						int       						=			do_rescale
										_UpperCAmelCase				:						List[Any]       						=			rescale_factor
										_UpperCAmelCase				:						Union[str, Any]       						=			do_normalize
										_UpperCAmelCase				:						Any       						=			image_mean if image_mean is not None else IMAGENET_STANDARD_MEAN
										_UpperCAmelCase				:						Dict       						=			image_std if image_std is not None else IMAGENET_STANDARD_STD


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = None		):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase				:						List[str]       						=			get_image_size(A_		)
										_UpperCAmelCase						,							_UpperCAmelCase				:						Any       						=			size["height"], size["width"]

										if (output_width < output_height and input_width > input_height) or (
										    output_width > output_height and input_width < input_height
										):
														_UpperCAmelCase				:						Optional[int]       						=			np.rotaa(A_  ,    3		)

										if data_format is not None:
														_UpperCAmelCase				:						List[str]       						=			to_channel_dimension_format(A_  ,    A_		)

										return image


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = False  ,    A_ = None  ,    ):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase				:						Optional[Any]       						=			size["height"], size["width"]
										_UpperCAmelCase						,							_UpperCAmelCase				:						List[Any]       						=			get_image_size(A_		)

										_UpperCAmelCase				:						Optional[Any]       						=			output_width - input_width
										_UpperCAmelCase				:						Any       						=			output_height - input_height

										if random_padding:
														_UpperCAmelCase				:						List[str]       						=			np.random.randint(low=0  ,    high=delta_height + 1		)
														_UpperCAmelCase				:						Optional[int]       						=			np.random.randint(low=0  ,    high=delta_width + 1		)
										else:
														_UpperCAmelCase				:						Union[str, Any]       						=			delta_height // 2
														_UpperCAmelCase				:						str       						=			delta_width // 2

										_UpperCAmelCase				:						Optional[Any]       						=			delta_height - pad_top
										_UpperCAmelCase				:						List[Any]       						=			delta_width - pad_left

										_UpperCAmelCase				:						Optional[Any]       						=			((pad_top, pad_bottom), (pad_left, pad_right))
										return pad(A_  ,    A_  ,    data_format=A_		)


						def 				_UpperCAmelCase (				self  ,    *A_  ,    **A_		):







										'''simple docstring'''


										logger.info("pad is deprecated and will be removed in version 4.27. Please use pad_image instead."		)
										return self.pad_image(*A_  ,    **A_		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = PILImageResampling.BICUBIC  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase				:						Union[str, Any]       						=			get_image_size(A_		)
										_UpperCAmelCase						,							_UpperCAmelCase				:						Union[str, Any]       						=			size["height"], size["width"]

										# We always resize to the smallest of either the input or output size.
										_UpperCAmelCase				:						Dict       						=			min(A_  ,    A_		)
										_UpperCAmelCase				:						Tuple       						=			min(A_  ,    A_		)

										if height == input_height and width == input_width:
														return image

										if input_height > input_width:
														_UpperCAmelCase				:						Any       						=			int(input_width * height / input_height		)
										elif input_width > input_height:
														_UpperCAmelCase				:						Any       						=			int(input_height * width / input_width		)

										return resize(
										    A_  ,    size=(height, width)  ,    resample=A_  ,    reducing_gap=2.0  ,    data_format=A_  ,    **A_		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = PILImageResampling.BICUBIC  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						Any       						=			get_size_dict(A_		)
										_UpperCAmelCase				:						List[str]       						=			min(size["height"]  ,    size["width"]		)
										_UpperCAmelCase				:						Optional[Any]       						=			get_resize_output_image_size(A_  ,    size=A_  ,    default_to_square=A_		)
										_UpperCAmelCase				:						str       						=			resize(A_  ,    size=A_  ,    resample=A_  ,    data_format=A_  ,    **A_		)
										return resized_image


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										return rescale(A_  ,    scale=A_  ,    data_format=A_  ,    **A_		)


						def 				_UpperCAmelCase (				self  ,    A_  ,    A_  ,    A_  ,    A_ = None  ,    **A_  ,    ):







										'''simple docstring'''


										return normalize(A_  ,    mean=A_  ,    std=A_  ,    data_format=A_  ,    **A_		)





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = ChannelDimension.FIRST  ,    **A_  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			do_resize if do_resize is not None else self.do_resize
										_UpperCAmelCase				:						str       						=			size if size is not None else self.size
										if isinstance(A_  ,    (tuple, list)		):
														# Previous feature extractor had size in (width, height) format
														_UpperCAmelCase				:						List[Any]       						=			size[::-1]
										_UpperCAmelCase				:						Union[str, Any]       						=			get_size_dict(A_		)
										_UpperCAmelCase				:						Dict       						=			resample if resample is not None else self.resample
										_UpperCAmelCase				:						str       						=			do_thumbnail if do_thumbnail is not None else self.do_thumbnail
										_UpperCAmelCase				:						Optional[Any]       						=			do_align_long_axis if do_align_long_axis is not None else self.do_align_long_axis
										_UpperCAmelCase				:						List[str]       						=			do_pad if do_pad is not None else self.do_pad
										_UpperCAmelCase				:						Optional[Any]       						=			do_rescale if do_rescale is not None else self.do_rescale
										_UpperCAmelCase				:						int       						=			rescale_factor if rescale_factor is not None else self.rescale_factor
										_UpperCAmelCase				:						List[str]       						=			do_normalize if do_normalize is not None else self.do_normalize
										_UpperCAmelCase				:						Any       						=			image_mean if image_mean is not None else self.image_mean
										_UpperCAmelCase				:						List[Any]       						=			image_std if image_std is not None else self.image_std

										_UpperCAmelCase				:						str       						=			make_list_of_images(A_		)

										if not valid_images(A_		):
														raise ValueError(
														    "Invalid image type. Must be of type PIL.Image.Image, numpy.ndarray, "
														    "torch.Tensor, tf.Tensor or jax.ndarray."		)

										if do_resize and size is None:
														raise ValueError("Size must be specified if do_resize is True."		)

										if do_rescale and rescale_factor is None:
														raise ValueError("Rescale factor must be specified if do_rescale is True."		)

										if do_pad and size is None:
														raise ValueError("Size must be specified if do_pad is True."		)

										if do_normalize and (image_mean is None or image_std is None):
														raise ValueError("Image mean and std must be specified if do_normalize is True."		)

										# All transformations expect numpy arrays.
										_UpperCAmelCase				:						Union[str, Any]       						=			[to_numpy_array(A_		) for image in images]

										if do_align_long_axis:
														_UpperCAmelCase				:						Tuple       						=			[self.align_long_axis(A_  ,    size=A_		) for image in images]

										if do_resize:
														_UpperCAmelCase				:						Optional[int]       						=			[self.resize(image=A_  ,    size=A_  ,    resample=A_		) for image in images]

										if do_thumbnail:
														_UpperCAmelCase				:						Optional[Any]       						=			[self.thumbnail(image=A_  ,    size=A_		) for image in images]

										if do_pad:
														_UpperCAmelCase				:						List[Any]       						=			[self.pad_image(image=A_  ,    size=A_  ,    random_padding=A_		) for image in images]

										if do_rescale:
														_UpperCAmelCase				:						Tuple       						=			[self.rescale(image=A_  ,    scale=A_		) for image in images]

										if do_normalize:
														_UpperCAmelCase				:						int       						=			[self.normalize(image=A_  ,    mean=A_  ,    std=A_		) for image in images]

										_UpperCAmelCase				:						str       						=			[to_channel_dimension_format(A_  ,    A_		) for image in images]

										_UpperCAmelCase				:						Dict       						=			{"pixel_values": images}
										return BatchFeature(data=A_  ,    tensor_type=A_		)


