code: 
  '''simple docstring'''
  
  
  
  
  
  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  lowerCAmelCase__   :
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    def __init__(self  : int	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : Optional[int]=2	, lowerCAmelCase_  : Tuple=True	, lowerCAmelCase_  : List[str]=True	, lowerCAmelCase_  : Union[str, Any]=10	, lowerCAmelCase_  : Any=10	, lowerCAmelCase_  : int=8	, lowerCAmelCase_  : Optional[int]=[2, 4, 4]	, lowerCAmelCase_  : List[str]=3	, lowerCAmelCase_  : List[str]=7_68	, lowerCAmelCase_  : Union[str, Any]=5	, lowerCAmelCase_  : Any=4	, lowerCAmelCase_  : Dict=37	, lowerCAmelCase_  : Union[str, Any]="gelu_fast"	, lowerCAmelCase_  : List[Any]=0.0	, lowerCAmelCase_  : int=0.0	, lowerCAmelCase_  : List[str]=0.02	, lowerCAmelCase_  : Optional[Any]=1E-06	, lowerCAmelCase_  : List[Any]=True	, lowerCAmelCase_  : List[str]=None	, )   ->       List[Any]:
          snake_case_						       =							parent
          snake_case_						       =							batch_size
          snake_case_						       =							is_training
          snake_case_						       =							use_labels
          snake_case_						       =							num_labels
          snake_case_						       =							image_size
          snake_case_						       =							num_frames
          snake_case_						       =							tubelet_size
          snake_case_						       =							num_channels
          snake_case_						       =							hidden_size
          snake_case_						       =							num_hidden_layers
          snake_case_						       =							num_attention_heads
          snake_case_						       =							intermediate_size
          snake_case_						       =							hidden_act
          snake_case_						       =							hidden_dropout_prob
          snake_case_						       =							attention_probs_dropout_prob
          snake_case_						       =							initializer_range
          snake_case_						       =							layer_norm_eps
          snake_case_						       =							qkv_bias
          snake_case_						       =							scope
  
          snake_case_						       =							(
              (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  : str    )   ->       int:
          snake_case_						       =							floats_tensor(
              [self.batch_size, self.num_frames, self.num_channels, self.image_size, self.image_size]    )
  
          snake_case_						       =							None
          if self.use_labels:
                snake_case_						       =							ids_tensor([self.batch_size]	, self.num_labels    )
  
          snake_case_						       =							self.get_config()
  
          return config, pixel_values, labels
  
    def 		_lowerCamelCase	(self  : Dict    )   ->       Any:
          snake_case_						       =							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	, )
          snake_case_						       =							self.num_labels
          return config
  
    def 		_lowerCamelCase	(self  : Tuple	, lowerCAmelCase_  : List[Any]	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : Optional[int]    )   ->       Dict:
          snake_case_						       =							VivitModel(config=lowerCAmelCase_    )
          model.to(lowerCAmelCase_    )
          model.eval()
          snake_case_						       =							model(lowerCAmelCase_    )
          self.parent.assertEqual(result.last_hidden_state.shape	, (self.batch_size, self.seq_length, self.hidden_size)    )
  
    def 		_lowerCamelCase	(self  : List[Any]	, lowerCAmelCase_  : Any	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : str    )   ->       str:
          snake_case_						       =							VivitForVideoClassification(lowerCAmelCase_    )
          model.to(lowerCAmelCase_    )
          model.eval()
  
          snake_case_						       =							model(lowerCAmelCase_    )
  
          # verify the logits shape
          snake_case_						       =							torch.Size((self.batch_size, self.num_labels)    )
          self.parent.assertEqual(result.logits.shape	, lowerCAmelCase_    )
  
  
    def 		_lowerCamelCase	(self  : Optional[int]    )   ->       int:
          snake_case_						       =							self.prepare_config_and_inputs()
          snake_case_       ,	snake_case_       ,	snake_case_						       =							config_and_inputs
          snake_case_						       =							{"pixel_values": pixel_values}
          return config, inputs_dict
  
  
  
  @require_torch
  class  lowerCAmelCase__   (       UpperCamelCase					,							unittest.TestCase       ):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    _UpperCamelCase						= (VivitModel, VivitForVideoClassification) if is_torch_available() else ()
  
    _UpperCamelCase						= False
    _UpperCamelCase						= False
    _UpperCamelCase						= False
    _UpperCamelCase						= False
  
    def 		_lowerCamelCase	(self  : str    )   ->       Any:
          snake_case_						       =							VivitModelTester(self    )
          snake_case_						       =							ConfigTester(self	, config_class=lowerCAmelCase_	, has_text_modality=lowerCAmelCase_	, hidden_size=37    )
  
    def 		_lowerCamelCase	(self  : Any	, lowerCAmelCase_  : List[str]	, lowerCAmelCase_  : str	, lowerCAmelCase_  : Union[str, Any]=False    )   ->       Optional[int]:
          snake_case_						       =							copy.deepcopy(lowerCAmelCase_    )
  
          if return_labels:
                if model_class in get_values(lowerCAmelCase_    ):
                      snake_case_						       =							torch.zeros(
                          self.model_tester.batch_size	, dtype=torch.long	, device=lowerCAmelCase_    )
  
          return inputs_dict
  
    def 		_lowerCamelCase	(self  : Optional[Any]    )   ->       Optional[int]:
          self.config_tester.run_common_tests()
  
    @unittest.skip(reason="Vivit does not use inputs_embeds"    )
    def 		_lowerCamelCase	(self  : Tuple    )   ->       Optional[int]:
          pass
  
    def 		_lowerCamelCase	(self  : int    )   ->       Optional[Any]:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
                snake_case_						       =							model_class(lowerCAmelCase_    )
                self.assertIsInstance(model.get_input_embeddings()	, (nn.Module)    )
                snake_case_						       =							model.get_output_embeddings()
                self.assertTrue(x is None or isinstance(lowerCAmelCase_	, nn.Linear    )    )
  
    def 		_lowerCamelCase	(self  : Any    )   ->       List[str]:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
                snake_case_						       =							model_class(lowerCAmelCase_    )
                snake_case_						       =							inspect.signature(model.forward    )
                # signature.parameters is an OrderedDict => so arg_names order is deterministic
                snake_case_						       =							[*signature.parameters.keys()]
  
                snake_case_						       =							["pixel_values", "head_mask"]
                self.assertListEqual(arg_names[:2]	, lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : Any    )   ->       Tuple:
          snake_case_						       =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : int    )   ->       Optional[int]:
          snake_case_						       =							self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_video_classification(*lowerCAmelCase_    )
  
    @slow
    def 		_lowerCamelCase	(self  : Dict    )   ->       Union[str, Any]:
          for model_name in VIVIT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                snake_case_						       =							VivitModel.from_pretrained(lowerCAmelCase_    )
                self.assertIsNotNone(lowerCAmelCase_    )
  
    def 		_lowerCamelCase	(self  : Dict    )   ->       Dict:
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
          snake_case_						       =							True
  
          for model_class in self.all_model_classes:
                snake_case_						       =							self.model_tester.seq_length
  
                snake_case_						       =							True
                snake_case_						       =							False
                snake_case_						       =							True
                snake_case_						       =							model_class(lowerCAmelCase_    )
                model.to(lowerCAmelCase_    )
                model.eval()
                with torch.no_grad():
                      snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
                snake_case_						       =							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"]
                snake_case_						       =							True
                snake_case_						       =							model_class(lowerCAmelCase_    )
                model.to(lowerCAmelCase_    )
                model.eval()
                with torch.no_grad():
                      snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
                snake_case_						       =							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]	, )
                snake_case_						       =							len(lowerCAmelCase_    )
  
                # Check attention is always last and order is fine
                snake_case_						       =							True
                snake_case_						       =							True
                snake_case_						       =							model_class(lowerCAmelCase_    )
                model.to(lowerCAmelCase_    )
                model.eval()
                with torch.no_grad():
                      snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
  
                self.assertEqual(out_len + 1	, len(lowerCAmelCase_    )    )
  
                snake_case_						       =							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  : Optional[int]    )   ->       Optional[int]:
          def check_hidden_states_output(lowerCAmelCase_  : int	, lowerCAmelCase_  : Union[str, Any]	, lowerCAmelCase_  : List[str]    ):
                snake_case_						       =							model_class(lowerCAmelCase_    )
                model.to(lowerCAmelCase_    )
                model.eval()
  
                with torch.no_grad():
                      snake_case_						       =							model(**self._prepare_for_class(lowerCAmelCase_	, lowerCAmelCase_    )    )
  
                snake_case_						       =							outputs.hidden_states
                snake_case_						       =							self.model_tester.num_hidden_layers + 1
                self.assertEqual(len(lowerCAmelCase_    )	, lowerCAmelCase_    )
  
                snake_case_						       =							self.model_tester.seq_length
  
                self.assertListEqual(
                    list(hidden_states[0].shape[-2:]    )	, [seq_length, self.model_tester.hidden_size]	, )
  
          snake_case_       ,	snake_case_						       =							self.model_tester.prepare_config_and_inputs_for_common()
  
          for model_class in self.all_model_classes:
                snake_case_						       =							True
                check_hidden_states_output(lowerCAmelCase_	, lowerCAmelCase_	, lowerCAmelCase_    )
  
                # check that output_hidden_states also work using config
                del inputs_dict["output_hidden_states"]
                snake_case_						       =							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  : Union[str, Any]    )   ->       str:
          pass
  
  def   snake_case_       (							):
        snake_case_						       =							hf_hub_download(
            repo_id="hf-internal-testing/spaghetti-video" ,					filename="eating_spaghetti_32_frames.npy" ,					repo_type="dataset"			)
        snake_case_						       =							np.load(_a			)
        return list(_a			)
  
  
  
  
  @require_torch
  @require_vision
  class  lowerCAmelCase__   (       unittest.TestCase       ):
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    @cached_property
    def 		_lowerCamelCase	(self  : Dict    )   ->       Tuple:
          return VivitImageProcessor() if is_vision_available() else None
  
  
    @slow
    def 		_lowerCamelCase	(self  : Union[str, Any]    )   ->       List[str]:
          snake_case_						       =							VivitForVideoClassification.from_pretrained("google/vivit-b-16x2-kinetics400"    ).to(lowerCAmelCase_    )
  
          snake_case_						       =							self.default_image_processor
          snake_case_						       =							prepare_video()
          snake_case_						       =							image_processor(lowerCAmelCase_	, return_tensors="pt"    ).to(lowerCAmelCase_    )
  
          # forward pass
          with torch.no_grad():
                snake_case_						       =							model(**lowerCAmelCase_    )
  
          # verify the logits
          snake_case_						       =							torch.Size((1, 4_00)    )
          self.assertEqual(outputs.logits.shape	, lowerCAmelCase_    )
  
          # taken from original model
          snake_case_						       =							torch.tensor([-1.0_543, 2.0_764, -0.2_104, 0.4_439, -0.9_658]    ).to(lowerCAmelCase_    )
  
          self.assertTrue(torch.allclose(outputs.logits[0, :5]	, lowerCAmelCase_	, atol=1E-4    )    )
  
  
