


'''simple docstring'''
import inspect
import unittest
from typing import List

import numpy as np

from transformers import EfficientFormerConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers import (
     TFEfficientFormerForImageClassification,
     TFEfficientFormerForImageClassificationWithTeacher,
     TFEfficientFormerModel,
 )
 from transformers.models.efficientformer.modeling_tf_efficientformer import (
     TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST,
 )


if is_vision_available():
 from PIL import Image

 from transformers import EfficientFormerImageProcessor

class 						_lowerCamelCase					:




 '''simple docstring'''


 def __init__(      self      ,      __lowercase      ,      __lowercase = 13      ,      __lowercase = 64      ,      __lowercase = 2      ,      __lowercase = 3      ,      __lowercase = 3      ,      __lowercase = True      ,      __lowercase = True      ,      __lowercase = 128      ,      __lowercase=[16, 32, 64, 128]      ,      __lowercase = 7      ,      __lowercase = 4      ,      __lowercase = 37      ,      __lowercase = "gelu"      ,      __lowercase = 0.1      ,      __lowercase = 0.1      ,      __lowercase = 10      ,      __lowercase = 0.0_2      ,      __lowercase = 2      ,      __lowercase = 1      ,      __lowercase = 128      ,      __lowercase = [2, 2, 2, 2]      ,      __lowercase = 2      ,      __lowercase = 2      ,      ):

       """simple docstring"""







       __A  :		Optional[Any]       =			parent
       __A  :		str       =			batch_size
       __A  :		Optional[Any]       =			image_size
       __A  :		str       =			patch_size
       __A  :		Tuple       =			num_channels
       __A  :		Union[str, Any]       =			is_training
       __A  :		Any       =			use_labels
       __A  :		Union[str, Any]       =			hidden_size
       __A  :		Union[str, Any]       =			num_hidden_layers
       __A  :		Dict       =			num_attention_heads
       __A  :		Dict       =			intermediate_size
       __A  :		List[str]       =			hidden_act
       __A  :		Union[str, Any]       =			hidden_dropout_prob
       __A  :		Union[str, Any]       =			attention_probs_dropout_prob
       __A  :		Optional[Any]       =			type_sequence_label_size
       __A  :		int       =			initializer_range
       __A  :		Any       =			encoder_stride
       __A  :		Tuple       =			num_attention_outputs
       __A  :		Any       =			embed_dim
       __A  :		Any       =			embed_dim + 1
       __A  :		Dict       =			resolution
       __A  :		Union[str, Any]       =			depths
       __A  :		int       =			hidden_sizes
       __A  :		Optional[int]       =			dim
       __A  :		Tuple       =			mlp_expansion_ratio


 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		Optional[Any]       =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

       __A  :		List[str]       =			None
       if self.use_labels:
             __A  :		Tuple       =			ids_tensor([self.batch_size]      ,      self.type_sequence_label_size						)

       __A  :		List[str]       =			self.get_config()

       return config, pixel_values, labels


 def  snake_case__   (      self						):

       """simple docstring"""







       return EfficientFormerConfig(
           image_size=self.image_size      ,      patch_size=self.patch_size      ,      num_channels=self.num_channels      ,      hidden_size=self.hidden_size      ,      num_hidden_layers=self.num_hidden_layers      ,      num_attention_heads=self.num_attention_heads      ,      intermediate_size=self.intermediate_size      ,      hidden_act=self.hidden_act      ,      hidden_dropout_prob=self.hidden_dropout_prob      ,      attention_probs_dropout_prob=self.attention_probs_dropout_prob      ,      is_decoder=__lowercase      ,      initializer_range=self.initializer_range      ,      encoder_stride=self.encoder_stride      ,      resolution=self.resolution      ,      depths=self.depths      ,      hidden_sizes=self.hidden_sizes      ,      dim=self.dim      ,      mlp_expansion_ratio=self.mlp_expansion_ratio      ,      )


 def  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase						):

       """simple docstring"""







       __A  :		Dict       =			TFEfficientFormerModel(config=__lowercase						)
       __A  :		List[Any]       =			model(__lowercase      ,      training=__lowercase						)
       self.parent.assertEqual(result.last_hidden_state.shape      ,      (self.batch_size, self.seq_length, self.hidden_size)						)


 def  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase						):

       """simple docstring"""







       __A  :		Any       =			self.type_sequence_label_size
       __A  :		str       =			TFEfficientFormerForImageClassification(__lowercase						)
       __A  :		Any       =			model(__lowercase      ,      labels=__lowercase      ,      training=__lowercase						)
       self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.type_sequence_label_size)						)

       # test greyscale images
       __A  :		List[str]       =			1
       __A  :		Any       =			TFEfficientFormerForImageClassification(__lowercase						)

       __A  :		Optional[Any]       =			floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
       __A  :		Optional[Any]       =			model(__lowercase      ,      labels=__lowercase						)
       self.parent.assertEqual(result.logits.shape      ,      (self.batch_size, self.type_sequence_label_size)						)







 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		int       =			self.prepare_config_and_inputs()
       __A  :		Dict       =			config_and_inputs
       __A  :		Optional[Any]       =			{'pixel_values': pixel_values}
       return config, inputs_dict


