





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__					:



           '''simple docstring'''

           @staticmethod
           def 							SCREAMING_SNAKE_CASE__    (				*lowerCamelCase__		:       Tuple		,**lowerCamelCase__		:       str			)	->						Dict:




                 '''simple docstring'''


                 pass

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



     '''simple docstring'''

     __snake_case       :      str						      =     MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING
     __snake_case       :      Union[str, Any]						      =     TF_MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Tuple		,lowerCamelCase__		:       Any		,lowerCamelCase__		:       str		,lowerCamelCase__		:       Optional[Any]			)	->						Any:




           '''simple docstring'''


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






     def 							SCREAMING_SNAKE_CASE__    (				self		:       Optional[Any]		,lowerCamelCase__		:       Optional[int]		,lowerCamelCase__		:       Optional[Any]			)	->						Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		image_classifier("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)

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

           import datasets

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

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






     @require_torch
     def 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		'''hf-internal-testing/tiny-random-vit'''
           SCREAMING_SNAKE_CASE						=		pipeline("""image-classification"""		,model=_lowerCamelCase			)

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

           SCREAMING_SNAKE_CASE						=		image_classifier(
               [
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
               ]		,top_k=2		,)
           self.assertEqual(
               nested_simplify(_lowerCamelCase		,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 							SCREAMING_SNAKE_CASE__    (				self		:       Tuple			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		'''hf-internal-testing/tiny-random-vit'''
           SCREAMING_SNAKE_CASE						=		pipeline("""image-classification"""		,model=_lowerCamelCase		,framework="""tf"""			)

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

           SCREAMING_SNAKE_CASE						=		image_classifier(
               [
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
                   """http://images.cocodataset.org/val2017/000000039769.jpg""",
               ]		,top_k=2		,)
           self.assertEqual(
               nested_simplify(_lowerCamelCase		,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 							SCREAMING_SNAKE_CASE__    (				self		:       Dict			)	->						Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		PreTrainedTokenizer()

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

           self.assertIs(image_classifier.tokenizer		,_lowerCamelCase			)






     @slow
     @require_torch
     def 							SCREAMING_SNAKE_CASE__    (				self		:       List[str]			)	->						List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE						=		pipeline("""image-classification"""		,model="""deepmind/vision-perceiver-conv"""			)
           SCREAMING_SNAKE_CASE						=		image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
           self.assertEqual(
               nested_simplify(_lowerCamelCase		,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"""},
               ]		,)

           SCREAMING_SNAKE_CASE						=		pipeline("""image-classification"""		,model="""deepmind/vision-perceiver-fourier"""			)
           SCREAMING_SNAKE_CASE						=		image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
           self.assertEqual(
               nested_simplify(_lowerCamelCase		,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"""},
               ]		,)

           SCREAMING_SNAKE_CASE						=		pipeline("""image-classification"""		,model="""deepmind/vision-perceiver-learned"""			)
           SCREAMING_SNAKE_CASE						=		image_classifier("""http://images.cocodataset.org/val2017/000000039769.jpg"""			)
           self.assertEqual(
               nested_simplify(_lowerCamelCase		,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"""

from __future__ import annotations

import random

from matplotlib import animation
from matplotlib import pyplot as plt

# Frame rate of the animation
_lowerCamelCase	:      int   =							20

# Time between time steps in seconds
_lowerCamelCase	:      Union[str, Any]   =							INTERVAL / 1000

class 							lowercase   :







				def __init__(				self :       Union[str, Any]   ,  _lowerCamelCase :       float   ,  _lowerCamelCase :       float   ,  _lowerCamelCase :       float   ,  _lowerCamelCase :       float   ,  _lowerCamelCase :       float = 1.0   ,  _lowerCamelCase :       float = 1.0   ,  _lowerCamelCase :       str = "blue"   ,  ):



					"""simple docstring"""

					A_	:					Union[str, Any]						 =		position_x
					A_	:					Optional[int]						 =		position_y
					A_	:					List[str]						 =		velocity_x
					A_	:					List[Any]						 =		velocity_y
					A_	:					Dict						 =		mass
					A_	:					Optional[Any]						 =		size
					A_	:					Any						 =		color







				@property
				def        a_	(				self :       Any							):



					"""simple docstring"""

					return self.position_x, self.position_y







				@property
				def        a_	(				self :       int							):



					"""simple docstring"""

					return self.velocity_x, self.velocity_y







				def        a_	(				self :       Dict   ,  _lowerCamelCase :       float   ,  _lowerCamelCase :       float   ,  _lowerCamelCase :       float							):



					"""simple docstring"""

					self.velocity_x += force_x * delta_time
					self.velocity_y += force_y * delta_time







				def        a_	(				self :       int   ,  _lowerCamelCase :       float							):



					"""simple docstring"""

					self.position_x += self.velocity_x * delta_time
					self.position_y += self.velocity_y * delta_time

class 							lowercase   :







				def __init__(				self :       Optional[Any]   ,  _lowerCamelCase :       list[Body]   ,  _lowerCamelCase :       float = 1.0   ,  _lowerCamelCase :       float = 1.0   ,  _lowerCamelCase :       float = 0.0   ,  ):



					"""simple docstring"""

					A_	:					Union[str, Any]						 =		bodies
					A_	:					Union[str, Any]						 =		gravitation_constant
					A_	:					str						 =		time_factor
					A_	:					str						 =		softening_factor







				def __len__(				self :       Dict							):



					"""simple docstring"""

					return len(self.bodies							)







				def        a_	(				self :       Dict   ,  _lowerCamelCase :       float							):



					"""simple docstring"""

					for bodya in self.bodies:
						A_	:					Tuple						 =		0.0
						A_	:					int						 =		0.0
						for bodya in self.bodies:
							if bodya != bodya:
								A_	:					Any						 =		bodya.position_x - bodya.position_x
								A_	:					Optional[int]						 =		bodya.position_y - bodya.position_y

								# Calculation of the distance using Pythagoras's theorem
								# Extra factor due to the softening technique
								A_	:					List[str]						 =		(dif_x**2 + dif_y**2 + self.softening_factor) ** (
								    1 / 2
								)

								# Newton's law of universal gravitation.
								force_x += (
								    self.gravitation_constant * bodya.mass * dif_x / distance**3
								)
								force_y += (
								    self.gravitation_constant * bodya.mass * dif_y / distance**3
								)

            # Update the body's velocity once all the force components have been added
						bodya.update_velocity(_lowerCamelCase   ,  _lowerCamelCase   ,  delta_time * self.time_factor							)

					# Update the positions only after all the velocities have been updated
					for body in self.bodies:
						body.update_position(delta_time * self.time_factor							)

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	body_system.update_system(_UpperCAmelCase						)

	# Update the positions of the patches
	for patch, body in zip(_UpperCAmelCase	,   body_system.bodies						):
		A_	:					str						 =		(body.position_x, body.position_y)

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase = -1	,   _UpperCAmelCase = 1	,   _UpperCAmelCase = -1	,   _UpperCAmelCase = 1	,   ):




	"""simple docstring"""






	A_	:					Optional[Any]						 =		plt.figure()
	fig.canvas.set_window_title(_UpperCAmelCase						)
	A_	:					Union[str, Any]						 =		plt.axes(
	    xlim=(x_start, x_end)	,   ylim=(y_start, y_end)						)  # Set section to be plotted
	plt.gca().set_aspect('''equal'''						)  # Fix aspect ratio

	# Each body is drawn as a patch by the plt-function
	A_	:					List[str]						 =		[
	    plt.Circle((body.position_x, body.position_y)	,   body.size	,   fc=body.color						)
	    for body in body_system.bodies
	]

	for patch in patches:
		ax.add_patch(_UpperCAmelCase						)

	# Function called at each step of the animation
	def update(_UpperCAmelCase						) -> list[plt.Circle]:
		update_step(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						)
		return patches

	A_	:					str						 =		animation.FuncAnimation(  # noqa: F841
	    _UpperCAmelCase	,   _UpperCAmelCase	,   interval=_UpperCAmelCase	,   blit=_UpperCAmelCase						)

	plt.show()

def 		lowercase_   (		):




	"""simple docstring"""






	A_	:					Optional[int]						 =		0.970_0436
	A_	:					Any						 =		-0.2430_8753
	A_	:					Tuple						 =		0.4_6620_3685
	A_	:					Any						 =		0.4323_6573

	A_	:					Dict						 =		[
	    Body(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase	,   size=0.2	,   color='''red'''						),
	    Body(-position_x	,   -position_y	,   _UpperCAmelCase	,   _UpperCAmelCase	,   size=0.2	,   color='''green'''						),
	    Body(0	,   0	,   -2 * velocity_x	,   -2 * velocity_y	,   size=0.2	,   color='''blue'''						),
	]
	return BodySystem(_UpperCAmelCase	,   time_factor=3						)

def 		lowercase_   (		):




	"""simple docstring"""






	A_	:					int						 =		7.3476E22
	A_	:					Optional[Any]						 =		5.972E24
	A_	:					List[Any]						 =		1022
	A_	:					Optional[int]						 =		3_8439_9000
	A_	:					Tuple						 =		6.674E-11

	# Calculation of the respective velocities so that total impulse is zero,
	# i.e. the two bodies together don't move
	A_	:					Any						 =		earth_mass * velocity_dif / (earth_mass + moon_mass)
	A_	:					List[Any]						 =		moon_velocity - velocity_dif

	A_	:					Optional[Any]						 =		Body(-earth_moon_distance	,   0	,   0	,   _UpperCAmelCase	,   _UpperCAmelCase	,   1000_0000	,   '''grey'''						)
	A_	:					List[Any]						 =		Body(0	,   0	,   0	,   _UpperCAmelCase	,   _UpperCAmelCase	,   5000_0000	,   '''blue'''						)
	return BodySystem([earth, moon]	,   _UpperCAmelCase	,   time_factor=100_0000						)

def 		lowercase_   (		):




	"""simple docstring"""






	A_	:					Union[str, Any]						 =		[]
	for _ in range(10						):
		A_	:					str						 =		random.uniform(-0.5	,   0.5						)
		A_	:					Optional[Any]						 =		random.uniform(-0.5	,   0.5						)

		# Bodies are created pairwise with opposite velocities so that the
		# total impulse remains zero
		bodies.append(
		    Body(
		        random.uniform(-0.5	,   0.5						)	,   random.uniform(-0.5	,   0.5						)	,   _UpperCAmelCase	,   _UpperCAmelCase	,   size=0.05	,   )						)
		bodies.append(
		    Body(
		        random.uniform(-0.5	,   0.5						)	,   random.uniform(-0.5	,   0.5						)	,   -velocity_x	,   -velocity_y	,   size=0.05	,   )						)
	return BodySystem(_UpperCAmelCase	,   0.01	,   10	,   0.1						)


if __name__ == "__main__":
		plot('Figure-8 solution to the 3-body-problem', example_a(), -2, 2, -2, 2)
		plot(
		    'Moon\'s orbit around the earth',
		    example_a(),
		    -430000000,
		    430000000,
		    -430000000,
		    430000000,
		)
		plot('Random system with many bodies', example_a(), -1.5, 1.5, -1.5, 1.5)





