




"""simple docstring"""

import argparse
import json
from pathlib import Path

import requests
import torch
from datasets import load_dataset
from huggingface_hub import hf_hub_download
from PIL import Image

from transformers import (
    BeitConfig,
    BeitForImageClassification,
    BeitForMaskedImageModeling,
    BeitForSemanticSegmentation,
    BeitImageProcessor,
)
from transformers.image_utils import PILImageResampling
from transformers.utils import logging


logging.set_verbosity_info()
_lowerCamelCase	:      Tuple   =							logging.get_logger(__name__)

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase=False	,   _UpperCAmelCase=False						):




	"""simple docstring"""






	A_	:					List[str]						 =		'''backbone.''' if is_semantic else ''''''

	A_	:					Union[str, Any]						 =		[]
	for i in range(config.num_hidden_layers						):
		# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
		rename_keys.append((f"""{prefix}blocks.{i}.norm1.weight""", f"""beit.encoder.layer.{i}.layernorm_before.weight""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.norm1.bias""", f"""beit.encoder.layer.{i}.layernorm_before.bias""")						)
		rename_keys.append(
		    (f"""{prefix}blocks.{i}.attn.proj.weight""", f"""beit.encoder.layer.{i}.attention.output.dense.weight""")						)
		rename_keys.append(
		    (f"""{prefix}blocks.{i}.attn.proj.bias""", f"""beit.encoder.layer.{i}.attention.output.dense.bias""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.norm2.weight""", f"""beit.encoder.layer.{i}.layernorm_after.weight""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.norm2.bias""", f"""beit.encoder.layer.{i}.layernorm_after.bias""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc1.weight""", f"""beit.encoder.layer.{i}.intermediate.dense.weight""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc1.bias""", f"""beit.encoder.layer.{i}.intermediate.dense.bias""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc2.weight""", f"""beit.encoder.layer.{i}.output.dense.weight""")						)
		rename_keys.append((f"""{prefix}blocks.{i}.mlp.fc2.bias""", f"""beit.encoder.layer.{i}.output.dense.bias""")						)

	# projection layer + position embeddings
	rename_keys.extend(
	    [
	        (f"""{prefix}cls_token""", '''beit.embeddings.cls_token'''),
	        (f"""{prefix}patch_embed.proj.weight""", '''beit.embeddings.patch_embeddings.projection.weight'''),
	        (f"""{prefix}patch_embed.proj.bias""", '''beit.embeddings.patch_embeddings.projection.bias'''),
	    ]						)

	if has_lm_head:
		# mask token + shared relative position bias + layernorm
		rename_keys.extend(
		    [
		        ('''mask_token''', '''beit.embeddings.mask_token'''),
		        (
		            '''rel_pos_bias.relative_position_bias_table''',
		            '''beit.encoder.relative_position_bias.relative_position_bias_table''',
		        ),
		        (
		            '''rel_pos_bias.relative_position_index''',
		            '''beit.encoder.relative_position_bias.relative_position_index''',
		        ),
		        ('''norm.weight''', '''layernorm.weight'''),
		        ('''norm.bias''', '''layernorm.bias'''),
		    ]						)
	elif is_semantic:
		# semantic segmentation classification heads
		rename_keys.extend(
		    [
		        ('''decode_head.conv_seg.weight''', '''decode_head.classifier.weight'''),
		        ('''decode_head.conv_seg.bias''', '''decode_head.classifier.bias'''),
		        ('''auxiliary_head.conv_seg.weight''', '''auxiliary_head.classifier.weight'''),
		        ('''auxiliary_head.conv_seg.bias''', '''auxiliary_head.classifier.bias'''),
		    ]						)
	else:
		# layernorm + classification head
		rename_keys.extend(
		    [
		        ('''fc_norm.weight''', '''beit.pooler.layernorm.weight'''),
		        ('''fc_norm.bias''', '''beit.pooler.layernorm.bias'''),
		        ('''head.weight''', '''classifier.weight'''),
		        ('''head.bias''', '''classifier.bias'''),
		    ]						)

	return rename_keys

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase=False	,   _UpperCAmelCase=False						):




	"""simple docstring"""






	for i in range(config.num_hidden_layers						):
		A_	:					List[str]						 =		'''backbone.''' if is_semantic else ''''''
		# queries, keys and values
		A_	:					List[str]						 =		state_dict.pop(f"""{prefix}blocks.{i}.attn.qkv.weight"""						)
		A_	:					Any						 =		state_dict.pop(f"""{prefix}blocks.{i}.attn.q_bias"""						)
		A_	:					Any						 =		state_dict.pop(f"""{prefix}blocks.{i}.attn.v_bias"""						)

		A_	:					List[Any]						 =		in_proj_weight[
		    : config.hidden_size, :
		]
		A_	:					Optional[int]						 =		q_bias
		A_	:					Dict						 =		in_proj_weight[
		    config.hidden_size : config.hidden_size * 2, :
		]
		A_	:					List[Any]						 =		in_proj_weight[
		    -config.hidden_size :, :
		]
		A_	:					Optional[Any]						 =		v_bias

		# gamma_1 and gamma_2
		# we call them lambda because otherwise they are renamed when using .from_pretrained
		A_	:					Tuple						 =		state_dict.pop(f"""{prefix}blocks.{i}.gamma_1"""						)
		A_	:					List[Any]						 =		state_dict.pop(f"""{prefix}blocks.{i}.gamma_2"""						)

		A_	:					Optional[Any]						 =		gamma_a
		A_	:					Tuple						 =		gamma_a

		# relative_position bias table + index
		if not has_lm_head:
			# each layer has its own relative position bias
			A_	:					Dict						 =		state_dict.pop(f"""{prefix}blocks.{i}.attn.relative_position_bias_table"""						)
			A_	:					Tuple						 =		state_dict.pop(f"""{prefix}blocks.{i}.attn.relative_position_index"""						)

			A_	:					List[Any]						 =		table
			A_	:					List[str]						 =		index