@require_tf
class 						_lowerCamelCase					(    snake_case_    ,		snake_case_    ,		unittest.TestCase				):




 '''simple docstring'''
 __lowercase				:		int    							=						(
     (
         TFEfficientFormerModel,
         TFEfficientFormerForImageClassificationWithTeacher,
         TFEfficientFormerForImageClassification,
     )
     if is_tf_available()
     else ()
 )
 __lowercase				:		Optional[int]    							=						(
     {
         '''feature-extraction''': TFEfficientFormerModel,
         '''image-classification''': (
             TFEfficientFormerForImageClassification,
             TFEfficientFormerForImageClassificationWithTeacher,
         ),
     }
     if is_tf_available()
     else {}
 )

 __lowercase				:		Any    							=						False

 __lowercase				:		int    							=						False
 __lowercase				:		Dict    							=						False
 __lowercase				:		Dict    							=						False
 __lowercase				:		Optional[Any]    							=						False


 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		str       =			TFEfficientFormerModelTester(self						)
       __A  :		Any       =			ConfigTester(
           self      ,      config_class=__lowercase      ,      has_text_modality=__lowercase      ,      hidden_size=37						)


 def  snake_case__   (      self						):

       """simple docstring"""







       self.config_tester.run_common_tests()


 @unittest.skip(reason='EfficientFormer does not use inputs_embeds'						)
 def  snake_case__   (      self						):

       """simple docstring"""







       pass


 @unittest.skip(reason='EfficientFormer does not support input and output embeddings'						)
 def  snake_case__   (      self						):

       """simple docstring"""







       pass


 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		Tuple       =			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A  :		Dict       =			model_class(__lowercase						)
             __A  :		Any       =			inspect.signature(model.call						)
             # signature.parameters is an OrderedDict => so arg_names order is deterministic
             __A  :		List[str]       =			[*signature.parameters.keys()]

             __A  :		int       =			['pixel_values']
             self.assertListEqual(arg_names[:1]      ,      __lowercase						)


 def  snake_case__   (      self						):

       """simple docstring"""







       def check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						):
             __A  :		List[Any]       =			model_class(__lowercase						)

             __A  :		Tuple       =			model(**self._prepare_for_class(__lowercase      ,      __lowercase						)      ,      training=__lowercase						)
             __A  :		Optional[Any]       =			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

             __A  :		Any       =			getattr(
                 self.model_tester      ,      'expected_num_hidden_layers'      ,      self.model_tester.num_hidden_layers + 1						)
             self.assertEqual(len(__lowercase						)      ,      __lowercase						)

             if hasattr(self.model_tester      ,      'encoder_seq_length'						):
                   __A  :		str       =			self.model_tester.encoder_seq_length
                   if hasattr(self.model_tester      ,      'chunk_length'						) and self.model_tester.chunk_length > 1:
                         __A  :		Optional[int]       =			seq_length * self.model_tester.chunk_length
             else:
                   __A  :		Tuple       =			self.model_tester.seq_length

             self.assertListEqual(
                 list(hidden_states[-1].shape[-2:]						)      ,      [seq_length, self.model_tester.hidden_size]      ,      )

             if config.is_encoder_decoder:
                   __A  :		List[Any]       =			outputs.decoder_hidden_states

                   self.asseretIsInstance(__lowercase      ,      (list, tuple)						)
                   self.assertEqual(len(__lowercase						)      ,      __lowercase						)
                   __A  :		Dict       =			getattr(self.model_tester      ,      'seq_length'      ,      __lowercase						)
                   __A  :		Dict       =			getattr(self.model_tester      ,      'decoder_seq_length'      ,      __lowercase						)

                   self.assertListEqual(
                       list(hidden_states[-1].shape[-2:]						)      ,      [decoder_seq_length, self.model_tester.hidden_size]      ,      )

       __A  :		str       =			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             __A  :		int       =			True
             check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             __A  :		int       =			True

             check_hidden_states_output(__lowercase      ,      __lowercase      ,      __lowercase						)


 def  snake_case__   (      self      ,      __lowercase      ,      __lowercase      ,      __lowercase=False						):

       """simple docstring"""







       __A  :		List[str]       =			super()._prepare_for_class(__lowercase      ,      __lowercase      ,      return_labels=__lowercase						)

       if return_labels:
             if model_class.__name__ == "TFEfficientFormerForImageClassificationWithTeacher":
                   del inputs_dict["labels"]

       return inputs_dict


 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		int       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*__lowercase						)


 @unittest.skip(reason='EfficientFormer does not implement masked image modeling yet'						)
 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		List[str]       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*__lowercase						)


 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		Tuple       =			self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*__lowercase						)


 @slow
 def  snake_case__   (      self						):

       """simple docstring"""







       for model_name in TF_EFFICIENTFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             __A  :		str       =			TFEfficientFormerModel.from_pretrained(__lowercase						)
             self.assertIsNotNone(__lowercase						)


 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		Union[str, Any]       =			self.model_tester.prepare_config_and_inputs_for_common()
       __A  :		List[Any]       =			True

       __A  :		Dict       =			getattr(self.model_tester      ,      'seq_length'      ,      __lowercase						)
       __A  :		Any       =			getattr(self.model_tester      ,      'encoder_seq_length'      ,      __lowercase						)
       __A  :		Union[str, Any]       =			getattr(self.model_tester      ,      'key_length'      ,      __lowercase						)
       __A  :		Optional[int]       =			getattr(self.model_tester      ,      'chunk_length'      ,      __lowercase						)

       if chunk_length is not None and hasattr(self.model_tester      ,      'num_hashes'						):
             __A  :		int       =			encoder_seq_length * self.model_tester.num_hashes

       for model_class in self.all_model_classes:
             __A  :		Any       =			True
             __A  :		Dict       =			False
             __A  :		int       =			True
             __A  :		Optional[Any]       =			model_class(__lowercase						)

             __A  :		Dict       =			model(**self._prepare_for_class(__lowercase      ,      __lowercase						)      ,      training=__lowercase						)
             __A  :		Optional[Any]       =			outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
             self.assertEqual(len(__lowercase						)      ,      self.model_tester.num_attention_outputs						)

             # check that output_attentions also work using config
             del inputs_dict["output_attentions"]
             __A  :		List[str]       =			True
             __A  :		Union[str, Any]       =			model_class(__lowercase						)
             __A  :		List[str]       =			model(**self._prepare_for_class(__lowercase      ,      __lowercase						)      ,      training=__lowercase						)

             __A  :		Union[str, Any]       =			outputs.encoder_attentions if config.is_encoder_decoder else outputs.attentions
             self.assertEqual(len(__lowercase						)      ,      self.model_tester.num_attention_outputs						)

             if chunk_length is not None:
                   self.assertListEqual(
                       list(attentions[0].shape[-4:]						)      ,      [self.model_tester.num_attention_heads, encoder_seq_length, chunk_length, encoder_key_length]      ,      )
             else:
                   self.assertListEqual(
                       list(attentions[0].shape[-3:]						)      ,      [self.model_tester.num_attention_heads, encoder_seq_length, encoder_key_length]      ,      )







 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		Any       =			self.model_tester.prepare_config_and_inputs_for_common()

       for model_class in self.all_model_classes:
             # Prepare our model
             __A  :		Union[str, Any]       =			model_class(__lowercase						)
             # These are maximally general inputs for the model, with multiple None dimensions
             # Hopefully this will catch any conditionals that fail for flexible shapes
             __A  :		Any       =			{
                 key: tf.keras.Input(shape=val.shape[1:]      ,      dtype=val.dtype      ,      name=__lowercase						)
                 for key, val in model.input_signature.items()
                 if key in model.dummy_inputs
             }
             __A  :		Dict       =			model(__lowercase						)
             self.assertTrue(outputs_dict is not None						)