style_context: 
  '''simple docstring'''
  
  
  
  
  
  from __future__ import annotations
  
  A           =   [2, 1, 4, 5, 6, 0, 8, 9, 1, 2, 0, 6, 4, 2, 0, 6, 5, 3, 2, 7]
  
  
  
  class  lowerCAmelCase__   :
  
  
  
    '''simple docstring'''
  
  
  
  
  
  
    def __init__(self  : Optional[int]	, lowerCAmelCase_  : int    )   ->       None:
          snake_case_						       =							-1
          snake_case_						       =							-1
          snake_case_						       =							[-1] * length
          snake_case_						       =							None
          snake_case_						       =							None
  
  
    def __repr__(self  : List[Any]    )   ->       str:
          return f'''Node(min_value={self.minn} max_value={self.maxx})'''
  
  def   snake_case_       (							_a     :							list[int]			):
        snake_case_						       =							Node(len(_a			)			)
        snake_case_       ,	snake_case_						       =							min(_a			), max(_a			)
        # Leaf node case where the node contains only one unique value
        if root.minn == root.maxx:
              return root
        snake_case_						       =							(root.minn + root.maxx) // 2
  
        snake_case_						       =							[]
        snake_case_						       =							[]
  
        for index, num in enumerate(_a			):
              if num <= pivot:
                    left_arr.append(_a			)
              else:
                    right_arr.append(_a			)
              snake_case_						       =							len(_a			)
        snake_case_						       =							build_tree(_a			)
        snake_case_						       =							build_tree(_a			)
        return root
  def   snake_case_       (							_a     :							Node | None ,					_a     :							int ,					_a     :							int			):
        if index < 0 or node is None:
              return 0
        # Leaf node cases
        if node.minn == node.maxx:
              return index + 1 if node.minn == num else 0
        snake_case_						       =							(node.minn + node.maxx) // 2
        if num <= pivot:
              # go the left subtree and map index to the left subtree
              return rank_till_index(node.left ,					_a ,					node.map_left[index] - 1			)
        else:
              # go to the right subtree and map index to the right subtree
              return rank_till_index(node.right ,					_a ,					index - node.map_left[index]			)
  def   snake_case_       (							_a     :							Node | None ,					_a     :							int ,					_a     :							int ,					_a     :							int			):
        if start > end:
              return 0
        snake_case_						       =							rank_till_index(_a ,					_a ,					_a			)
        snake_case_						       =							rank_till_index(_a ,					_a ,					start - 1			)
        return rank_till_end - rank_before_start
  def   snake_case_       (							_a     :							Node | None ,					_a     :							int ,					_a     :							int ,					_a     :							int			):
        if index > (end - start) or start > end or node is None:
              return -1
        # Leaf node case
        if node.minn == node.maxx:
              return node.minn
        # Number of elements in the left subtree in interval [start, end]
        snake_case_						       =							node.map_left[end] - (
            node.map_left[start - 1] if start else 0
        )
        if num_elements_in_left_tree > index:
              return quantile(
                  node.left ,					_a ,					(node.map_left[start - 1] if start else 0) ,					node.map_left[end] - 1 ,					)
        else:
              return quantile(
                  node.right ,					index - num_elements_in_left_tree ,					start - (node.map_left[start - 1] if start else 0) ,					end - node.map_left[end] ,					)
  def   snake_case_       (							_a     :							Node | None ,					_a     :							int ,					_a     :							int ,					_a     :							int ,					_a     :							int			):
        if (
            start > end
            or node is None
            or start_num > end_num
            or node.minn > end_num
            or node.maxx < start_num
        ):
              return 0
        if start_num <= node.minn and node.maxx <= end_num:
              return end - start + 1
        snake_case_						       =							range_counting(
            node.left ,					(node.map_left[start - 1] if start else 0) ,					node.map_left[end] - 1 ,					_a ,					_a ,					)
        snake_case_						       =							range_counting(
            node.right ,					start - (node.map_left[start - 1] if start else 0) ,					end - node.map_left[end] ,					_a ,					_a ,					)
        return left + right
  
  
  if __name__ == "__main__":
       import doctest
  
       doctest.testmod()
  
  