


"""simple docstring"""







from math import pi, sqrt, tan




def      UpperCAmelCase__ (lowerCAmelCase_     ):




					'''simple docstring'''


					if side_length < 0:
										raise ValueError("surface_area_cube() only accepts non-negative values"     )
					return 6 * side_length**2




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if length < 0 or breadth < 0 or height < 0:
										raise ValueError("surface_area_cuboid() only accepts non-negative values"     )
					return 2 * ((length * breadth) + (breadth * height) + (length * height))




def      UpperCAmelCase__ (lowerCAmelCase_     ):




					'''simple docstring'''


					if radius < 0:
										raise ValueError("surface_area_sphere() only accepts non-negative values"     )
					return 4 * pi * radius**2




def      UpperCAmelCase__ (lowerCAmelCase_     ):




					'''simple docstring'''


					if radius < 0:
										raise ValueError("surface_area_hemisphere() only accepts non-negative values"     )
					return 3 * pi * radius**2




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if radius < 0 or height < 0:
										raise ValueError("surface_area_cone() only accepts non-negative values"     )
					return pi * radius * (radius + (height**2 + radius**2) ** 0.5)




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if radius_a < 0 or radius_a < 0 or height < 0:
										raise ValueError(
										    "surface_area_conical_frustum() only accepts non-negative values"     )
					__SCREAMING_SNAKE_CASE		     =       (height**2 + (radius_a - radius_a) ** 2) ** 0.5
					return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if radius < 0 or height < 0:
										raise ValueError("surface_area_cylinder() only accepts non-negative values"     )
					return 2 * pi * radius * (height + radius)




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if torus_radius < 0 or tube_radius < 0:
										raise ValueError("surface_area_torus() only accepts non-negative values"     )
					if torus_radius < tube_radius:
										raise ValueError(
										    "surface_area_torus() does not support spindle or self intersecting tori"     )
					return 4 * pow(lowerCAmelCase_						,		2     ) * torus_radius * tube_radius




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if length < 0 or width < 0:
										raise ValueError("area_rectangle() only accepts non-negative values"     )
					return length * width




def      UpperCAmelCase__ (lowerCAmelCase_     ):




					'''simple docstring'''


					if side_length < 0:
										raise ValueError("area_square() only accepts non-negative values"     )
					return side_length**2




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if base < 0 or height < 0:
										raise ValueError("area_triangle() only accepts non-negative values"     )
					return (base * height) / 2




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if sidea < 0 or sidea < 0 or sidea < 0:
										raise ValueError("area_triangle_three_sides() only accepts non-negative values"     )
					elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
										raise ValueError("Given three sides do not form a triangle"     )
					__SCREAMING_SNAKE_CASE		     =       (sidea + sidea + sidea) / 2
					__SCREAMING_SNAKE_CASE		     =       sqrt(
					    semi_perimeter
					    * (semi_perimeter - sidea)
					    * (semi_perimeter - sidea)
					    * (semi_perimeter - sidea)     )
					return area




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if base < 0 or height < 0:
										raise ValueError("area_parallelogram() only accepts non-negative values"     )
					return base * height




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if basea < 0 or basea < 0 or height < 0:
										raise ValueError("area_trapezium() only accepts non-negative values"     )
					return 1 / 2 * (basea + basea) * height




def      UpperCAmelCase__ (lowerCAmelCase_     ):




					'''simple docstring'''


					if radius < 0:
										raise ValueError("area_circle() only accepts non-negative values"     )
					return pi * radius**2




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if radius_x < 0 or radius_y < 0:
										raise ValueError("area_ellipse() only accepts non-negative values"     )
					return pi * radius_x * radius_y




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if diagonal_a < 0 or diagonal_a < 0:
										raise ValueError("area_rhombus() only accepts non-negative values"     )
					return 1 / 2 * diagonal_a * diagonal_a