def 			_lowercase       (				):
      __A  :		Optional[int]       =			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
      return image


@require_tf
@require_vision
class 						_lowerCamelCase					(    unittest.TestCase				):




 '''simple docstring'''


 @cached_property
 def  snake_case__   (      self						):

       """simple docstring"""







       return (
           EfficientFormerImageProcessor.from_pretrained('snap-research/efficientformer-l1-300'						)
           if is_vision_available()
           else None
       )


 @slow
 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		List[str]       =			TFEfficientFormerForImageClassification.from_pretrained('snap-research/efficientformer-l1-300'						)
       __A  :		List[str]       =			self.default_image_processor
       __A  :		List[Any]       =			prepare_img()
       __A  :		Union[str, Any]       =			image_processor(images=__lowercase      ,      return_tensors='tf'						)
       # forward pass
       __A  :		List[str]       =			model(**__lowercase      ,      training=__lowercase						)
       # verify the logits
       __A  :		Dict       =			tf.TensorShape((1, 1_000)						)
       self.assertEqual(outputs.logits.shape      ,      __lowercase						)
       __A  :		Optional[int]       =			tf.constant([-0.0_5_5_5, 0.4_8_2_5, -0.0_8_5_2]						)
       self.assertTrue(np.allclose(outputs.logits[0, :3]      ,      __lowercase      ,      atol=1E-4						)						)







 @slow
 def  snake_case__   (      self						):

       """simple docstring"""







       __A  :		Optional[Any]       =			TFEfficientFormerForImageClassificationWithTeacher.from_pretrained(
           'snap-research/efficientformer-l1-300'						)
       __A  :		Tuple       =			self.default_image_processor
       __A  :		int       =			prepare_img()
       __A  :		List[str]       =			image_processor(images=__lowercase      ,      return_tensors='tf'						)
       # forward pass
       __A  :		int       =			model(**__lowercase      ,      training=__lowercase						)
       # verify the logits
       __A  :		Any       =			tf.TensorShape((1, 1_000)						)
       self.assertEqual(outputs.logits.shape      ,      __lowercase						)
       __A  :		int       =			tf.constant([-0.1_3_1_2, 0.4_3_5_3, -1.0_4_9_9]						)
       self.assertTrue(np.allclose(outputs.logits[0, :3]      ,      __lowercase      ,      atol=1E-4						)						)










