


from __future__ import annotations

from math import pi, pow

def  lowercase_						(						_A     :       int | float		):

      """simple docstring"""




      if side_length < 0:
            raise ValueError("vol_cube() only accepts non-negative values"		)
      return pow(_A       ,   3		)

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if height < 0 or radius < 0:
            raise ValueError("vol_spherical_cap() only accepts non-negative values"		)
      # Volume is 1/3 pi * height squared * (3 * radius - height)
      return 1 / 3 * pi * pow(_A       ,   2		) * (3 * radius - height)

def  lowercase_						(						_A     :       float       ,   _A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if radius_a < 0 or radius_a < 0 or centers_distance < 0:
            raise ValueError("vol_spheres_intersect() only accepts non-negative values"		)
      if centers_distance == 0:
            return vol_sphere(min(_A       ,   _A		)		)

      lowerCamelCase__						:							Tuple       =    (
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )
      lowerCamelCase__						:							Union[str, Any]       =    (
          (radius_a - radius_a + centers_distance)
          * (radius_a + radius_a - centers_distance)
          / (2 * centers_distance)
      )

      return vol_spherical_cap(_A       ,   _A		) + vol_spherical_cap(_A       ,   _A		)

def  lowercase_						(						_A     :       float       ,   _A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if radius_a <= 0 or radius_a <= 0 or centers_distance < 0:
            raise ValueError(
                "vol_spheres_union() only accepts non-negative values, non-zero radius"		)

      if centers_distance == 0:
            return vol_sphere(max(_A       ,   _A		)		)

      return (
          vol_sphere(_A		)
          + vol_sphere(_A		)
          - vol_spheres_intersect(_A       ,   _A       ,   _A		)
      )

def  lowercase_						(						_A     :       float       ,   _A     :       float       ,   _A     :       float		):

      """simple docstring"""




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

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if height < 0 or area_of_base < 0:
            raise ValueError("vol_cone() only accepts non-negative values"		)
      return area_of_base * height / 3.0

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if height < 0 or radius < 0:
            raise ValueError("vol_right_circ_cone() only accepts non-negative values"		)
      return pi * pow(_A       ,   2		) * height / 3.0

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if height < 0 or area_of_base < 0:
            raise ValueError("vol_prism() only accepts non-negative values"		)
      return float(area_of_base * height		)

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if height < 0 or area_of_base < 0:
            raise ValueError("vol_pyramid() only accepts non-negative values"		)
      return area_of_base * height / 3.0

def  lowercase_						(						_A     :       float		):

      """simple docstring"""




      if radius < 0:
            raise ValueError("vol_sphere() only accepts non-negative values"		)
      # Volume is 4/3 * pi * radius cubed
      return 4 / 3 * pi * pow(_A       ,   3		)

def  lowercase_						(						_A     :       float		):

      """simple docstring"""




      if radius < 0:
            raise ValueError("vol_hemisphere() only accepts non-negative values"		)
      # Volume is radius cubed * pi * 2/3
      return pow(_A       ,   3		) * pi * 2 / 3

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if height < 0 or radius < 0:
            raise ValueError("vol_circular_cylinder() only accepts non-negative values"		)
      # Volume is radius squared * height * pi
      return pow(_A       ,   2		) * height * pi

def  lowercase_						(						_A     :       float       ,   _A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if inner_radius < 0 or outer_radius < 0 or height < 0:
            raise ValueError(
                "vol_hollow_circular_cylinder() only accepts non-negative values"		)
      if outer_radius <= inner_radius:
            raise ValueError("outer_radius must be greater than inner_radius"		)
      return pi * (pow(_A       ,   2		) - pow(_A       ,   2		)) * height

def  lowercase_						(						_A     :       float       ,   _A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if radius_a < 0 or radius_a < 0 or height < 0:
            raise ValueError("vol_conical_frustum() only accepts non-negative values"		)
      return (
          1
          / 3
          * pi
          * height
          * (pow(_A       ,   2		) + pow(_A       ,   2		) + radius_a * radius_a)
      )

def  lowercase_						(						_A     :       float       ,   _A     :       float		):

      """simple docstring"""




      if torus_radius < 0 or tube_radius < 0:
            raise ValueError("vol_torus() only accepts non-negative values"		)
      return 2 * pow(_A       ,   2		) * torus_radius * pow(_A       ,   2		)

def  lowercase_						(						):

      """simple docstring"""




      print("Volumes:"		)
      print(F"Cube: {vol_cube(2		) = }"		)  # = 8
      print(F"Cuboid: {vol_cuboid(2       ,   2       ,   2		) = }"		)  # = 8
      print(F"Cone: {vol_cone(2       ,   2		) = }"		)  # ~= 1.33
      print(F"Right Circular Cone: {vol_right_circ_cone(2       ,   2		) = }"		)  # ~= 8.38
      print(F"Prism: {vol_prism(2       ,   2		) = }"		)  # = 4
      print(F"Pyramid: {vol_pyramid(2       ,   2		) = }"		)  # ~= 1.33
      print(F"Sphere: {vol_sphere(2		) = }"		)  # ~= 33.5
      print(F"Hemisphere: {vol_hemisphere(2		) = }"		)  # ~= 16.75
      print(F"Circular Cylinder: {vol_circular_cylinder(2       ,   2		) = }"		)  # ~= 25.1
      print(F"Torus: {vol_torus(2       ,   2		) = }"		)  # ~= 157.9
      print(F"Conical Frustum: {vol_conical_frustum(2       ,   2       ,   4		) = }"		)  # ~= 58.6
      print(F"Spherical cap: {vol_spherical_cap(1       ,   2		) = }"		)  # ~= 5.24
      print(F"Spheres intersetion: {vol_spheres_intersect(2       ,   2       ,   1		) = }"		)  # ~= 21.21
      print(F"Spheres union: {vol_spheres_union(2       ,   2       ,   1		) = }"		)  # ~= 45.81
      print(
          F"Hollow Circular Cylinder: {vol_hollow_circular_cylinder(1       ,   2       ,   3		) = }"		)  # ~= 28.3


if __name__ == "__main__":
    main()






import copy
import inspect
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import VivitConfig
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor


if is_torch_available():
    import torch
    from torch import nn

    from transformers import MODEL_FOR_VIDEO_CLASSIFICATION_MAPPING, VivitForVideoClassification, VivitModel
    from transformers.models.vivit.modeling_vivit import VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from transformers import VivitImageProcessor







class      _lowercase					:


       """simple docstring"""




       def __init__(  self				:     Union[str, Any]   , __lowerCamelCase				:     List[Any]   , __lowerCamelCase				:     int=2   , __lowerCamelCase				:     Any=True   , __lowerCamelCase				:     Union[str, Any]=True   , __lowerCamelCase				:     int=10   , __lowerCamelCase				:     str=10   , __lowerCamelCase				:     int=8   , __lowerCamelCase				:     Optional[int]=[2, 4, 4]   , __lowerCamelCase				:     List[Any]=3   , __lowerCamelCase				:     str=768   , __lowerCamelCase				:     int=5   , __lowerCamelCase				:     Any=4   , __lowerCamelCase				:     int=37   , __lowerCamelCase				:     int="gelu_fast"   , __lowerCamelCase				:     int=0.0   , __lowerCamelCase				:     Optional[int]=0.0   , __lowerCamelCase				:     Union[str, Any]=0.0_2   , __lowerCamelCase				:     Any=1E-0_6   , __lowerCamelCase				:     Optional[int]=True   , __lowerCamelCase				:     Tuple=None   , ):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[Any]       =    parent
             lowerCamelCase__						:							int       =    batch_size
             lowerCamelCase__						:							List[Any]       =    is_training
             lowerCamelCase__						:							Optional[Any]       =    use_labels
             lowerCamelCase__						:							List[str]       =    num_labels
             lowerCamelCase__						:							Union[str, Any]       =    image_size
             lowerCamelCase__						:							Tuple       =    num_frames
             lowerCamelCase__						:							Union[str, Any]       =    tubelet_size
             lowerCamelCase__						:							Optional[int]       =    num_channels
             lowerCamelCase__						:							Any       =    hidden_size
             lowerCamelCase__						:							Optional[Any]       =    num_hidden_layers
             lowerCamelCase__						:							List[str]       =    num_attention_heads
             lowerCamelCase__						:							List[Any]       =    intermediate_size
             lowerCamelCase__						:							Union[str, Any]       =    hidden_act
             lowerCamelCase__						:							Any       =    hidden_dropout_prob
             lowerCamelCase__						:							Union[str, Any]       =    attention_probs_dropout_prob
             lowerCamelCase__						:							List[Any]       =    initializer_range
             lowerCamelCase__						:							Optional[int]       =    layer_norm_eps
             lowerCamelCase__						:							Tuple       =    qkv_bias
             lowerCamelCase__						:							List[Any]       =    scope

             lowerCamelCase__						:							Union[str, Any]       =    (
                 (self.image_size // self.tubelet_size[2])
                 * (self.image_size // self.tubelet_size[1])
                 * (self.num_frames // self.tubelet_size[0])
             ) + 1  # CLS token





       def 		lowerCAmelCase	(  self				:     List[Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    floats_tensor(
                 [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]			)

             lowerCamelCase__						:							Optional[int]       =    None
             if self.use_labels:
                   lowerCamelCase__						:							Optional[Any]       =    ids_tensor([self.batch_size]   , self.num_labels			)

             lowerCamelCase__						:							Any       =    self.get_config()

             return config, pixel_values, labels





       def 		lowerCAmelCase	(  self				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    VivitConfig(
                 num_frames=self.num_frames   , image_size=self.image_size   , tubelet_size=self.tubelet_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   , initializer_range=self.initializer_range   , layer_norm_eps=self.layer_norm_eps   , qkv_bias=self.qkv_bias   , )
             lowerCamelCase__						:							Union[str, Any]       =    self.num_labels
             return config





       def 		lowerCAmelCase	(  self				:     Optional[int]   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__						:							Tuple       =    VivitModel(config=__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()
             lowerCamelCase__						:							Any       =    model(__lowerCamelCase			)
             self.parent.assertEqual(result.last_hidden_state.shape   , (self.batch_size, self.seq_length, self.hidden_size)			)





       def 		lowerCAmelCase	(  self				:     int   , __lowerCamelCase				:     Union[str, Any]   , __lowerCamelCase				:     Optional[int]   , __lowerCamelCase				:     Optional[int]			):


             '''simple docstring'''



             lowerCamelCase__						:							Dict       =    VivitForVideoClassification(__lowerCamelCase			)
             model.to(__lowerCamelCase			)
             model.eval()

             lowerCamelCase__						:							List[str]       =    model(__lowerCamelCase			)

             # verify the logits shape
             lowerCamelCase__						:							Optional[int]       =    torch.Size((self.batch_size, self.num_labels)			)
             self.parent.assertEqual(result.logits.shape   , __lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Optional[Any]			):


             '''simple docstring'''



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







@require_torch
class      _lowercase					(				lowercase__				,    unittest.TestCase):


       """simple docstring"""




       A__   		=     (VivitModel, VivitForVideoClassification) if is_torch_available() else ()

       A__   		=     False
       A__   		=     False
       A__   		=     False
       A__   		=     False





       def 		lowerCAmelCase	(  self				:     Optional[int]			):


             '''simple docstring'''



             lowerCamelCase__						:							Any       =    VivitModelTester(self			)
             lowerCamelCase__						:							Any       =    ConfigTester(self   , config_class=__lowerCamelCase   , has_text_modality=__lowerCamelCase   , hidden_size=37			)





       def 		lowerCAmelCase	(  self				:     int   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Dict   , __lowerCamelCase				:     Union[str, Any]=False			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    copy.deepcopy(__lowerCamelCase			)

             if return_labels:
                   if model_class in get_values(__lowerCamelCase			):
                         lowerCamelCase__						:							List[Any]       =    torch.zeros(
                             self.model_tester.batch_size   , dtype=torch.long   , device=__lowerCamelCase			)

             return inputs_dict





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             self.config_tester.run_common_tests()





       @unittest.skip(reason="Vivit does not use inputs_embeds"			)
       def 		lowerCAmelCase	(  self				:     int			):


             '''simple docstring'''



             pass





       def 		lowerCAmelCase	(  self				:     Union[str, Any]			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							int       =    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							str       =    model_class(__lowerCamelCase			)
                   self.assertIsInstance(model.get_input_embeddings()   , (nn.Module)			)
                   lowerCamelCase__						:							Dict       =    model.get_output_embeddings()
                   self.assertTrue(x is None or isinstance(__lowerCamelCase   , nn.Linear			)			)





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							str       =    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							Tuple       =    model_class(__lowerCamelCase			)
                   lowerCamelCase__						:							List[Any]       =    inspect.signature(model.forward			)
                   # signature.parameters is an OrderedDict => so arg_names order is deterministic
                   lowerCamelCase__						:							int       =    [*signature.parameters.keys()]

                   lowerCamelCase__						:							Any       =    ["pixel_values", "head_mask"]
                   self.assertListEqual(arg_names[:2]   , __lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Dict			):


             '''simple docstring'''



             lowerCamelCase__						:							str       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_model(*__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							int       =    self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_for_video_classification(*__lowerCamelCase			)





       @slow
       def 		lowerCAmelCase	(  self				:     List[Any]			):


             '''simple docstring'''



             for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   lowerCamelCase__						:							str       =    VivitModel.from_pretrained(__lowerCamelCase			)
                   self.assertIsNotNone(__lowerCamelCase			)





       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__       ,  lowerCamelCase__						:							Dict       =    self.model_tester.prepare_config_and_inputs_for_common()
             lowerCamelCase__						:							List[str]       =    True

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							Any       =    self.model_tester.seq_length

                   lowerCamelCase__						:							List[str]       =    True
                   lowerCamelCase__						:							List[str]       =    False
                   lowerCamelCase__						:							Tuple       =    True
                   lowerCamelCase__						:							Dict       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()
                   with torch.no_grad():
                         lowerCamelCase__						:							str       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)
                   lowerCamelCase__						:							Dict       =    outputs.attentions
                   self.assertEqual(len(__lowerCamelCase			)   , self.model_tester.num_hidden_layers			)

                   # check that output_attentions also work using config
                   del inputs_dict["output_attentions"]
                   lowerCamelCase__						:							List[str]       =    True
                   lowerCamelCase__						:							Union[str, Any]       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()
                   with torch.no_grad():
                         lowerCamelCase__						:							List[str]       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)
                   lowerCamelCase__						:							Optional[int]       =    outputs.attentions
                   self.assertEqual(len(__lowerCamelCase			)   , self.model_tester.num_hidden_layers			)

                   self.assertListEqual(
                       list(attentions[0].shape[-3:]			)   , [self.model_tester.num_attention_heads, seq_len, seq_len]   , )
                   lowerCamelCase__						:							int       =    len(__lowerCamelCase			)

                   # Check attention is always last and order is fine
                   lowerCamelCase__						:							Optional[int]       =    True
                   lowerCamelCase__						:							str       =    True
                   lowerCamelCase__						:							Optional[int]       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()
                   with torch.no_grad():
                         lowerCamelCase__						:							Union[str, Any]       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)

                   self.assertEqual(out_len + 1   , len(__lowerCamelCase			)			)

                   lowerCamelCase__						:							Any       =    outputs.attentions

                   self.assertEqual(len(__lowerCamelCase			)   , self.model_tester.num_hidden_layers			)

                   self.assertListEqual(
                       list(self_attentions[0].shape[-3:]			)   , [self.model_tester.num_attention_heads, seq_len, seq_len]   , )





       def 		lowerCAmelCase	(  self				:     List[str]			):


             '''simple docstring'''



             def check_hidden_states_output(__lowerCamelCase				:     str   , __lowerCamelCase				:     List[str]   , __lowerCamelCase				:     Tuple			):
                   lowerCamelCase__						:							Union[str, Any]       =    model_class(__lowerCamelCase			)
                   model.to(__lowerCamelCase			)
                   model.eval()

                   with torch.no_grad():
                         lowerCamelCase__						:							Optional[Any]       =    model(**self._prepare_for_class(__lowerCamelCase   , __lowerCamelCase			)			)

                   lowerCamelCase__						:							List[Any]       =    outputs.hidden_states
                   lowerCamelCase__						:							Optional[int]       =    self.model_tester.num_hidden_layers + 1
                   self.assertEqual(len(__lowerCamelCase			)   , __lowerCamelCase			)

                   lowerCamelCase__						:							Optional[int]       =    self.model_tester.seq_length

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

             lowerCamelCase__       ,  lowerCamelCase__						:							Optional[Any]       =    self.model_tester.prepare_config_and_inputs_for_common()

             for model_class in self.all_model_classes:
                   lowerCamelCase__						:							Tuple       =    True
                   check_hidden_states_output(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase			)

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

                   check_hidden_states_output(__lowerCamelCase   , __lowerCamelCase   , __lowerCamelCase			)





       @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."			)
       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             pass



def  lowercase_						(						):

      """simple docstring"""




      lowerCamelCase__						:							str       =    hf_hub_download(
          repo_id="hf-internal-testing/spaghetti-video"       ,   filename="eating_spaghetti_32_frames.npy"       ,   repo_type="dataset"		)
      lowerCamelCase__						:							Union[str, Any]       =    np.load(_A		)
      return list(_A		)







@require_torch
@require_vision
class      _lowercase					(				unittest.TestCase):


       """simple docstring"""




       @cached_property
       def 		lowerCAmelCase	(  self				:     str			):


             '''simple docstring'''



             return VivitImageProcessor() if is_vision_available() else None





       @slow
       def 		lowerCAmelCase	(  self				:     Tuple			):


             '''simple docstring'''



             lowerCamelCase__						:							Optional[int]       =    VivitForVideoClassification.from_pretrained("google/vivit-b-16x2-kinetics400"			).to(__lowerCamelCase			)

             lowerCamelCase__						:							Tuple       =    self.default_image_processor
             lowerCamelCase__						:							List[str]       =    prepare_video()
             lowerCamelCase__						:							Optional[int]       =    image_processor(__lowerCamelCase   , return_tensors="pt"			).to(__lowerCamelCase			)

             # forward pass
             with torch.no_grad():
                   lowerCamelCase__						:							Optional[int]       =    model(**__lowerCamelCase			)

             # verify the logits
             lowerCamelCase__						:							str       =    torch.Size((1, 400)			)
             self.assertEqual(outputs.logits.shape   , __lowerCamelCase			)

             # taken from original model
             lowerCamelCase__						:							str       =    torch.tensor([-1.0_5_4_3, 2.0_7_6_4, -0.2_1_0_4, 0.4_4_3_9, -0.9_6_5_8]			).to(__lowerCamelCase			)

             self.assertTrue(torch.allclose(outputs.logits[0, :5]   , __lowerCamelCase   , atol=1E-4			)			)