def      UpperCAmelCase__ (lowerCAmelCase_						,		lowerCAmelCase_     ):




					'''simple docstring'''


					if not isinstance(lowerCAmelCase_						,		lowerCAmelCase_     ) or sides < 3:
										raise ValueError(
										    "area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides"     )
					elif length < 0:
										raise ValueError(
										    "area_reg_polygon() only accepts non-negative values as \
length of a side"     )
					return (sides * length**2) / (4 * tan(pi / sides     ))
					return (sides * length**2) / (4 * tan(pi / sides     ))


if __name__ == "__main__":
		import doctest

		doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

		print('''[DEMO] Areas of various geometric shapes: \n''')
		print(F"Rectangle: {area_rectangle(1_0, 2_0) = }")
		print(F"Square: {area_square(1_0) = }")
		print(F"Triangle: {area_triangle(1_0, 1_0) = }")
		print(F"Triangle: {area_triangle_three_sides(5, 1_2, 1_3) = }")
		print(F"Parallelogram: {area_parallelogram(1_0, 2_0) = }")
		print(F"Rhombus: {area_rhombus(1_0, 2_0) = }")
		print(F"Trapezium: {area_trapezium(1_0, 2_0, 3_0) = }")
		print(F"Circle: {area_circle(2_0) = }")
		print(F"Ellipse: {area_ellipse(1_0, 2_0) = }")
		print('''\nSurface Areas of various geometric shapes: \n''')
		print(F"Cube: {surface_area_cube(2_0) = }")
		print(F"Cuboid: {surface_area_cuboid(1_0, 2_0, 3_0) = }")
		print(F"Sphere: {surface_area_sphere(2_0) = }")
		print(F"Hemisphere: {surface_area_hemisphere(2_0) = }")
		print(F"Cone: {surface_area_cone(1_0, 2_0) = }")
		print(F"Conical Frustum: {surface_area_conical_frustum(1_0, 2_0, 3_0) = }")
		print(F"Cylinder: {surface_area_cylinder(1_0, 2_0) = }")
		print(F"Torus: {surface_area_torus(2_0, 1_0) = }")
		print(F"Equilateral Triangle: {area_reg_polygon(3, 1_0) = }")
		print(F"Square: {area_reg_polygon(4, 1_0) = }")
		print(F"Reqular Pentagon: {area_reg_polygon(5, 1_0) = }")




"""simple docstring"""







import unittest

from transformers import MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING, is_vision_available
from transformers.pipelines import pipeline
from transformers.testing_utils import (
    is_pipeline_test,
    nested_simplify,
    require_tf,
    require_torch,
    require_vision,
    slow,
)

from .test_pipelines_common import ANY


if is_vision_available():
		from PIL import Image
else:




		class 				UpperCamelCase_			:

			"""simple docstring"""





			@staticmethod
			def 						UpperCAmelCase_   (				*UpperCAmelCase__    :       List[Any]    ,    **UpperCAmelCase__    :       Optional[Any]     ) ->			Optional[int]:
								pass




