


'''simple docstring'''







def 						_UpperCamelCase							( UpperCamelCase__     ,   UpperCamelCase__     ,   UpperCamelCase__		):






				"""simple docstring"""



				if mass < 0:
								raise ValueError("The mass of the body cannot be negative"		)
				if radius <= 0:
								raise ValueError("The radius is always a positive non zero integer"		)
				return (mass * (velocity) ** 2) / radius


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)



'''simple docstring'''







import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput






@dataclass
class 		_snake_case    (				snake_case_		):






						'''simple docstring'''







						__snake_case   =      42
						__snake_case   =      None
						__snake_case   =      None






class 		_snake_case    (				unittest.TestCase		):






						'''simple docstring'''







						def lowerCAmelCase__ (  self:	List[str]     )							->	str:
										__magic_name__				:					List[Any]						       =       ModelOutputTest(a=30     )
										self.assertEqual(x.a      ,							30     )
										self.assertIsNone(x.b     )
										self.assertIsNone(x.c     )
										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					Optional[int]						       =       x.d







						def lowerCAmelCase__ (  self:	Dict     )							->	Dict:
										__magic_name__				:					List[Any]						       =       ModelOutputTest(a=30      ,							b=10     )
										self.assertEqual(x[0]      ,							30     )
										self.assertEqual(x[1]      ,							10     )
										self.assertEqual(x[:2]      ,							(30, 10)     )
										self.assertEqual(x[:]      ,							(30, 10)     )

										__magic_name__				:					str						       =       ModelOutputTest(a=30      ,							c=10     )
										self.assertEqual(x[0]      ,							30     )
										self.assertEqual(x[1]      ,							10     )
										self.assertEqual(x[:2]      ,							(30, 10)     )
										self.assertEqual(x[:]      ,							(30, 10)     )







						def lowerCAmelCase__ (  self:	List[Any]     )							->	Optional[int]:
										__magic_name__				:					Optional[Any]						       =       ModelOutputTest(a=30      ,							b=10     )
										self.assertEqual(x["a"]      ,							30     )
										self.assertEqual(x["b"]      ,							10     )
										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					str						       =       x["c"]

										__magic_name__				:					Optional[Any]						       =       ModelOutputTest(a=30      ,							c=10     )
										self.assertEqual(x["a"]      ,							30     )
										self.assertEqual(x["c"]      ,							10     )
										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					Union[str, Any]						       =       x["b"]







						def lowerCAmelCase__ (  self:	Optional[Any]     )							->	Any:
										__magic_name__				:					Any						       =       ModelOutputTest(a=30     )
										self.assertEqual(list(x.keys()     )      ,							["a"]     )
										self.assertEqual(list(x.values()     )      ,							[30]     )
										self.assertEqual(list(x.items()     )      ,							[("a", 30)]     )
										self.assertEqual(list(__UpperCamelCase     )      ,							["a"]     )

										__magic_name__				:					Dict						       =       ModelOutputTest(a=30      ,							b=10     )
										self.assertEqual(list(x.keys()     )      ,							["a", "b"]     )
										self.assertEqual(list(x.values()     )      ,							[30, 10]     )
										self.assertEqual(list(x.items()     )      ,							[("a", 30), ("b", 10)]     )
										self.assertEqual(list(__UpperCamelCase     )      ,							["a", "b"]     )

										__magic_name__				:					int						       =       ModelOutputTest(a=30      ,							c=10     )
										self.assertEqual(list(x.keys()     )      ,							["a", "c"]     )
										self.assertEqual(list(x.values()     )      ,							[30, 10]     )
										self.assertEqual(list(x.items()     )      ,							[("a", 30), ("c", 10)]     )
										self.assertEqual(list(__UpperCamelCase     )      ,							["a", "c"]     )

										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					str						       =       x.update({"d": 20}     )
										with self.assertRaises(__UpperCamelCase     ):
														del x["a"]
										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					List[str]						       =       x.pop("a"     )
										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					Optional[Any]						       =       x.setdefault("d"      ,							32     )







						def lowerCAmelCase__ (  self:	Dict     )							->	int:
										__magic_name__				:					Any						       =       ModelOutputTest(a=30     )
										__magic_name__				:					Tuple						       =       10
										self.assertEqual(x.a      ,							10     )
										self.assertEqual(x["a"]      ,							10     )







						def lowerCAmelCase__ (  self:	Dict     )							->	Union[str, Any]:
										__magic_name__				:					Tuple						       =       ModelOutputTest(a=30     )
										__magic_name__				:					Union[str, Any]						       =       10
										self.assertEqual(x.a      ,							10     )
										self.assertEqual(x["a"]      ,							10     )







						def lowerCAmelCase__ (  self:	Optional[int]     )							->	Optional[int]:
										__magic_name__				:					Tuple						       =       ModelOutputTest({"a": 30, "b": 10}     )
										self.assertEqual(list(x.keys()     )      ,							["a", "b"]     )
										self.assertEqual(x.a      ,							30     )
										self.assertEqual(x.b      ,							10     )







						def lowerCAmelCase__ (  self:	Optional[int]     )							->	Optional[Any]:
										__magic_name__				:					List[str]						       =       ModelOutputTest([("a", 30), ("b", 10)]     )
										self.assertEqual(list(x.keys()     )      ,							["a", "b"]     )
										self.assertEqual(x.a      ,							30     )
										self.assertEqual(x.b      ,							10     )

										with self.assertRaises(__UpperCamelCase     ):
														__magic_name__				:					Any						       =       ModelOutputTest([("a", 30), (10, 10)]     )

										__magic_name__				:					Any						       =       ModelOutputTest(a=(30, 30)     )
										self.assertEqual(list(x.keys()     )      ,							["a"]     )
										self.assertEqual(x.a      ,							(30, 30)     )