'''simple docstring'''
from math import pi, sqrt, tan


def 			_lowercase       (				UpperCamelCase__       :					float			):
 if side_length < 0:
  raise ValueError('surface_area_cube() only accepts non-negative values'			)
 return 6 * side_length**2


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 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 			_lowercase       (				UpperCamelCase__       :					float			):
 if radius < 0:
  raise ValueError('surface_area_sphere() only accepts non-negative values'			)
 return 4 * pi * radius**2


def 			_lowercase       (				UpperCamelCase__       :					float			):
 if radius < 0:
  raise ValueError('surface_area_hemisphere() only accepts non-negative values'			)
 return 3 * pi * radius**2


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 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 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 if radius_a < 0 or radius_a < 0 or height < 0:
  raise ValueError(
      'surface_area_conical_frustum() only accepts non-negative values'			)
 __A  :		Optional[Any]       =			(height**2 + (radius_a - radius_a) ** 2) ** 0.5
 return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 if radius < 0 or height < 0:
  raise ValueError('surface_area_cylinder() only accepts non-negative values'			)
 return 2 * pi * radius * (height + radius)


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 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(UpperCamelCase__,				2			) * torus_radius * tube_radius


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 if length < 0 or width < 0:
  raise ValueError('area_rectangle() only accepts non-negative values'			)
 return length * width


def 			_lowercase       (				UpperCamelCase__       :					float			):
 if side_length < 0:
  raise ValueError('area_square() only accepts non-negative values'			)
 return side_length**2


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 if base < 0 or height < 0:
  raise ValueError('area_triangle() only accepts non-negative values'			)
 return (base * height) / 2


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 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'			)
 __A  :		int       =			(sidea + sidea + sidea) / 2
 __A  :		List[Any]       =			sqrt(
     semi_perimeter
     * (semi_perimeter - sidea)
     * (semi_perimeter - sidea)
     * (semi_perimeter - sidea)			)
 return area


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 if base < 0 or height < 0:
  raise ValueError('area_parallelogram() only accepts non-negative values'			)
 return base * height


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 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 			_lowercase       (				UpperCamelCase__       :					float			):
 if radius < 0:
  raise ValueError('area_circle() only accepts non-negative values'			)
 return pi * radius**2


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 if radius_x < 0 or radius_y < 0:
  raise ValueError('area_ellipse() only accepts non-negative values'			)
 return pi * radius_x * radius_y


def 			_lowercase       (				UpperCamelCase__       :					float,				UpperCamelCase__       :					float			):
 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 			_lowercase       (				UpperCamelCase__       :					int,				UpperCamelCase__       :					float			):
 if not isinstance(UpperCamelCase__,				UpperCamelCase__			) 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) = }''')