@is_pipeline_test
@require_torch
@require_vision
class 				UpperCamelCase_			(				unittest.TestCase):

	"""simple docstring"""





	snake_case__       :						List[Any]					      =    MODEL_FOR_VISUAL_QUESTION_ANSWERING_MAPPING




	def 						UpperCAmelCase_   (				self    :       Dict    ,    UpperCAmelCase__    :       Tuple    ,    UpperCAmelCase__    :       List[Any]    ,    UpperCAmelCase__    :       Optional[int]     ) ->			str:
						__SCREAMING_SNAKE_CASE		     =       pipeline("visual-question-answering"    ,    model="hf-internal-testing/tiny-vilt-random-vqa"     )
						__SCREAMING_SNAKE_CASE		     =       [
						    {
						        "image": Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     ),
						        "question": "How many cats are there?",
						    },
						    {
						        "image": "./tests/fixtures/tests_samples/COCO/000000039769.png",
						        "question": "How many cats are there?",
						    },
						]
						return vqa_pipeline, examples




	def 						UpperCAmelCase_   (				self    :       Dict    ,    UpperCAmelCase__    :       List[Any]    ,    UpperCAmelCase__    :       Any     ) ->			Any:
						__SCREAMING_SNAKE_CASE		     =       vqa_pipeline(UpperCAmelCase__    ,    top_k=1     )
						self.assertEqual(
						    UpperCAmelCase__    ,    [
						        [{"score": ANY(UpperCAmelCase__     ), "answer": ANY(UpperCAmelCase__     )}],
						        [{"score": ANY(UpperCAmelCase__     ), "answer": ANY(UpperCAmelCase__     )}],
						    ]    ,    )




	@require_torch
	def 						UpperCAmelCase_   (				self    :       Optional[Any]     ) ->			int:
						__SCREAMING_SNAKE_CASE		     =       pipeline("visual-question-answering"    ,    model="hf-internal-testing/tiny-vilt-random-vqa"     )
						__SCREAMING_SNAKE_CASE		     =       "./tests/fixtures/tests_samples/COCO/000000039769.png"
						__SCREAMING_SNAKE_CASE		     =       "How many cats are there?"

						__SCREAMING_SNAKE_CASE		     =       vqa_pipeline(image=UpperCAmelCase__    ,    question="How many cats are there?"    ,    top_k=2     )
						self.assertEqual(
						    UpperCAmelCase__    ,    [{"score": ANY(UpperCAmelCase__     ), "answer": ANY(UpperCAmelCase__     )}, {"score": ANY(UpperCAmelCase__     ), "answer": ANY(UpperCAmelCase__     )}]     )

						__SCREAMING_SNAKE_CASE		     =       vqa_pipeline({"image": image, "question": question}    ,    top_k=2     )
						self.assertEqual(
						    UpperCAmelCase__    ,    [{"score": ANY(UpperCAmelCase__     ), "answer": ANY(UpperCAmelCase__     )}, {"score": ANY(UpperCAmelCase__     ), "answer": ANY(UpperCAmelCase__     )}]     )




	@slow
	@require_torch
	def 						UpperCAmelCase_   (				self    :       Tuple     ) ->			Any:
						__SCREAMING_SNAKE_CASE		     =       pipeline("visual-question-answering"    ,    model="dandelin/vilt-b32-finetuned-vqa"     )
						__SCREAMING_SNAKE_CASE		     =       "./tests/fixtures/tests_samples/COCO/000000039769.png"
						__SCREAMING_SNAKE_CASE		     =       "How many cats are there?"

						__SCREAMING_SNAKE_CASE		     =       vqa_pipeline(image=UpperCAmelCase__    ,    question=UpperCAmelCase__    ,    top_k=2     )
						self.assertEqual(
						    nested_simplify(UpperCAmelCase__    ,    decimals=4     )    ,    [{"score": 0.8_799, "answer": "2"}, {"score": 0.296, "answer": "1"}]     )

						__SCREAMING_SNAKE_CASE		     =       vqa_pipeline({"image": image, "question": question}    ,    top_k=2     )
						self.assertEqual(
						    nested_simplify(UpperCAmelCase__    ,    decimals=4     )    ,    [{"score": 0.8_799, "answer": "2"}, {"score": 0.296, "answer": "1"}]     )

						__SCREAMING_SNAKE_CASE		     =       vqa_pipeline(
						    [{"image": image, "question": question}, {"image": image, "question": question}]    ,    top_k=2     )
						self.assertEqual(
						    nested_simplify(UpperCAmelCase__    ,    decimals=4     )    ,    [[{"score": 0.8_799, "answer": "2"}, {"score": 0.296, "answer": "1"}]] * 2    ,    )




	@require_tf
	@unittest.skip("Visual question answering not implemented in TF"     )
	def 						UpperCAmelCase_   (				self    :       str     ) ->			Optional[Any]:
						pass