def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	A_	:					List[str]						 =		dct.pop(_UpperCAmelCase						)
	A_	:					Optional[int]						 =		val

def 		lowercase_   (		):




	"""simple docstring"""






	A_	:					Any						 =		'''http://images.cocodataset.org/val2017/000000039769.jpg'''
	A_	:					List[str]						 =		Image.open(requests.get(_UpperCAmelCase	,   stream=_UpperCAmelCase						).raw						)
	return im

@torch.no_grad()
def 		lowercase_   (		_UpperCAmelCase	,   _UpperCAmelCase						):




	"""simple docstring"""






	A_	:					str						 =		BeitConfig()
	A_	:					str						 =		False
	A_	:					List[str]						 =		False
	A_	:					int						 =		'''huggingface/label-files'''
	# set config parameters based on URL
	if checkpoint_url[-9:-4] == "pt22k":
		# masked image modeling
		A_	:					Optional[int]						 =		True
		A_	:					Optional[int]						 =		True
		A_	:					List[Any]						 =		True
	elif checkpoint_url[-9:-4] == "ft22k":
		# intermediate fine-tuning on ImageNet-22k
		A_	:					Optional[Any]						 =		True
		A_	:					Optional[Any]						 =		2_1841
		A_	:					Optional[Any]						 =		'''imagenet-22k-id2label.json'''
		A_	:					Tuple						 =		json.load(open(hf_hub_download(_UpperCAmelCase	,   _UpperCAmelCase	,   repo_type='''dataset'''						)	,   '''r'''						)						)
		A_	:					List[Any]						 =		{int(_UpperCAmelCase						): v for k, v in idalabel.items()}
		# this dataset contains 21843 labels but the model only has 21841
		# we delete the classes as mentioned in https://github.com/google-research/big_transfer/issues/18
		del idalabel[9205]
		del idalabel[1_5027]
		A_	:					List[Any]						 =		idalabel
		A_	:					Optional[Any]						 =		{v: k for k, v in idalabel.items()}
	elif checkpoint_url[-8:-4] == "to1k":
		# fine-tuning on ImageNet-1k
		A_	:					Optional[int]						 =		True
		A_	:					Tuple						 =		1000
		A_	:					str						 =		'''imagenet-1k-id2label.json'''
		A_	:					Optional[Any]						 =		json.load(open(hf_hub_download(_UpperCAmelCase	,   _UpperCAmelCase	,   repo_type='''dataset'''						)	,   '''r'''						)						)
		A_	:					Any						 =		{int(_UpperCAmelCase						): v for k, v in idalabel.items()}
		A_	:					List[Any]						 =		idalabel
		A_	:					int						 =		{v: k for k, v in idalabel.items()}
		if "384" in checkpoint_url:
			A_	:					List[Any]						 =		384
		if "512" in checkpoint_url:
			A_	:					List[Any]						 =		512
	elif "ade20k" in checkpoint_url:
		# fine-tuning
		A_	:					List[str]						 =		True
		A_	:					List[str]						 =		150
		A_	:					Dict						 =		'''ade20k-id2label.json'''
		A_	:					Optional[Any]						 =		json.load(open(hf_hub_download(_UpperCAmelCase	,   _UpperCAmelCase	,   repo_type='''dataset'''						)	,   '''r'''						)						)
		A_	:					Any						 =		{int(_UpperCAmelCase						): v for k, v in idalabel.items()}
		A_	:					List[str]						 =		idalabel
		A_	:					Dict						 =		{v: k for k, v in idalabel.items()}
		A_	:					int						 =		640
		A_	:					Any						 =		True
	else:
		raise ValueError('''Checkpoint not supported, URL should either end with \'pt22k\', \'ft22k\', \'to1k\' or \'ade20k\''''						)

	# size of the architecture
	if "base" in checkpoint_url:
		pass
	elif "large" in checkpoint_url:
		A_	:					Optional[int]						 =		1024
		A_	:					Optional[int]						 =		4096
		A_	:					List[str]						 =		24
		A_	:					Union[str, Any]						 =		16
		if "ade20k" in checkpoint_url:
			A_	:					List[str]						 =		640
			A_	:					Optional[int]						 =		[7, 11, 15, 23]
	else:
		raise ValueError('''Should either find \'base\' or \'large\' in checkpoint URL'''						)

	# load state_dict of original model, remove and rename some keys
	A_	:					Tuple						 =		torch.hub.load_state_dict_from_url(_UpperCAmelCase	,   map_location='''cpu'''	,   check_hash=_UpperCAmelCase						)
	A_	:					str						 =		state_dict['''model'''] if '''ade20k''' not in checkpoint_url else state_dict['''state_dict''']

	A_	:					Optional[int]						 =		create_rename_keys(_UpperCAmelCase	,   has_lm_head=_UpperCAmelCase	,   is_semantic=_UpperCAmelCase						)
	for src, dest in rename_keys:
		rename_key(_UpperCAmelCase	,   _UpperCAmelCase	,   _UpperCAmelCase						)
	read_in_q_k_v(_UpperCAmelCase	,   _UpperCAmelCase	,   has_lm_head=_UpperCAmelCase	,   is_semantic=_UpperCAmelCase						)
	if is_semantic:
		# add prefix to decoder keys
		for key, val in state_dict.copy().items():
			A_	:					List[str]						 =		state_dict.pop(_UpperCAmelCase						)
			if key.startswith('''backbone.fpn'''						):
				A_	:					int						 =		key.replace('''backbone.fpn'''	,   '''fpn'''						)
			A_	:					Tuple						 =		val

    # load HuggingFace model
	if checkpoint_url[-9:-4] == "pt22k":
		A_	:					List[Any]						 =		BeitForMaskedImageModeling(_UpperCAmelCase						)
	elif "ade20k" in checkpoint_url:
		A_	:					Optional[int]						 =		BeitForSemanticSegmentation(_UpperCAmelCase						)
	else:
		A_	:					Optional[int]						 =		BeitForImageClassification(_UpperCAmelCase						)
	model.eval()
	model.load_state_dict(_UpperCAmelCase						)

	# Check outputs on an image
	if is_semantic:
		A_	:					List[str]						 =		BeitImageProcessor(size=config.image_size	,   do_center_crop=_UpperCAmelCase						)
		A_	:					str						 =		load_dataset('''hf-internal-testing/fixtures_ade20k'''	,   split='''test'''						)
		A_	:					List[Any]						 =		Image.open(ds[0]['''file''']						)
	else:
		A_	:					Tuple						 =		BeitImageProcessor(
		    size=config.image_size	,   resample=PILImageResampling.BILINEAR	,   do_center_crop=_UpperCAmelCase						)
		A_	:					Optional[int]						 =		prepare_img()

	A_	:					Any						 =		image_processor(images=_UpperCAmelCase	,   return_tensors='''pt'''						)
	A_	:					Optional[Any]						 =		encoding['''pixel_values''']

	A_	:					Union[str, Any]						 =		model(_UpperCAmelCase						)
	A_	:					List[Any]						 =		outputs.logits

	# verify logits
	A_	:					Dict						 =		torch.Size([1, 1000]						)
	if checkpoint_url[:-4].endswith('''beit_base_patch16_224_pt22k'''						):
		A_	:					Tuple						 =		torch.Size([1, 196, 8192]						)
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_224_pt22k'''						):
		A_	:					Any						 =		torch.Size([1, 196, 8192]						)
	elif checkpoint_url[:-4].endswith('''beit_base_patch16_224_pt22k_ft22k'''						):
		A_	:					Optional[int]						 =		torch.Size([1, 2_1841]						)
		A_	:					Optional[int]						 =		torch.tensor([2.2288, 2.4671, 0.7395]						)
		A_	:					Union[str, Any]						 =		2397
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_224_pt22k_ft22k'''						):
		A_	:					Any						 =		torch.Size([1, 2_1841]						)
		A_	:					List[Any]						 =		torch.tensor([1.6881, -0.2787, 0.5901]						)
		A_	:					int						 =		2396
	elif checkpoint_url[:-4].endswith('''beit_base_patch16_224_pt22k_ft1k'''						):
		A_	:					int						 =		torch.tensor([0.1241, 0.0798, -0.6569]						)
		A_	:					Any						 =		285
	elif checkpoint_url[:-4].endswith('''beit_base_patch16_224_pt22k_ft22kto1k'''						):
		A_	:					Union[str, Any]						 =		torch.tensor([-1.2385, -1.0987, -1.0108]						)
		A_	:					Dict						 =		281
	elif checkpoint_url[:-4].endswith('''beit_base_patch16_384_pt22k_ft22kto1k'''						):
		A_	:					str						 =		torch.tensor([-1.5303, -0.9484, -0.3147]						)
		A_	:					Tuple						 =		761
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_224_pt22k_ft1k'''						):
		A_	:					Union[str, Any]						 =		torch.tensor([0.4610, -0.0928, 0.2086]						)
		A_	:					Any						 =		761
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_224_pt22k_ft22kto1k'''						):
		A_	:					List[str]						 =		torch.tensor([-0.4804, 0.6257, -0.1837]						)
		A_	:					Optional[int]						 =		761
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_384_pt22k_ft22kto1k'''						):
		A_	:					int						 =		torch.tensor([[-0.5122, 0.5117, -0.2113]]						)
		A_	:					Tuple						 =		761
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_512_pt22k_ft22kto1k'''						):
		A_	:					str						 =		torch.tensor([-0.3062, 0.7261, 0.4852]						)
		A_	:					Optional[Any]						 =		761
	elif checkpoint_url[:-4].endswith('''beit_base_patch16_640_pt22k_ft22ktoade20k'''						):
		A_	:					Tuple						 =		(1, 150, 160, 160)
		A_	:					List[Any]						 =		torch.tensor(
		    [
		        [[-4.9225, -2.3954, -3.0522], [-2.8822, -1.0046, -1.7561], [-2.9549, -1.3228, -2.1347]],
		        [[-5.8168, -3.4129, -4.0778], [-3.8651, -2.2214, -3.0277], [-3.8356, -2.4643, -3.3535]],
		        [[-0.0078, 3.9952, 4.0754], [2.9856, 4.6944, 5.0035], [3.2413, 4.7813, 4.9969]],
		    ]						)
	elif checkpoint_url[:-4].endswith('''beit_large_patch16_640_pt22k_ft22ktoade20k'''						):
		A_	:					str						 =		(1, 150, 160, 160)
		A_	:					Optional[Any]						 =		torch.tensor(
		    [
		        [[-4.3305, -2.3049, -3.0161], [-2.9591, -1.5305, -2.2251], [-3.4198, -1.8004, -2.9062]],
		        [[-5.8922, -3.7435, -4.3978], [-4.2063, -2.7872, -3.4755], [-4.2791, -3.1874, -4.1681]],
		        [[0.9895, 4.3467, 4.7663], [4.2476, 5.6830, 6.1518], [4.5550, 6.2495, 6.5154]],
		    ]						)
	else:
		raise ValueError('''Can\'t verify logits as model is not supported'''						)

	assert logits.shape == expected_shape, "Shape of logits not as expected"
	if not has_lm_head:
		if is_semantic:
			assert torch.allclose(
			    logits[0, :3, :3, :3]	,   _UpperCAmelCase	,   atol=1E-3						), "First elements of logits not as expected"
		else:
			print('''Predicted class idx:'''	,   logits.argmax(-1						).item()						)
			assert torch.allclose(
			    logits[0, :3]	,   _UpperCAmelCase	,   atol=1E-3						), "First elements of logits not as expected"
			assert logits.argmax(-1						).item() == expected_class_idx, "Predicted class index not as expected"

	Path(_UpperCAmelCase						).mkdir(exist_ok=_UpperCAmelCase						)
	print(f"""Saving model to {pytorch_dump_folder_path}"""						)
	model.save_pretrained(_UpperCAmelCase						)
	print(f"""Saving image processor to {pytorch_dump_folder_path}"""						)
	image_processor.save_pretrained(_UpperCAmelCase						)


if __name__ == "__main__":
		_lowerCamelCase	:      Any   =							argparse.ArgumentParser()

		parser.add_argument(
		    '--checkpoint_url',
		    default='https://conversationhub.blob.core.windows.net/beit-share-public/beit/beit_base_patch16_224_pt22k_ft22kto1k.pth',
		    type=str,
		    help='URL to the original PyTorch checkpoint (.pth file).',
		)
		parser.add_argument(
		    '--pytorch_dump_folder_path', default=None, type=str, help='Path to the folder to output PyTorch model.'
		)
		_lowerCamelCase	:      str   =							parser.parse_args()
		convert_beit_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path)











"""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)





