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        UpperCAmelCase__  :
  
  
  
  		@staticmethod
  		def    __lowerCamelCase				(  *lowercase		,	**lowercase			)  ->							Union[str, Any]:
  			pass
  @is_pipeline_test
  @require_torch_or_tf
  @require_vision
  class        UpperCAmelCase__  (    unittest.TestCase):
  	__SCREAMING_SNAKE_CASE					      =				MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  	__SCREAMING_SNAKE_CASE					      =				TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
  
  
  
  	def    __lowerCamelCase				(  self		,	lowercase		,	lowercase		,	lowercase			)  ->							int:
  		__UpperCamelCase				      =  ImageClassificationPipeline(model=SCREAMING_SNAKE_CASE_		,	image_processor=SCREAMING_SNAKE_CASE_		,	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    __lowerCamelCase				(  self		,	lowercase		,	lowercase			)  ->							Dict:
  		__UpperCamelCase				      =  image_classifier("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
  
  		self.assertEqual(
  		    SCREAMING_SNAKE_CASE_		,	[
  		        {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		        {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		    ]		,	)
  
  		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(
  		    SCREAMING_SNAKE_CASE_		,	[
  		        [
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		        ],
  		        [
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		        ],
  		        [
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		        ],
  		        [
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		        ],
  		        [
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		            {"""score""": ANY(SCREAMING_SNAKE_CASE_			), """label""": ANY(SCREAMING_SNAKE_CASE_			)},
  		        ],
  		    ]		,	)
  
  
  
  	@require_torch
  	def    __lowerCamelCase				(  self			)  ->							Optional[int]:
  		__UpperCamelCase				      =  """hf-internal-testing/tiny-random-vit"""
  		__UpperCamelCase				      =  pipeline("""image-classification"""		,	model=SCREAMING_SNAKE_CASE_			)
  
  		__UpperCamelCase				      =  image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
  		self.assertEqual(
  		    nested_simplify(SCREAMING_SNAKE_CASE_		,	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(SCREAMING_SNAKE_CASE_		,	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			)  ->							Dict:
  		__UpperCamelCase				      =  """hf-internal-testing/tiny-random-vit"""
  		__UpperCamelCase				      =  pipeline("""image-classification"""		,	model=SCREAMING_SNAKE_CASE_		,	framework="""tf"""			)
  
  		__UpperCamelCase				      =  image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
  		self.assertEqual(
  		    nested_simplify(SCREAMING_SNAKE_CASE_		,	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(SCREAMING_SNAKE_CASE_		,	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			)  ->							List[Any]:
  		__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=SCREAMING_SNAKE_CASE_			)
  
  		self.assertIs(image_classifier.tokenizer		,	SCREAMING_SNAKE_CASE_			)
  
  
  
  
  	@slow
  	@require_torch
  	def    __lowerCamelCase				(  self			)  ->							List[str]:
  		# 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(SCREAMING_SNAKE_CASE_		,	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"""},
  		    ]		,	)
  
  		__UpperCamelCase				      =  pipeline("""image-classification"""		,	model="""deepmind/vision-perceiver-fourier"""			)
  		__UpperCamelCase				      =  image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
  		self.assertEqual(
  		    nested_simplify(SCREAMING_SNAKE_CASE_		,	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"""},
  		    ]		,	)
  
  		__UpperCamelCase				      =  pipeline("""image-classification"""		,	model="""deepmind/vision-perceiver-learned"""			)
  		__UpperCamelCase				      =  image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
  		self.assertEqual(
  		    nested_simplify(SCREAMING_SNAKE_CASE_		,	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"""},
  		    ]		,	)
  
  
  
  
  
  
style_context: 
  
  
  
  '''simple docstring'''
  
  
  
  def _lowercase   (  __A							,__A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  1
   while b > 0:
    if b & 1:
     res *= a
  
    a *= a
    b >>= 1
  
   return res
  
  
  
  
  
  
  
  def _lowercase   (  __A							,__A							,__A       ):
  
  
  
   '''simple docstring'''
  
  
  
   __UpperCamelCase				      =  1
   while b > 0:
    if b & 1:
     __UpperCamelCase				      =  ((res % c) * (a % c)) % c
  
    a *= a
    b >>= 1
  
   return res
  
  
  
  
  
  