code: 
  
  
  
  '''simple docstring'''
  
  
  
  
  
  import unittest
  
  import numpy as np
  
  from transformers.testing_utils import require_torch, require_vision
  from transformers.utils import is_torch_available, is_vision_available
  
  from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs
  
  
  if is_torch_available():
      import torch
  
  if is_vision_available():
      from PIL import Image
  
      from transformers import OwlViTImageProcessor
  
  
  
  class        lowerCAmelCase_	(						unittest.TestCase							):
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_=7,    SCREAMING_SNAKE_CASE_=3,    SCREAMING_SNAKE_CASE_=18,    SCREAMING_SNAKE_CASE_=30,    SCREAMING_SNAKE_CASE_=400,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=None,    SCREAMING_SNAKE_CASE_=True,    SCREAMING_SNAKE_CASE_=[0.48_14_54_66, 0.4_57_82_75, 0.40_82_10_73],    SCREAMING_SNAKE_CASE_=[0.26_86_29_54, 0.26_13_02_58, 0.27_57_77_11],    SCREAMING_SNAKE_CASE_=True,    )  ->	List[str]:
            UpperCamelCase					:						Optional[int]					=			parent
            UpperCamelCase					:						Optional[Any]					=			batch_size
            UpperCamelCase					:						Tuple					=			num_channels
            UpperCamelCase					:						List[Any]					=			image_size
            UpperCamelCase					:						Any					=			min_resolution
            UpperCamelCase					:						Dict					=			max_resolution
            UpperCamelCase					:						Optional[Any]					=			do_resize
            UpperCamelCase					:						str					=			size if size is not None else {'height': 18, 'width': 18}
            UpperCamelCase					:						List[str]					=			do_center_crop
            UpperCamelCase					:						List[Any]					=			crop_size if crop_size is not None else {'height': 18, 'width': 18}
            UpperCamelCase					:						int					=			do_normalize
            UpperCamelCase					:						int					=			image_mean
            UpperCamelCase					:						Optional[int]					=			image_std
            UpperCamelCase					:						Union[str, Any]					=			do_convert_rgb
  
  
  
  
  
  
         def       snake_case_ (    self )  ->	int:
            return {
                "do_resize": self.do_resize,
                "size": self.size,
                "do_center_crop": self.do_center_crop,
                "crop_size": self.crop_size,
                "do_normalize": self.do_normalize,
                "image_mean": self.image_mean,
                "image_std": self.image_std,
                "do_convert_rgb": self.do_convert_rgb,
            }
  
  
  
  
  
  
  @require_torch
  @require_vision
  class        lowerCAmelCase_	(						a__ ,					unittest.TestCase							):
         UpperCAmelCase__       :      List[Any]       =						OwlViTImageProcessor if is_vision_available() else None
         def       snake_case_ (    self )  ->	Union[str, Any]:
            UpperCamelCase					:						Union[str, Any]					=			OwlViTImageProcessingTester(self )
         @property
         def       snake_case_ (    self )  ->	int:
            return self.image_processor_tester.prepare_image_processor_dict()
         def       snake_case_ (    self )  ->	Union[str, Any]:
            UpperCamelCase					:						Optional[Any]					=			self.image_processing_class(**self.image_processor_dict )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'do_resize' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'size' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'do_center_crop' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'center_crop' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'do_normalize' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'image_mean' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'image_std' ) )
            self.assertTrue(hasattr(SCREAMING_SNAKE_CASE_,    'do_convert_rgb' ) )
         def       snake_case_ (    self )  ->	str:
            UpperCamelCase					:						Tuple					=			self.image_processing_class.from_dict(self.image_processor_dict )
            self.assertEqual(image_processor.size,    {'height': 18, 'width': 18} )
            self.assertEqual(image_processor.crop_size,    {'height': 18, 'width': 18} )
  
            UpperCamelCase					:						Optional[Any]					=			self.image_processing_class.from_dict(self.image_processor_dict,    size=42,    crop_size=84 )
            self.assertEqual(image_processor.size,    {'height': 42, 'width': 42} )
            self.assertEqual(image_processor.crop_size,    {'height': 84, 'width': 84} )
         def       snake_case_ (    self )  ->	str:
            # Initialize image_processing
            UpperCamelCase					:						Optional[int]					=			self.image_processing_class(**self.image_processor_dict )
            # create random PIL images
            UpperCamelCase					:						int					=			prepare_image_inputs(self.image_processor_tester,    equal_resolution=SCREAMING_SNAKE_CASE_ )
  
            for image in image_inputs:
               self.assertIsInstance(SCREAMING_SNAKE_CASE_,    Image.Image )
  
            # Test not batched input
            UpperCamelCase					:						str					=			image_processing(image_inputs[0],    return_tensors='pt' ).pixel_values
            self.assertEqual(
                encoded_images.shape,    (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),    )
  
            # Test batched
            UpperCamelCase					:						Optional[int]					=			image_processing(SCREAMING_SNAKE_CASE_,    return_tensors='pt' ).pixel_values
            self.assertEqual(
                encoded_images.shape,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),    )
         def       snake_case_ (    self )  ->	str:
            # Initialize image_processing
            UpperCamelCase					:						Optional[Any]					=			self.image_processing_class(**self.image_processor_dict )
            # create random numpy tensors
            UpperCamelCase					:						Optional[Any]					=			prepare_image_inputs(self.image_processor_tester,    equal_resolution=SCREAMING_SNAKE_CASE_,    numpify=SCREAMING_SNAKE_CASE_ )
            for image in image_inputs:
               self.assertIsInstance(SCREAMING_SNAKE_CASE_,    np.ndarray )
  
            # Test not batched input
            UpperCamelCase					:						Optional[Any]					=			image_processing(image_inputs[0],    return_tensors='pt' ).pixel_values
            self.assertEqual(
                encoded_images.shape,    (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),    )
  
            # Test batched
            UpperCamelCase					:						Union[str, Any]					=			image_processing(SCREAMING_SNAKE_CASE_,    return_tensors='pt' ).pixel_values
            self.assertEqual(
                encoded_images.shape,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),    )
  
  
  
  
  
  
         def       snake_case_ (    self )  ->	List[Any]:
            # Initialize image_processing
            UpperCamelCase					:						str					=			self.image_processing_class(**self.image_processor_dict )
            # create random PyTorch tensors
            UpperCamelCase					:						int					=			prepare_image_inputs(self.image_processor_tester,    equal_resolution=SCREAMING_SNAKE_CASE_,    torchify=SCREAMING_SNAKE_CASE_ )
            for image in image_inputs:
               self.assertIsInstance(SCREAMING_SNAKE_CASE_,    torch.Tensor )
  
            # Test not batched input
            UpperCamelCase					:						Any					=			image_processing(image_inputs[0],    return_tensors='pt' ).pixel_values
            self.assertEqual(
                encoded_images.shape,    (
                    1,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),    )
  
            # Test batched
            UpperCamelCase					:						Optional[Any]					=			image_processing(SCREAMING_SNAKE_CASE_,    return_tensors='pt' ).pixel_values
            self.assertEqual(
                encoded_images.shape,    (
                    self.image_processor_tester.batch_size,
                    self.image_processor_tester.num_channels,
                    self.image_processor_tester.crop_size['height'],
                    self.image_processor_tester.crop_size['width'],
                ),    )
  
  
  
  
