code: 
  
  
  
  
  
  
  """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"},
           ]				,			)
  
style_context: 
  
  
  
  
  
  
  """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					)
  