






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







      '''simple docstring'''


      @staticmethod
      def 					UpperCamelCase__   (      *UpperCamelCase_:		List[Any]				,			**UpperCamelCase_:		Optional[int]					):
         pass
@is_pipeline_test
@require_torch_or_tf
@require_vision
class 						__lowerCAmelCase   (			unittest.TestCase       ):







  '''simple docstring'''


  __lowerCamelCase       :    int     	=			MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  __lowerCamelCase       :    Optional[int]     	=			TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  def 					UpperCamelCase__   (      self:		Dict				,			UpperCamelCase_:		List[Any]				,			UpperCamelCase_:		int				,			UpperCamelCase_:		Optional[Any]					):
     UpperCamelCase_     =ImageClassificationPipeline(model=UpperCamelCase_				,			image_processor=UpperCamelCase_				,			top_k=2					)
     UpperCamelCase_     =[
         Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					),
         "http://images.cocodataset.org/val2017/000000039769.jpg",
     ]
     return image_classifier, examples
  def 					UpperCamelCase__   (      self:		List[str]				,			UpperCamelCase_:		List[Any]				,			UpperCamelCase_:		str					):
     UpperCamelCase_     =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

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

     # Accepts URL + PIL.Image + lists
     UpperCamelCase_     =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 					UpperCamelCase__   (      self:		str					):
     UpperCamelCase_     ="hf-internal-testing/tiny-random-vit"
     UpperCamelCase_     =pipeline("image-classification"				,			model=UpperCamelCase_					)

     UpperCamelCase_     =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}]				,			)

     UpperCamelCase_     =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 					UpperCamelCase__   (      self:		Optional[Any]					):
     UpperCamelCase_     ="hf-internal-testing/tiny-random-vit"
     UpperCamelCase_     =pipeline("image-classification"				,			model=UpperCamelCase_				,			framework="tf"					)

     UpperCamelCase_     =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}]				,			)

     UpperCamelCase_     =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 					UpperCamelCase__   (      self:		Tuple					):
     UpperCamelCase_     =PreTrainedTokenizer()

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

     self.assertIs(image_classifier.tokenizer				,			UpperCamelCase_					)





  @slow
  @require_torch
  def 					UpperCamelCase__   (      self:		Any					):
     # 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
     UpperCamelCase_     =pipeline("image-classification"				,			model="deepmind/vision-perceiver-conv"					)
     UpperCamelCase_     =image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"					)
     self.assertEqual(
         nested_simplify(UpperCamelCase_				,			decimals=4					)				,			[
             {"score": 0.4385, "label": "tabby, tabby cat"},
             {"score": 0.321, "label": "tiger cat"},
             {"score": 0.0502, "label": "Egyptian cat"},
             {"score": 0.0137, "label": "crib, cot"},
             {"score": 0.007, "label": "radiator"},
         ]				,			)

     UpperCamelCase_     =pipeline("image-classification"				,			model="deepmind/vision-perceiver-fourier"					)
     UpperCamelCase_     =image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"					)
     self.assertEqual(
         nested_simplify(UpperCamelCase_				,			decimals=4					)				,			[
             {"score": 0.5658, "label": "tabby, tabby cat"},
             {"score": 0.1309, "label": "tiger cat"},
             {"score": 0.0722, "label": "Egyptian cat"},
             {"score": 0.0707, "label": "remote control, remote"},
             {"score": 0.0082, "label": "computer keyboard, keypad"},
         ]				,			)

     UpperCamelCase_     =pipeline("image-classification"				,			model="deepmind/vision-perceiver-learned"					)
     UpperCamelCase_     =image_classifier("http://images.cocodataset.org/val2017/000000039769.jpg"					)
     self.assertEqual(
         nested_simplify(UpperCamelCase_				,			decimals=4					)				,			[
             {"score": 0.3022, "label": "tabby, tabby cat"},
             {"score": 0.2362, "label": "Egyptian cat"},
             {"score": 0.1856, "label": "tiger cat"},
             {"score": 0.0324, "label": "remote control, remote"},
             {"score": 0.0096, "label": "quilt, comforter, comfort, puff"},
         ]				,			)








"""simple docstring"""






import unittest
from dataclasses import dataclass
from typing import List, Union

import numpy as np
import PIL.Image

from diffusers.utils.outputs import BaseOutput
@dataclass
class 						__lowerCAmelCase   (			UpperCAmelCase       ):







  '''simple docstring'''


  __lowerCamelCase       :    Union[List[PIL.Image.Image], np.ndarray]




class 						__lowerCAmelCase   (			unittest.TestCase       ):







  '''simple docstring'''


  def 					UpperCamelCase__   (      self:		Tuple					):
     UpperCamelCase_     =CustomOutput(images=np.random.rand(1				,			3				,			4				,			4					)					)

     # check every way of getting the attribute
     assert isinstance(outputs.images				,			np.ndarray					)
     assert outputs.images.shape == (1, 3, 4, 4)
     assert isinstance(outputs["images"]				,			np.ndarray					)
     assert outputs["images"].shape == (1, 3, 4, 4)
     assert isinstance(outputs[0]				,			np.ndarray					)
     assert outputs[0].shape == (1, 3, 4, 4)

     # test with a non-tensor attribute
     UpperCamelCase_     =CustomOutput(images=[PIL.Image.new("RGB"				,			(4, 4)					)]					)

     # check every way of getting the attribute
     assert isinstance(outputs.images				,			UpperCamelCase_					)
     assert isinstance(outputs.images[0]				,			PIL.Image.Image					)
     assert isinstance(outputs["images"]				,			UpperCamelCase_					)
     assert isinstance(outputs["images"][0]				,			PIL.Image.Image					)
     assert isinstance(outputs[0]				,			UpperCamelCase_					)
     assert isinstance(outputs[0][0]				,			PIL.Image.Image					)





  def 					UpperCamelCase__   (      self:		Optional[int]					):
     # test output reinitialization with a `dict` for compatibility with `accelerate`
     UpperCamelCase_     =CustomOutput({"images": np.random.rand(1				,			3				,			4				,			4					)}					)

     # check every way of getting the attribute
     assert isinstance(outputs.images				,			np.ndarray					)
     assert outputs.images.shape == (1, 3, 4, 4)
     assert isinstance(outputs["images"]				,			np.ndarray					)
     assert outputs["images"].shape == (1, 3, 4, 4)
     assert isinstance(outputs[0]				,			np.ndarray					)
     assert outputs[0].shape == (1, 3, 4, 4)

     # test with a non-tensor attribute
     UpperCamelCase_     =CustomOutput({"images": [PIL.Image.new("RGB"				,			(4, 4)					)]}					)

     # check every way of getting the attribute
     assert isinstance(outputs.images				,			UpperCamelCase_					)
     assert isinstance(outputs.images[0]				,			PIL.Image.Image					)
     assert isinstance(outputs["images"]				,			UpperCamelCase_					)
     assert isinstance(outputs["images"][0]				,			PIL.Image.Image					)
     assert isinstance(outputs[0]				,			UpperCamelCase_					)
     assert isinstance(outputs[0][0]				,			PIL.Image.Image					)