style_context: 
  
  
  
  from __future__ import annotations
  
  import random
  
  from matplotlib import animation
  from matplotlib import pyplot as plt
  
  # Frame rate of the animation
  __UpperCAmelCase      = 20
  
  # Time between time steps in seconds
  __UpperCAmelCase      = INTERVAL / 1_000
  
  
  
  class        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = "blue",    )  ->	None:
            UpperCamelCase					:						int					=			position_x
            UpperCamelCase					:						List[Any]					=			position_y
            UpperCamelCase					:						Tuple					=			velocity_x
            UpperCamelCase					:						Optional[Any]					=			velocity_y
            UpperCamelCase					:						Optional[Any]					=			mass
            UpperCamelCase					:						Union[str, Any]					=			size
            UpperCamelCase					:						Any					=			color
         @property
         def       snake_case_ (    self )  ->	tuple[float, float]:
            return self.position_x, self.position_y
         @property
         def       snake_case_ (    self )  ->	tuple[float, float]:
            return self.velocity_x, self.velocity_y
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ )  ->	None:
            self.velocity_x += force_x * delta_time
            self.velocity_y += force_y * delta_time
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	None:
            self.position_x += self.velocity_x * delta_time
            self.position_y += self.velocity_y * delta_time
  
  
  
  
  
  
  class        lowerCAmelCase_	:
         def __init__(    self,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = 1.0,    SCREAMING_SNAKE_CASE_ = 0.0,    )  ->	None:
            UpperCamelCase					:						Tuple					=			bodies
            UpperCamelCase					:						Tuple					=			gravitation_constant
            UpperCamelCase					:						Any					=			time_factor
            UpperCamelCase					:						Any					=			softening_factor
         def __len__(    self )  ->	int:
            return len(self.bodies )
  
  
  
  
  
  
         def       snake_case_ (    self,    SCREAMING_SNAKE_CASE_ )  ->	None:
            for bodya in self.bodies:
               UpperCamelCase					:						Optional[Any]					=			0.0
               UpperCamelCase					:						str					=			0.0
               for bodya in self.bodies:
                  if bodya != bodya:
                     UpperCamelCase					:						List[str]					=			bodya.position_x - bodya.position_x
                     UpperCamelCase					:						Union[str, Any]					=			bodya.position_y - bodya.position_y
  
                     # Calculation of the distance using Pythagoras's theorem
                     # Extra factor due to the softening technique
                     UpperCamelCase					:						Dict					=			(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(SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    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 	UpperCamelCase			(     snake_case__ :					BodySystem ,  snake_case__ :					float ,  snake_case__ :					list[plt.Circle]			)			->  None:
     body_system.update_system(snake_case__			)
  
     # Update the positions of the patches
     for patch, body in zip(snake_case__ ,  body_system.bodies			):
        UpperCamelCase					:						List[str]					=			(body.position_x, body.position_y)
  def 	UpperCamelCase			(     snake_case__ :					str ,  snake_case__ :					BodySystem ,  snake_case__ :					float = -1 ,  snake_case__ :					float = 1 ,  snake_case__ :					float = -1 ,  snake_case__ :					float = 1 ,  )			->  None:
     UpperCamelCase					:						Dict					=			plt.figure()
     fig.canvas.set_window_title(snake_case__			)
     UpperCamelCase					:						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
     UpperCamelCase					:						List[Any]					=			[
         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(snake_case__			)
  
     # Function called at each step of the animation
     def update(snake_case__ :					int			) -> list[plt.Circle]:
        update_step(snake_case__ ,  snake_case__ ,  snake_case__			)
        return patches
  
     UpperCamelCase					:						Dict					=			animation.FuncAnimation(  # noqa: F841
         snake_case__ ,  snake_case__ ,  interval=snake_case__ ,  blit=snake_case__			)
  
     plt.show()
  def 	UpperCamelCase			(     )			->  BodySystem:
     UpperCamelCase					:						str					=			0.9700436
     UpperCamelCase					:						Optional[Any]					=			-0.24308753
     UpperCamelCase					:						Optional[int]					=			0.466203685
     UpperCamelCase					:						int					=			0.43236573
  
     UpperCamelCase					:						int					=			[
         Body(snake_case__ ,  snake_case__ ,  snake_case__ ,  snake_case__ ,  size=0.2 ,  color='red'			),
         Body(-position_x ,  -position_y ,  snake_case__ ,  snake_case__ ,  size=0.2 ,  color='green'			),
         Body(0 ,  0 ,  -2 * velocity_x ,  -2 * velocity_y ,  size=0.2 ,  color='blue'			),
     ]
     return BodySystem(snake_case__ ,  time_factor=3			)
  def 	UpperCamelCase			(     )			->  BodySystem:
     UpperCamelCase					:						str					=			7.3_476E22
     UpperCamelCase					:						str					=			5.972E24
     UpperCamelCase					:						Union[str, Any]					=			1022
     UpperCamelCase					:						Optional[Any]					=			384399000
     UpperCamelCase					:						str					=			6.674E-11
  
     # Calculation of the respective velocities so that total impulse is zero,
     # i.e. the two bodies together don't move
     UpperCamelCase					:						int					=			earth_mass * velocity_dif / (earth_mass + moon_mass)
     UpperCamelCase					:						str					=			moon_velocity - velocity_dif
  
     UpperCamelCase					:						Optional[int]					=			Body(-earth_moon_distance ,  0 ,  0 ,  snake_case__ ,  snake_case__ ,  10000000 ,  'grey'			)
     UpperCamelCase					:						Dict					=			Body(0 ,  0 ,  0 ,  snake_case__ ,  snake_case__ ,  50000000 ,  'blue'			)
     return BodySystem([earth, moon] ,  snake_case__ ,  time_factor=1000000			)
  def 	UpperCamelCase			(     )			->  BodySystem:
     UpperCamelCase					:						int					=			[]
     for _ in range(10			):
        UpperCamelCase					:						Optional[int]					=			random.uniform(-0.5 ,  0.5			)
        UpperCamelCase					:						Union[str, 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			) ,  snake_case__ ,  snake_case__ ,  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(snake_case__ ,  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(),
          -430_000_000,
          430_000_000,
          -430_000_000,
          430_000_000,
      )
      plot('''Random system with many bodies''', example_a(), -1.5, 1.5, -1.5, 1.5)
  
  
  
  